(57)【要約】【課題】実行しているプログラムにパッチを当てるように構成されるデータ処理システム及び方法を提供する。【解決手段】本発明に係る方法は、実行プログラムの少なくとも１つの関数にパッチを当てる方法であって、少なくとも１つの関数が実行されていない時を確定することと、少なくとも１つの関数におけるオリジナルコードを、パッチが当てられたコードに置き換えることを含む。好適には、少なくとも１つの関数が実行されていない時を確定することは、保守期間の間待機することを含む。また好適には、保守期間は、少なくとも、前記少なくとも１つの関数の最大実行時間と同様の長さである。【選択図】図１
2009009545.tif 000002
【特許請求の範囲】
【請求項１】
実行プログラムの少なくとも１つの関数にパッチを当てる方法であって、
前記少なくとも１つの関数が実行されていない時を確定することと、
前記少なくとも１つの関数におけるオリジナルコードを、パッチが当てられたコードに置き換えることと
を含む方法。
【請求項２】
前記少なくとも１つの関数が実行されていない時を確定することは、
保守期間の間待機すること
を含む請求項１に記載の方法。
【請求項３】
前記保守期間は、
少なくとも、前記少なくとも１つの関数の最大実行時間と同様の長さである、
請求項２に記載の方法。
【請求項４】
前記少なくとも１つの関数が実行されている時にステータステーブルを更新するように、前記少なくとも１つの関数を変更すること
を含む請求項１に記載の方法。
【請求項５】
前記少なくとも１つの関数が実行されていない時を確定することは、
前記少なくとも１つの関数が実行されていないことを前記ステータステーブルが示す時を確定すること
を含む請求項４に記載の方法。
【請求項６】
前記少なくとも１つの関数を変更することは、
前記少なくとも１つの関数の実行が終了した時に、前記ステータステーブルが前記少なくとも１つの関数が実行されていないことを示すか否かを検査するコードを、前記少なくとも１つの関数に挿入すること
を含む請求項５に記載の方法。
【請求項７】
前記少なくとも１つの関数はパディングコードを含み、
前記関数を変更することは、
前記少なくとも１つの関数の実行が開始し終了した時に、前記関数が前記ステータステーブルを更新するように、前記パディングコードを変更すること
を含む請求項４に記載の方法。
【請求項８】
前記オリジナルコードを置き換えている間、前記少なくとも１つの関数を呼び出すスレッドを強制的にスリープ状態にすること
を含む請求項１に記載の方法。
【請求項９】
実行プログラムの少なくとも１つの関数にパッチを当てるコンピュータプログラムであって、
前記少なくとも１つの関数が実行されていない時を確定するコードと、
前記少なくとも１つの関数におけるオリジナルコードを、パッチが当てられたコードに置き換えるコードと
を含むコンピュータプログラム。
【請求項１０】
前記少なくとも１つの関数が実行されていない時を確定する前記コードは、保守期間の間待機するコード
を含む請求項９に記載のコンピュータプログラム。
【請求項１１】
前記保守期間は、少なくとも、前記少なくとも１つの関数の最大実行時間と同様の長さである、
請求項１０に記載のコンピュータプログラム。
【請求項１２】
前記少なくとも１つの関数が実行されている時にステータステーブルを更新するように、前記少なくとも１つの関数を変更するコード
を含む請求項９に記載のコンピュータプログラム。
【請求項１３】
前記少なくとも１つの関数が実行されていない時を確定する前記コードは、
前記少なくとも１つの関数が実行されていないことを前記ステータステーブルが示す時を確定するコード
を含む請求項１２に記載のコンピュータプログラム。
【請求項１４】
前記少なくとも１つの関数を変更する前記コードは、
前記少なくとも１つの関数の実行が終了した時に、前記ステータステーブルが前記少なくとも１つの関数が実行されていないことを示すか否かを検査するコードを、前記少なくとも１つの関数に挿入するコード
を含む請求項１３に記載のコンピュータプログラム。
【請求項１５】
前記少なくとも１つの関数はパディングコードを含み、
前記関数を変更する前記コードは、
前記少なくとも１つの関数の実行が開始し終了した時に、前記関数が前記ステータステーブルを更新するように、前記パディングコードを変更するコード
を含む請求項１２に記載のコンピュータプログラム。
【請求項１６】
前記オリジナルコードを置き換える前記コードが実行されている間に、前記少なくとも１つの関数を呼び出すスレッドを強制的にスリープ状態にするコード
を含む請求項９に記載のコンピュータプログラム。
【請求項１７】
前記パッチが当てられたコードを含む請求項９に記載のコンピュータプログラム。
【請求項１８】
請求項１に記載の方法をインプリメントするシステム。
【請求項１９】
請求項９に記載のコンピュータプログラムがロードされたデータ処理システム。
【請求項２０】
請求項９に記載のコンピュータプログラムを格納するコンピュータ可読記憶装置。
【発明の詳細な説明】
【技術分野】
【０００１】
本発明の実施の形態は、実行しているプログラムにパッチを当てるように構成されるデータ処理システム及び方法に関する。
【背景技術】
【０００２】
コンピュータプログラムに対し、変更を行うか又は「パッチを当てる」ことにより、そのコンピュータプログラムのオリジナルコードのうちの少なくともいくつかを、パッチを当てたコードに置き換えることができる。コンピュータプログラムにパッチを当てることにより、プログラムの機能を追加し、誤りを訂正し、且つ／又は性能を向上させることができる。
【０００３】
コンピュータプログラムがデータ処理システムで実行しており、且つ、コンピュータプログラムの少なくとも一部にパッチが当てられるか、又はコンピュータプログラムによって呼び出されるコードの一部にパッチが当てられる場合、その部分内の関数のすべてにパッチが当てられる必要のない場合であっても、コンピュータプログラムは、その部分内の関数を呼び出すことができなくなる。これにより、コンピュータプログラムのダウンタイムがもたらされる可能性がある。
【０００４】
別のパッチ当て方法は、パッチを当てたコードをデータ処理システムのメモリにロードし、パッチが当てられる関数内のコードを、それがオリジナル関数コードを実行する代りにパッチが当てられたコードを呼び出すように変更する。しかしながら、一旦パッチが当てられると、データプロセッサは、依然としてパッチが当てられていないコードを実行している可能性がある。また、このパッチ当て方法は、オリジナルコードが冗長であるが依然としてメモリ内に配置されているため、メモリ効率が悪い。
【発明の開示】
【発明が解決しようとする課題】
【０００５】
本発明の実施の形態の目的は、従来技術の問題のうちの１つ又は複数を少なくとも軽減することである。
【課題を解決するための手段】
【０００６】
本発明の一形態は、実行プログラムの少なくとも１つの関数にパッチを当てる方法であって、少なくとも１つの関数が実行されていない時を確定することと、少なくとも１つの関数におけるオリジナルコードを、パッチが当てられたコードに置き換えることとを含む方法である。
【０００７】
ここで、本発明の実施形態を、添付図面を参照して単に例として説明する。
【発明を実施するための最良の形態】
【０００８】
本発明の実施形態による方法を使用して、データ処理システムで実行しているプログラムにパッチを当てることができる。プログラムにパッチが当てられる場合、パッチが当てられたコードがデータ処理システムに、たとえばデータ処理システムが読取り可能なパッチバイナリファイルの形式で提供される。パッチバイナリファイルはまた、データ処理システム上でパッチ当て方法をインプリメントする命令を含んでもよい。パッチバイナリファイルは、パッチが当てられたコードを含み、又はパッチが当てられたコードを生成する命令を含む。パッチが当てられたコードは、実行プログラム内且つ／又は実行プログラムによって呼び出される１つ若しくは複数の関数の一部又はすべてを形成するオリジナルコードに置き換わるように意図されている。
【０００９】
たとえば、パッチバイナリファイルは、パッチが当てられたコードと、実行プログラムにパッチを当てる命令を提供する実行可能部分とを含んでもよい。別法として、パッチバイナリファイルは、パッチが当てられたコードのみを含んでもよく、実行可能部分は含まない。したがって、実行プログラムにパッチを当てる命令を、データ処理システムに、たとえば別ファイルで又はオペレーティングシステムの一部として提供してもよい。実行可能部分のないパッチバイナリファイルは、実行可能部分を含むパッチバイナリファイルに比べてサイズが低減し得る。
【００１０】
図１に、本発明の一実施形態によるパッチ当て方法１００の一例を示す。方法はステップ１０２で開始し、そこで、データ処理システムはパッチバイナリファイルを読み出す。パッチバイナリファイルを、たとえばフラッシュメモリ、光記憶装置若しくはフロッピー（登録商標）ディスク等のコンピュータ可読記憶装置を使用して、或いは有線ＬＡＮ若しくはＷＡＮ又は無線ＬＡＮ若しくはＷＡＮ等のネットワーク接続を使用して、或いはファイルをデータ処理システムに提供する他の何らかの方法を使用して、データ処理システムに提供してもよい。
【００１１】
ステップ１０２に続くステップ１０４において、データ処理システムは保守モードに入り、パッチ当てプロセスが開始したことを示す。そして、方法はステップ１０６に進み、そこでデータ処理システムは、パッチが当てられたコードが予約された空間内に適合するか否かを判断する。パッチが当てられる各関数に対するパッチが当てられたコードは、その関数に対して予約された空間内に適合しなければならない。関数に対して予約された空間は、その関数に対してオリジナルコードによって占有されるデータ処理システムのメモリの量である。パッチが当てられたコードが予約された空間内に適合しない場合、パッチ当ては進行することができず、パッチ当て方法はステップ１０８において終了する。各関数に対するパッチが当てられたコードのサイズを、パッチバイナリファイルに含めてもよく、又は他の方法でデータ処理システムに提供するか若しくはデータ処理システムによって確定してもよい。
【００１２】
図２に、データ処理システムのメモリにおける関数２００の構造を示す。関数２００は、その関数の開始におけるパディングコードの第１の部分２０２と、関数の終了におけるパディングコードの第２の部分２０４とを含む。関数２００はまた、オリジナルコード２０６も含む。オリジナルコード２０６は、関数コード２０８とパディングコードの第３の部分２１０とを含む。関数コード２０８は、データ処理システムに対して関数を実行させる命令を含む。パディングコードの部分２０２、２０４及び２１０は、無演算（no-op）命令を含む。パディングコードの第１の部分２０２及び第２の部分２０４は、後により詳細に示すように、パッチ当てプロセス中にルーチンに対する呼出しに置き換えられる。パディングコードの第３の部分２１０は、オリジナルコード２０６のサイズを増大させるために存在する。たとえば、パディングコード２１０は、オリジナルコード２０６の５％を含んでもよい。オリジナルコード２０６のサイズが増大することにより、パッチが当てられたコードが、関数コード２０８より大きい場合に、オリジナルコード２０６と置き換わることが可能になる。パディングコードの第３の部分２１０を、オリジナルコード２０６の開始又は終了に配置してもよく、或いはオリジナルコード２０６を通して分散させてもよい。パディングコードの第３の部分を、関数に関連する実行ファイルに挿入してもよく（たとえばコンパイラにより）、関数がロードされる際にメモリに挿入してもよく、又は他の方法で挿入してもよい。いかなるパッチが当てられたコードのサイズも関数コード２０８より小さくなることが保証される場合、パディングコードの第３の部分２１０を省略してもよい。関数はまた、パディングコードの第２の部分２０４に続き、且つ関数を呼び出したスレッドに戻る命令（図示せず）を含んでもよい。
【００１３】
図１を再び参照すると、パッチが当てられたコードが予約された空間内に適合する場合、方法はステップ１０６からステップ１１０に進み、そこでステータステーブルが作成される。ステータステーブルは、パッチが当てられる各関数に対する行を含む。ステータステーブルは、後述するように、パッチが当てられる関数をいずれのスレッドが呼び出したかを示す。
【００１４】
ステップ１１０から、方法はステップ１１２に進み、そこで、パッチが当てられる関数が変更される。このステップにおいて、パッチが当てられる各関数は、図３に示す関数３００の構造を有するように変更される。関数３００は、図２の関数２００と同じ構造を有するが、このステップにおいて、パディングコードの第１の部分２０２を共通入口ルーチンに対する呼出し３０２に置き換えるように、且つパディングコードの第２の部分２０４を共通出口ルーチンに対する呼出し３０４に置き換えるように変更されている。パッチが当てられる関数のすべてが、同じ共通入口ルーチン及び共通出口ルーチンを呼び出すように変更される。
【００１５】
パッチが当てられる変更された関数が、実行プログラムのスレッドによって呼び出される時、図３に示すように、共通入口ルーチンを呼び出す命令３０２が関数の開始に見つかると、共通入口ルーチンが即座に呼び出される。共通入口ルーチンは、呼出しスレッドのスレッドＩＤを、ステータステーブルの呼び出された関数に対応する行に追加する。ステータステーブルを、たとえば、各関数に対して複数のエントリを追加し且つ除去することができるようにリンクされたリストとしてインプリメントしてもよい。ステータステーブルは、パッチが当てられない関数に関連する情報を含まず、こうした関数は、システムが保守モードにあるか又はパッチが当てられる関数にパッチが当てられている時でさえも、正常に実行されることが可能であり、本発明の実施形態によって影響を受けない。
【００１６】
共通出口ルーチンは、関数が実行を終了し、呼出しスレッドに戻る時に、呼び出される。共通出口ルーチンは、ステータステーブルの呼び出された関数に対応する行から、呼出しスレッドのスレッドＩＤを除去する。したがって、ステータステーブルは、データ処理システムが保守モードに入ってから実行を開始しており、且つまだ実行が終了していない関数の最新リストを含む。スレッドのスレッドＩＤは、ステータステーブルに複数回存在してもよく、且つ／又はステータステーブルの同じ行に複数回存在してもよく、それは、スレッドが呼び出した関数の数とスレッドが各関数を呼び出した回数とに対応する。
【００１７】
図１を再び参照すると、ステップ１１２においてパッチが当てられる関数が変更されると、方法１００はステップ１１４に進む。ステップ１１４において、データ処理システムにおいてパッチ当て方法をインプリメントするように実行しているパッチ当てスレッドは、保守期間の間、スリープ状態になる。保守期間は、少なくとも、パッチが当てられる関数の最大実行時間と同様の長さであるように選択されるか又は計算される。したがって、保守期間が経過すると、データ処理システムが保守モードに入る前に実行していたいかなる関数も実行を終了する。これは、ステータステーブルが、システムが保守モードに入る前に呼び出された関数を示さないため、有用である。それは、それら関数が、呼び出された時点で共通入口ルーチンを呼び出す命令３０２を含まなかったためである。
【００１８】
このように、保守期間の終了時、ステータステーブルは、パッチが当てられるべき関数のいずれが実行しているかと、いずれの関数が実行していないかとを示す。
【００１９】
保守期間が経過すると、パッチ当てスレッドは、ステップ１１４から続くステップ１１６において、ウェイクアップ信号を受け取る（たとえば、データ処理システムで実行しているオペレーティングシステムから）。そして、方法１００はステップ１１８に進み、そこで、パッチ当てスレッドは、ステータステーブルを検査して、それが空であるか否かを判断する。ステータステーブルが空でない場合、パッチが当てられる関数のうちのいくつかが実行されている。空でない場合、方法１００はステップ１１８からステップ１２０に進み、そこで、パッチ当てスレッドは、ウェイクアップ信号を受け取るまでスリープ状態になる。後により詳細に示すように、パッチ当てスレッドが共通出口ルーチンからウェイクアップ信号を受け取ると、方法はステップ１１６に進み、その後、パッチ当てスレッドが再びステータステーブルを検査する時にステップ１１８に進む。
【００２０】
ステップ１１８において、パッチ当てスレッドが、ステータステーブルが空であると判断する場合、パッチが当てられる関数のいずれも実行されていない。これは、「同期点」である。パッチ当てをこの時点で行うことができる。それは、パッチが当てられたコードが、実行されているコードに置き換わらないためである。このため、パッチ当てスレッドは、図１の方法１００のステップ１２２においてパッチが当てられる関数のパッチ当てを開始する。関数にパッチを当てるため、パッチ当てスレッドは、メモリ内のオリジナルコード（図２及び図３におけるコード２０６等）を、パッチが当てられたコード及びパディングコードの部分と置き換える。図４は、オリジナルコード２０６が、パッチが当てられたコード４０２及びパディングコードの部分４０４と置き換えられた場合の関数４００を示す。パディングコード４０４は、パッチが当てられたコード４０２及びパディングコード４０４によって占有されるメモリ空間がオリジナルコード２０６によって占有されるメモリ空間に一致することを保証するために存在する。このため、パッチが当てられたコード４０２がオリジナルコード２０６と同じサイズである場合、パディングコード４０４は必要ではない。
【００２１】
パッチが当てられたコード４０２及びパディングコード４０４がメモリの適当な場所に挿入されると、パッチ当てスレッドは、共通入口ルーチン及び共通出口ルーチンそれぞれに対する呼出し３０２及び３０４をパディングコードに置き換える。図５は、呼出し３０２及び３０４がパディングコード５０２及び５０４それぞれによって置き換えられた場合の関数５００を示す。関数５００は、完全にパッチが当てられた関数であり、実行プログラムによって呼び出されることが可能である。
【００２２】
パッチ当てスレッドは、上述したようにパッチが当てられる関数の各々にパッチを当て、関数のすべてにパッチが当てられると、関数のパッチ当てを終了する。そして、データ処理システムは保守モードから出て、図１の方法はステップ１２４で終了する。
【００２３】
パッチ当てスレッドが関数にパッチを当てる過程にある場合、データ処理システムで実行しているプログラムが、パッチが当てられる関数のいずれをも呼び出すことは望ましくない。したがって、各関数に対する共通入口ルーチンは、パッチ当てスレッドが関数にパッチを当てるのを終了するまで、こうした関数を呼び出すスレッドをスリープ状態にする。図６は、共通入口ルーチン６００の一例を示す。このルーチンが呼び出されるのは、パッチが当てられる関数が、図１の方法１００のステップ１１２において変更されている場合に、実行プログラムのスレッドによって呼び出される時である。共通入口ルーチンは、ステップ６０２で開始し、そこで、パッチ当てスレッドが、パッチが当てられる関数にパッチを当てる過程にあるか否かを判断する。そうである場合、ルーチン６００はステップ６０４に進み、そこで、パッチが当てられる関数を呼び出したスレッドをスリープ状態にする。そして、ルーチンはステップ６０６で終了する。このようにスリープ状態になるスレッドを、パッチ当てプロセスが終了する時にウェイクさせることができる。
【００２４】
ルーチン６００は、ステップ６０２において、パッチ当てスレッドが、パッチが当てられる関数にまだパッチを当てていないと判断すると、ステップ６０２からステップ６０８に進み、そこで、呼び出された関数及び呼出しスレッドのＩＤを確定する。そして、ルーチン６００はステップ６１０に進み、そこで、ステータステーブルにおけるパッチが当てられる呼び出された関数に対応する行に、呼出しスレッドのＩＤを追加する。そして、ルーチンはステップ６１２で終了する。
【００２５】
図７は、パッチが当てられる関数が、図１の方法１００のステップ１１２において変更されている場合に、実行を終了した時に呼び出される、共通出口ルーチン７００の一例を示す。ルーチン７００はステップ７０２で開始し、そこで、呼び出された関数及び呼出しスレッドのＩＤを確定する。そして、ルーチン７００はステップ７０４に進み、そこで、スレッドＩＤがステータステーブルの呼び出された関数に対応する行に存在するか否かを判断する。そうでない場合、データ処理システムが保守モードに入る前に、関数は実行プログラムによって呼び出されている。そして、ルーチン７００はステップ７０６において終了する。
【００２６】
ルーチン７００は、ステップ７０４において、呼出しスレッドＩＤがステータステーブルの適当な行にあると判断すると、ステップ７０４からステップ７０８に進み、そこでステータステーブルの適当な行からスレッドＩＤを除去する。次に、ステップ７１０において、ルーチン７００は、ステータステーブルがこの時点で空であるか否か、及びステータス期間が経過したか否かを判断する。ステータステーブルが空でなく且つ／又はステータス期間が経過していない場合、ルーチン７００はステップ７１２において終了する。ステータステーブルが空であり、且つステータス期間が経過した場合、パッチが当てられる関数のいずれも実行していない。したがって、ルーチン７００はステップ７１０からステップ７１４に進み、そこで、パッチ当てスレッドにウェイクアップ信号を送出する。そして、ルーチン７００はステップ７１６において終了する。
【００２７】
本発明のいくつかの実施形態では、パッチ当てスレッドは、図１のパッチ当て方法１００をインプリメントしてもよく、又は別法として、本方法の他の実施形態によるパッチ当て方法をインプリメントしてもよい。別法として、データ処理システムがパッチ当て方法の少なくとも一部をインプリメントする命令を含んでもよく、又はデータ処理システムにそういった命令を提供してもよい。同様に、共通入口ルーチン及び共通出口ルーチンにパッチバイナリファイルを提供してもよく、或いは他の方法で、それらがデータ処理システムに存在するか、又はそれらをデータ処理システムに提供してもよい。
【００２８】
いくつかの実施形態では、パッチ当て方法は、データ処理システムのハードディスク等の永久記憶装置において１つ又は複数のファイルを更新し（たとえば、変更又は置換により）、それらファイルは実行プログラムに関連する。したがって、ファイルが、実行プログラムになるようにメモリにロードされる時、新たなプログラムは、オリジナルコードの代りにパッチが当てられた関数を含むことになる。ファイルを更新するための情報に、パッチバイナリファイルを提供してもよく又は他の方法を用いてもよい。
【００２９】
図８は、データ処理システム８００の一例を示す。データ処理システム８００は、データプロセッサ８０２及びメモリ８０４を備える。システム８００はまた、例えばハードディスク等の永久記憶デバイス８０６と、データ処理システムが、ＬＡＮ、ＷＡＮ、インターネット又は他のネットワーク等の有線及び／又は無線ネットワークと通信するのを可能にする通信デバイス８０８とを備える。データ処理システムは、キーボード及び／又はマウス等の入力デバイス８１０と、表示デバイス８１２とを有してもよい。本発明の実施形態をインプリメントするのに適しているデータ処理システムは、システム８００のコンポーネントのいずれを排除してもよく、且つ／又はさらなるコンポーネントを含んでもよい。
【００３０】
図９は、図１の方法１００のステップ１１０において作成されるステータステーブル９００の一例を示す。ここでは、３つの関数Ａ、Ｂ及びＣにパッチが当てられる。ステータステーブルは、関数Ａ、Ｂ及びＣの各々に対する行を含む。ステータステーブルは、各行の第１のエントリがＮＵＬＬを指すため空である。
【００３１】
システムが保守モードにある間であるが、保守期間が経過する前、データ処理システムで実行しているプログラムのスレッドＴ１が、関数Ａを呼び出す場合を考慮する。Ｔ１のスレッドＩＤが、ステータステーブルの関数Ａに対応する行に追加される。結果としてのステータステーブル１０００を図１０に示す。
【００３２】
その後、第２のスレッドＴ２が、関数Ａ（Ｔ１によって呼び出された）が実行を終了する前に関数Ａ及びＢを呼び出す場合、Ｔ２のスレッドＩＤが、関数Ａ及びＢに対応するステータステーブルの行に追加される。結果としてのステータステーブル１１００を図１１に示す。関数Ａに対応する行は２つのエントリ、すなわち、Ｔ１及びＴ２を有し、それは、Ｔ１及びＴ２の両方が関数Ａを呼び出しており、関数ＡがＴ１又はＴ２に関して実行を終了していないことを示す。
【００３３】
Ｔ１によって呼び出された関数Ａが実行を終了すると、Ｔ１のスレッドＩＤは、ステータステーブルの適当な行から除去される。結果としてのステータステーブル１２００を図１２に示す。これは、関数Ａに対応する行が、この時、単一エントリＴ２のみを有することを示す。これは、関数ＡがＴ１に関して実行を終了していた場合であっても、関数ＡはＴ２に関して実行を終了していないことを示す。関数ＡがＴ２に関して実行を終了し、且つ関数Ｂもまた実行を終了すると、パッチ当てプロセスは、関数がそれ以上呼び出されておらず、且つ保守期間が経過した場合、関数Ａ、Ｂ及びＣにパッチを当てるように進むことができる。
【００３４】
本発明の実施形態を、ハードウェア、ソフトウェア、又はハードウェア及びソフトウェアの組合せの形態で具現化することができるということが理解されよう。こうしたソフトウェアのいずれも、たとえば消去可能であるか書換可能であるか否かに関わらずＲＯＭのような記憶デバイス等の揮発性記憶装置若しくは不揮発性記憶装置の形態で、又はたとえばＲＡＭ、メモリチップ、デバイス若しくは集積回路等のメモリの形態で、又はたとえばＣＤ、ＤＶＤ、磁気ディスク又は磁気テープ等の光学的可読媒体若しくは磁気的可読媒体に、格納してもよい。記憶デバイス及び記憶媒体は、実行されると本発明の実施形態をインプリメントする１つ又は複数のプログラムを格納するために適した機械可読記憶装置の実施形態であるということが理解されよう。したがって、実施形態は、あらゆる添付の特許請求の範囲において請求されているようなシステム又は方法をインプリメントするコードを含むプログラムと、こうしたプログラムを格納する機械可読記憶装置とを提供する。さらに、本発明の実施形態を、有線接続又は無線接続によって搬送される通信信号等の任意の媒体を介して電子的に伝送してもよく、実施形態は適当にこれを包含する。
【００３５】
本明細書（すべての添付の特許請求の範囲、要約書及び図面を含む）に開示された特徴のすべて及び／又はそのように開示された任意の方法又はプロセスのステップのすべてを組み合わせて、こうした特徴及び／又はステップの少なくともいくつかが相互に排他的である組合せを除き、いかなる組合せにしてもよい。
【００３６】
本明細書（すべての添付の特許請求の範囲、要約書及び図面を含む）に開示された各特徴を、特に別途明示的に述べる場合を除き、同じ目的、等価な目的又は同様の目的にかなう代替的な特徴によって置き換えてもよい。このように、特に別途明示的に述べる場合を除き、開示された各特徴は、包括的な一続きの等価な特徴又は同様の特徴の単に一例である。
【００３７】
本発明は、上述した実施形態のいずれの詳細にも限定されない。本発明は、本明細書（すべての添付の特許請求の範囲、要約書及び図面を含む）において開示された特徴のいかなる新規なもの、又はいかなる新規な組合せにも、或いはそのように開示されたいかなる方法又はプロセスのステップのいかなる新規なもの又はいかなる新規な組合せにも及ぶ。特許請求の範囲は、単に上述した実施形態を包含するように解釈されるべきではなく、その範囲内にあるいかなる実施形態をも包含するように解釈されるべきである。
【図面の簡単な説明】
【００３８】
【図１】本発明の実施形態による実行プログラムにパッチを当てるパッチ当て方法を示す図である。
【図２】パッチが当てられる関数の構造を示す図である。
【図３】変更された関数の構造を示す図である。
【図４】オリジナルコードが置き換えられた、変更された関数の構造を示す図である。
【図５】パッチが当てられた関数の構造を示す図である。
【図６】共通入口ルーチンの一例を示す図である。
【図７】共通出口ルーチンの一例を示す図である。
【図８】本発明の実施形態をインプリメントするために適しているデータ処理システムの一例を示す図である。
【図９】空のステータステーブルの一例を示す図である。
【図１０】関数ＡがスレッドＴ１によって呼び出された場合のステータステーブルの一例を示す図である。
【図１１】関数Ａ及びＢがスレッドＴ２によって呼び出された場合のステータステーブルの一例を示す図である。
【図１２】スレッドＴ１によって呼び出された関数Ａが実行を終了した場合のステータステーブルの一例を示す図である。
【符号の説明】
【００３９】
２０６・・・オリジナルコード
８００・・・データ処理システム
８０２・・・データプロセッサ
８０４・・・メモリ
８０６・・・永久記憶デバイス
８０８・・・通信デバイス
８１０・・・入力デバイス
８１２・・・表示デバイス
９００、１０００、１１００、１２００・・・ステータステーブル
【図１】
2009009545.tif 000003
【図２】
2009009545.tif 000004
【図３】
2009009545.tif 000005
【図４】
2009009545.tif 000006
【図５】
2009009545.tif 000007
【図６】
2009009545.tif 000008
【図７】
2009009545.tif 000009
【図８】
2009009545.tif 000010
【図９】
2009009545.tif 000011
【図１０】
2009009545.tif 000012
【図１１】
2009009545.tif 000013
【図１２】
2009009545.tif 000014
【手続補正書】
【提出日】平成20年3月26日(2008.3.26)
【手続補正１】
【補正対象書類名】図面
【補正対象項目名】図６
【補正方法】変更
【補正の内容】
【図６】
2009009545.tif 000015
【外国語明細書】
DATA PROCESSING SYSTEM AND METHOD
Background to the Invention
Computer programs can be modified or "patched" to replace at least some of the original code in the computer program with patched code. A computer program may be patched to add features, correct errors and/or improve the performance of the program.
Where a computer program is executing on a data processing system and at least a portion of the computer program is to be patched, or a portion of code that is called by the computer program is to be patched, the computer program is blocked from calling functions within the portion, even if not all of the functions within the portion need to be patched. This may lead to downtime of the computer program.
Another patching method loads patched code into a data processing system's memory, and modifies code within the function to be patched such that it calls the patched code instead of executes the original function code. However, once the patch is applied, the data processor may still be executing the unpatched code. Also, this patching method is memory inefficient as the original code is redundant but is still located within the memory.
It is an object of embodiments of the invention to at least mitigate one or more of the problems of the prior art.
Brief Description of the Drawings
Embodiments of the invention will now be described by way of example only, with reference to the accompanying drawings, in which:
Figure 1 shows a patching method for patching an executing program according to embodiments of the invention;
Figure 2 shows the structure of a function to be patched;
Figure 3 shows the structure of a modified function;
Figure 4 shows the structure of a modified function with the original code replaced;
Figure 5 shows the structure of a patched function;
Figure 6 shows an example of a common entry routine;
Figure 7 shows an example of a common exit routine;
Figure 8 shows an example of a data processing system suitable for implementing embodiments of the invention;
Figure 9 shows an example of an empty status table;
Figure 10 shows an example of a status table where a function a has been called by a thread T1;
Figure 11 shows an example of a status table where the functions a and b have been called by a thread T2; and
Figure 12 shows an example of a status table where a function a called by a thread T1 has finished executing.
Detailed Description of Embodiments of the Invention
Methods according to embodiments of the invention may be used to patch a program that is executing on a data processing system. When a program is to be patched, the patched code is provided to the data processing system in the form of, for example, a patch binary file that is readable by the data processing system. The patch binary file may also include instructions for implementing the patching method on the data processing system. The patch binary file includes patched code, or contains instructions for producing the patched code. The patched code is intended to replace original code that forms part or all of one or more functions within the executing program and/or called by the executing program.
For example, the patch binary file may include the patched code and an executable portion that provides instructions for patching an executing program. Alternatively, the patch binary file may contain only the patched code, and does not include an executable portion. The instructions for patching the executing program may therefore be provided to the data processing system, for example in another file or as part of an operating system. A patch binary file without an executable portion may be of reduced size compared to a patch binary file with an executable portion.
An example of a patching method 100 according to an embodiment of the invention is shown in figure 1. The method starts at step 102, where the data processing system reads the patch binary file. The patch binary file may be provided to the data processing system using, for example, computer readable storage such as flash memory, optical storage or a floppy disk, or using a network connection such as a wired or wireless LAN or WAN, or using some other method of providing the file to the data processing system.
In step 104, which follows from step 102, the data processing system enters maintenance mode, indicating that the patching process has begun. The method then proceeds to step 106, where the data processing system determines whether the patched code fits within the space reserved. The patched code for each function to be patched must fit within the space reserved for the function. The space reserved for a function is the amount of memory of the data processing system that is occupied by the original code for the function. If the patched code does not fit within the space reserved then patching cannot go ahead, and the patching method ends at step 108. The size of the patched code for each function can be included in the patch binary file, or otherwise provided to or determined by the data processing system.
The structure of a function 200 in the memory of the data processing system is shown in figure 2. The function 200 comprises a first portion of padding code 202 at the start of the function, and a second portion of padding code 204 at the end of the function. The function 200 also comprises original code 206. The original code 206 comprises function code 208 and a third portion of padding code 210. The function code 208 contains instructions to cause the data processing system to carry out the function. The portions of padding code 202, 204 and 210 comprise no-op instructions. The first 202 and second 204 portions of padding code are replaced with calls to routines during the patching process as indicated in more detail later. The third portion of padding code 210 is present to increase the size of the original code 206. For example, the padding code 210 may comprise 5% of the original code 206. The increased size of the original code 206 enables patched code to replace the original code 206 where the patched code is larger than the function code 208. The third portion of padding code 210 may be located at the start or the end of the original code 206 or may be distributed throughout the original code 206. The third portion of padding code may be inserted into executable files associated with the function (such as, for example, by a compiler), inserted as the function is loaded into memory, or inserted otherwise. The third portion of padding code 210 may be omitted where it is guaranteed that any patched code will be smaller in size than the function code 208. The function may also include instructions (not shown) that follow the second portion of padding code 204, and return to the thread that called the function.
Referring back to figure 1, if the patched code fits within the space reserved, then the method proceeds from step 106 to step 110 where a status table is created. The status table contains a row for each function to be patched. The status table indicates which threads have called the functions to be patched as indicated below.
From step 110, the method proceeds to step 112 where the functions to be patched are modified. In this step, each function to be patched is modified such that it has the structure of the function 300 shown in figure 3. The function 300 has the same structure as the function 200 of figure 2, except that the function has been modified in this step to replace the first portion of padding code 202 with a call 302 to a common entry routine, and to replace the second portion of padding code 204 with a call 304 to a common exit routine. All of the functions to be patched are modified to call the same common entry and exit routines.
When a modified function to be patched is called by a thread of the executing program, the common entry routine is immediately called as the instructions 302 for calling the common entry routine are found at the start of the function, as shown in figure 3. The common entry routine adds the thread ID of the calling thread to the status table in the row corresponding to the called function. The status table may be implemented, for example, as a linked list so that multiple entries can be added and removed for each function. The status table does not include information relating to functions that are not to be patched, and such functions may be executed normally and are not affected by embodiments of the invention, even when the system is in maintenance mode or the functions to be patched are being patched.
The common exit routine is called when the function finishes execution and returns to the calling thread. The common exit routine removes the thread ID of the calling thread from the row of the status table corresponding to the called function. Therefore, the status table comprises an up-to-date list of the functions that have started executing since the data processing system entered maintenance mode, and have not yet finished executing. The thread ID of a thread may be present in multiple times in the status table, and/or multiple times in the same row of the status table, corresponding to the number of functions that the thread called and the number of times that the thread called each function.
Referring back to figure 1, once the functions to be patched have been modified in step 112, the method 100 proceeds to step 114. In step 114, the patching thread that is executing on the data processing system to implement the patching method sleeps for a maintenance period. The maintenance period is chosen or calculated to be at least as long as the maximum execution time of the functions to be patched. Therefore, once the maintenance period has elapsed, any functions that were executing before the data processing system entered maintenance mode will have finished executing. This is useful because the status table will not indicate functions that were called before the system entered maintenance mode, as the functions did not include instructions 302 to call the common entry routine at the time they were called.
Thus, at the end of the maintenance period, the status table indicates which functions to be patched are executing and which functions are not executing.
Once the maintenance period has elapsed, the patching thread receives a wake-up signal (for example, from an operating system running on the data processing system) in step 116, which follows on from step 114. The method 100 then proceeds to step 118, where the patching thread checks the status table to determine whether it is empty. If the status table is not empty, then some of the functions to be patched are being executed. If this is the case, then the method 100 proceeds from step 118 to step 120, where the patching thread sleeps until it receives a wake-up signal. The method proceeds to step 116 when the patching thread receives a wake-up signal from the common exit routine as indicated in more detail below, and then proceeds to step 118 when the patching thread checks the status table once again.
If in step 118 the patching thread determines that the status table is empty, then none of the functions to be patched are being executed. This is the "synchronisation point". Patching can take place at this point as the patched code will not replace code that is being executed. The patching thread thus begins patching the functions to be patched in step 122 of the method 100 of figure 1. To patch a function, the patching thread replaces the original code (such as code 206 in figures 2 and 3) in memory with patched code and a portion of padding code. Figure 4 shows a function 400 where the original code 206 has been replaced with patched code 402 and a portion of padding code 404. The padding code 404 is present to ensure that the memory space occupied by the patched code 402 and the padding code 404 matches that occupied by the original code 206. Thus, the padding code 404 is not required where the patched code 402 is the same size as the original code 206.
Once the patched code 402 and padding code 404 have been inserted at the appropriate place in memory, the patching thread replaces the calls 302 and 304 to common entry and exit routines respectively with padding code. Figure 5 shows a function 500 where the calls 302 and 304 have been replaced by padding code 502 and 504 respectively. The function 500 is a fully patched function and can be called by the executing program.
The patching thread patches each of the functions to be patched as indicated above, and once all of the functions have been patched, the patching thread finishes patching the functions. The data processing system then comes out of maintenance mode, and the method of figure 1 ends at step 124.
If the patching thread is in the process of patching functions, then it is undesirable for the program executing on the data processing system to call any of the functions to be patched. Therefore, the common entry routine for each function sends threads that call such functions to sleep until the patching thread has finished patching the functions. Figure 6 shows an example of a common entry routine 600. This routine is called when a function to be patched is called by a thread of the executing program, provided that the functions to be patched have been modified in step 112 of the method 100 of figure 1. The common entry routine starts at step 602 where the routine determines whether the patching thread is in the process of patching the functions to be patched. If this is the case, then the routine proceeds to step 604 where the routine 600 sleeps the thread that called the function to be patched. The routine then ends at step 606. Threads that are slept in this way can be woken when the patching process ends.
If the routine 600 determines in step 602 that the patching thread is not yet patching the functions to be patched, then the routine 600 proceeds from step 602 to step 608 where the called function and the ID of the calling thread are determined. The routine 600 then proceeds to step 610 where the ID of the calling thread is added to the status table in the row corresponding to the called function to be patched. The routine then ends at step 612.
Figure 7 shows an example of a common exit routine 700 which is called when the functions to be patched finish executing, provided that the functions to be patched have been modified in step 112 of the method 100 of figure 1. The routine 700 begins at step 702 where the called function and the ID of the calling thread are determined. The routine 700 then proceeds to step 704 where the routine determines whether the thread ID is present in the status table in the row corresponding to the called function. If this is not the case, then the function was called by the executing program before the data processing system entered maintenance mode. The routine 700 then ends at step 706.
If the routine 700 determines in step 704 that the calling thread ID is in the appropriate row of the status table, then the routine 700 proceeds from step 704 to step 708 where the routine 700 removes the thread ID from the appropriate row of the status table. Next, at step 710 the routine 700 determines whether the status table is now empty and whether the status period has elapsed . If it is not empty, and/or the status period has not elapsed, then the routine 700 ends at step 712. If it is empty and the status period has elapsed, then none of the functions to be patched are executing. Therefore, the routine 700 proceeds from step 710 to step 714, where the routine 700 sends a wake-up signal to the patching thread. The routine 700 then ends at step 716.
In certain embodiments of the invention, the patching thread may implement the patching method 100 of figure 1 or, alternatively, a patching method according to other embodiments of the invention. Alternatively, the data processing system may include or be provided with instructions for implementing at least part of the patching method. Similarly, the common entry and exit routines may be provided with the patch binary file, or may be otherwise present on or provided to the data processing system.
In certain embodiments, the patching method updates (for example, by modification or replacement) one or more files on a permanent storage, such as a hard disk, of the data processing system, the files being associated with the executing program. Therefore, in the event that the files are loaded into memory so as to become an executing program, the new program will contain the patched functions in place of the original code. The information to update the files may be provided with the patch binary file or otherwise.
Figure 8 shows an example of a data processing system 800. The data processing system 800 comprises a data processor 802 and memory 804. The system 800 also comprises a permanent storage device 806 such as, for example, a hard disk, and a communications device 808 that enables the data processing system to communicate with a wired and/or wireless network, such as a LAN, WAN, internet or other network. The data processing system may include an input device 810 such as a keyboard and/or mouse, and a display device 812. A data processing system suitable for implementing embodiments of the invention may exclude any of the components of the system 800 and/or include further components.
Figure 9 shows an example of a status table 900 that is created in step 110 of the method 100 of figure 1, where three functions A, B and C are to be patched. The status table contains a row for each of the functions A, B and C. The status table is empty as the first entry in each row points to NULL.
Consider that a thread T1 of a program executing on the data processing system calls the function A while the system is in maintenance mode, but before the maintenance period has elapsed. The thread ID of T1 will be added to the status table in the row corresponding to the function A. The resulting status table 1000 is shown in figure 10.
If a second thread T2 subsequently calls the functions A and B before the function A (called by T1) has finished executing, then the thread ID of T1 will be added to the rows of the status table corresponding to the functions A and B. The resulting status table 1100 is shown in figure 11. The row corresponding to the function A has two entries, T1 and T2, which shows that both T1 and T2 have called the function A, and the function A has not finished executing in respect of T1 or T2.
If the function A, called by T1, finishes executing, then the thread ID of T1 will be removed from the appropriate row of the status table. The resulting status table 1200 is shown in figure 12, which shows that the row corresponding to the function A now only has a single entry, T2. This shows that even though the function A has finished executing in respect of T1, the function A has not finished executing in respect of T2. Once the function A has finished executing in respect of T2, and the function B has also finished executing, then the patching process can proceed to patch the functions A, B and C, provided that the functions have not been called again and the maintenance period has elapsed.
It will be appreciated that embodiments of the present invention can be realised in the form of hardware, software or a combination of hardware and software. Any such software may be stored in the form of volatile or non-volatile storage such as, for example, a storage device like a ROM, whether erasable or rewritable or not, or in the form of memory such as, for example, RAM, memory chips, device or integrated circuits or on an optically or magnetically readable medium such as, for example, a CD, DVD, magnetic disk or magnetic tape. It will be appreciated that the storage devices and storage media are embodiments of machine-readable storage that are suitable for storing a program or programs that, when executed, implement embodiments of the present invention. Accordingly, embodiments provide a program comprising code for implementing a system or method as claimed in any preceding claim and a machine readable storage storing such a program. Still further, embodiments of the present invention may be conveyed electronically via any medium such as a communication signal carried over a wired or wireless connection and embodiments suitably encompass the same.
All of the features disclosed in this specification (including any accompanying claims, abstract and drawings), and/or all of the steps of any method or process so disclosed, may be combined in any combination, except combinations where at least some of such features and/or steps are mutually exclusive.
Each feature disclosed in this specification (including any accompanying claims, abstract and drawings), may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise. Thus, unless expressly stated otherwise, each feature disclosed is one example only of a generic series of equivalent or similar features.
The invention is not restricted to the details of any foregoing embodiments. The invention extends to any novel one, or any novel combination, of the features disclosed in this specification (including any accompanying claims, abstract and drawings), or to any novel one, or any novel combination, of the steps of any method or process so disclosed. The claims should not be construed to cover merely the foregoing embodiments, but also any embodiments which fall within the scope of the claims.
CLAIMS
1.    A method of patching at least one function of an executing program, comprising:
determining when the at least one function is not being executed; and
replacing original code in the at least one function with patched code.
2.    A method as claimed in claim 1, wherein determining when the at least one function is not being executed comprises waiting for a maintenance period.
3.    A method as claimed in claim 2, wherein the maintenance period is at least as long as a maximum execution time of the at least one function.
4.    A method as claimed in claim 1, comprising modifying the at least one function to update a status table when the at least one function is being executed.
5.    A method as claimed in claim 4, wherein determining when the at least one function is not being executed comprises determining when the status table indicates that the at least one function is not being executed.
6.    A method as claimed in claim 5, wherein modifying the at least one function comprises inserting code into the at least one function that checks whether the status table indicates that the at least one function is not being executed when execution of the at least one function ends.
7.    A method as claimed in claim 4, wherein the at least one function includes padding code, and modifying the function comprises modifying the padding code such that the function updates the status table when execution of the at least one function begins and ends.
8.    A method as claimed in claim 1, comprising, while replacing the original code, forcing threads that call the at least one function to sleep.
9.    A computer program for patching at least one function of an executing program, comprising:
code for determining when the at least one function is not being executed; and
code for replacing original code in the at least one function with patched code.
10.    A computer program as claimed in claim 9, wherein the code for determining when the at least one function is not being executed comprises code for waiting for a maintenance period.
11.    A computer program as claimed in claim 10, wherein the maintenance period is at least as long as a maximum execution time of the at least one function.
12.    A computer program as claimed in claim 9, comprising code for modifying the at least one function to update a status table when the at least one function is being executed.
13.    A computer program as claimed in claim 12, wherein the code for determining when the at least one function is not being executed comprises code for determining when the status table indicates that the at least one function is not being executed.
14.    A computer program as claimed in claim 13, wherein the code for modifying the at least one function comprises code for inserting code into the at least one function that checks whether the status table indicates that the at least one function is not being executed when execution of the at least one function ends.
15.    A computer program as claimed in claim 12, wherein the at least one function includes padding code, and the code for modifying the function comprises code for modifying the padding code such that the function updates the status table when execution of the at least one function begins and ends.
16.    A computer program as claimed in claim 9, comprising code for forcing threads that call the at least one function to sleep while the code for replacing the original code is being executed.
17.    A computer program as claimed in claim 9, comprising the patched code.
18.    A system for implementing the method as claimed in claim 1.
19.    A data processing system having loaded therein a computer program as claimed in claim 9.
20.    Computer readable storage storing a computer program as claimed in claim 9.
DATA PROCESSING SYSTEM AND METHOD
A method of patching at least one function of an executing program, comprising determining when the at least one function is not being executed; and replacing original code in the at least one function with patched code.
2009009545.tif 000016
2009009545.tif 000017
2009009545.tif 000018
2009009545.tif 000019
2009009545.tif 000020
2009009545.tif 000021
2009009545.tif 000022
2009009545.tif 000023
2009009545.tif 000024
2009009545.tif 000025
2009009545.tif 000026
2009009545.tif 000027