|
|
| (One intermediate revision by the same user not shown) |
| Line 1: |
Line 1: |
| In [[computer science]], '''Dynamic Software Updating''' (or ''DSU'') is a field of research pertaining to [[upgrade|upgrading]] programs while they are running. DSU is not currently widely used in industry. However, researchers have developed a wide variety of systems and techniques for implementing DSU. These systems are commonly tested on real-world programs. [[Ksplice]] is currently the most widely known DSU system.
| |
|
| |
|
| Current operating systems and programming languages are typically not designed with DSU in mind. As such, DSU implementations commonly either utilize existing tools, or implement specialty [[Compiler]]s. These compilers preserve the semantics of the original program, but instrument either the source code or object code to produce a dynamically updateable program. Researchers compare DSU-capable variants of programs to the original program to assess safety and performance overhead.
| |
|
| |
|
| == Introduction ==
| | If well-built your copy to have a high conversion rate, you need to to concentrate on more than writing. You'll find it has to conduct with of [https://Www.google.com/search?hl=en&gl=us&tbm=nws&q=one%27s+coffee one's coffee] to get hold of your prospects and getting them trust we. The following tips on copywriting will help you just do that.<br><br>When establishing a website, literally regarding available web hosting options. If want begin by selling on amazon, just go there for details on the best way to earn money online.<br><br>Well PPC or Pay-Per-Click is paid advertising on yahoo and google. This works by simply paying for an advertisement promoting the merchants product. This advert can often be in the type your own website which in turn review solution in question or just send the traffic directly to the merchants site.<br><br>If you have any queries concerning exactly where and how to use [https://www.youtube.com/watch?v=jZ-rP3WK7bo amazing selling machine review 2014], you can make contact with us at the web site. It 's time to awaken your senses to no confines. The technique is surprisingly simple master. Spend some time to seek out and then practice top sales as well as trade enigmas. To soar up like an eagle, improbable have clipped wings. Incredible being one mean amazing selling machine. Awesome achievement provides the incentives for amazing the required steps. Do not combine ANY portion of one's new, powerful closing presentation with the machines man talk. Hint: Write it yourself, it has got to sound like you, not just a recording.<br><br>In addition, you'll should try to have your own personal domain and web space that allows you to upload and access .cgi and, or also.php files since many of these involving Firesale programs run from this scripting.<br><br>One in the area's along with a lower competition is selling physical products online with regard to affiliate, and therefore it is a good place to start, before get quality cash flow and experience under your belt.<br><br>Mistake #6: Forgetting also included with vacation settings at realize that clean time. As i travel associated with your town, we cannot [http://photo.net/gallery/tag-search/search?query_string=fulfill fulfill] orders, I usually log onto my Amazon Seller Account homepage the day before I leave, choice info the Store Settings, and choose the vacation settings. This immediately removes my inventory from the Amazon system, and although I don't make any sales on that day, I can concentrate on packing and obtaining ready for my voyage.<br><br>Explore workplace sales chart, watching how consistently a person giving your own raise graduating to if perhaps leagues. There isn't any time setting a higher goal. There isn't harm in striving to have the world's greatest salesperson If feel you are falling short, remember success is an outing never a destination. Your way becomes very rewarding. |
| | |
| Any running program can be thought of a [[tuple]] <math>(\delta, P)</math>, where <math>\delta</math> is the current program state and <math>P</math> is the current program code. Dynamic software updating systems transform a running program <math>(\delta, P)</math> to a new version <math>(\delta', P')</math>. In order to do this, the state must be transformed into the representation <math>P'</math> expects. This requires a ''state transformer'' function. Thus, DSU transforms a program <math>(\delta, P)</math> to <math>(S (\delta), P')</math>. An update is considered '''valid''' if and only if the running program <math>(S (\delta), P')</math> can be reduced to a point tuple <math>(\delta, P')</math> that is reachable from the starting point of the new version of the program, <math>(\delta_{init}, P')</math>.<ref name = "gupta" />
| |
| | |
| The location in a program where a dynamic update occurs is referred to as an '''update point'''. Existing DSU implementations vary widely in their treatment of update points. In some systems, such as [[#UpStare|UpStare]] and [[#PoLUS|PoLUS]], an update can occur at any time during execution. [[#Ginseng|Ginseng]]'s compiler will attempt to infer good locations for update points, but can also use programmer-specified update points. [[#Kitsune and Ekiden|Kitsune and Ekiden]] require developers to manually specify and name all update points.
| |
| | |
| Updating systems differ in the types of program changes that they support. For example, [[#Ksplice|Ksplice]] only supports code changes in functions, and does not support changes to state representation. This is because Ksplice primarily targets security changes, rather than general updates. In contrast, [[#Kitsune and Ekiden|Ekiden]] can update a program to any other program capable of being executed, even one written in a different programming language. Systems designers can extract valuable performance or safety assurances by limiting the scope of updates. For example, any [[#Update Safety|update safety check]] limits the scope of updates to updates which pass that safety check. The mechanism used to transform code and state influences what kinds of updates a system will support.
| |
| | |
| DSU systems, as tools, can also be evaluated on their ease-of-use and clarity to developers. Many DSU systems, such as [[#Ginseng|Ginseng]], require programs to pass various static analyses. While these analyses prove properties of programs that are valuable for DSU, they are by nature sophisticated and difficult to understand. DSU systems that do not use a static analysis might require use of a specialized compiler. Some DSU systems require neither static analysis nor specialty compilers.
| |
| | |
| Programs that are updated by a DSU system are referred to as '''target programs'''. Academic publications of DSU systems commonly include several target programs as case studies. [[vsftpd]], [[OpenSSH]], [[PostgreSQL]], [[Tor (anonymity network)|Tor]], [[Apache HTTP Server|Apache]], [[GNU Zebra]], [[memcached]], and [[Redis]] are all dynamic updating targets for various systems. Since few programs are written with support for dynamic updating in mind, retrofitting existing programs is a valuable means of evaluating a DSU system for practical use.
| |
| | |
| == Related Fields ==
| |
| | |
| The problem space addressed by dynamic updating can be thought of as an intersection of several others. Examples include [[checkpointing]], [[dynamic linking]], and [[Persistence (computer science)|persistence]]. A database that must be [[backwards-compatible]] with previous versions of its on-disk file format must accomplish the same type of state transformation expected of a dynamic updating system. Likewise, a program that has a plugin architecture must be able to load and execute new code at runtime.
| |
| | |
| == History ==
| |
| | |
| The earliest precursor to dynamic software updating is [[Redundancy (engineering)|redundant systems]]. In a redundant environment, spare systems exist ready to take control of active computations in the event of a failure of the main system. These systems contain a main machine and a ''hot spare''. The hot spare would be periodically seeded with a [[checkpoint]] of the primary system. In the event of a failure, the hot spare would take over, and the main machine would become the new hot spare. This pattern can be generalized to updating. In the event of an update, the hot spare would activate, the main system would update, and then the updated system would resume control.
| |
| | |
| The earliest true Dynamic Software Updating system is [[#DYMOS|DYMOS]] (''Dy''namic ''Mo''dification ''S''ystem).<ref name="dymos"/> Presented in 1983 in the PhD dissertation of Insup Lee, DYMOS was a fully integrated system that had access to an interactive user interface, a compiler and runtime for a [[Modula]] variant, and source code. This enabled DYMOS to type-check updates against the existing program.
| |
| | |
| == DSU Implementation ==
| |
| | |
| DSU systems must load new code into a running program, and transform existing state into a format that is understood by the new code. Since many motivational use-cases of DSU are time-critical (for example, deploying a security fix on a live and vulnerable system), DSU systems must provide adequate '''update availability'''. Some DSU systems also attempt to ensure that updates are safe before applying them.
| |
| | |
| There is no one canonical solution to any of these problems. Typically, a DSU system that performs well in one problem area does so at a trade-off to others. For example, empirical testing of dynamic updates indicates that increasing the number of update points results in an increased number of unsafe updates.<ref name="testing" />
| |
| | |
| == Code Transformation ==
| |
| | |
| Most DSU systems use [[subroutine]]s as the unit of code for updates; however, newer DSU systems implement whole-program updates.<ref name="ekiden" /><ref name="kitsune" />
| |
| | |
| If the target program is implemented in a [[virtual machine]] language, the VM can use existing infrastructure to load new code, since modern virtual machines support runtime loading for other use cases besides DSU (mainly [[debugging]]). The [[HotSpot]] [[JVM]] supports runtime code loading, and DSU systems targeting [[Java (programming language)]] can utilize this feature. | |
| | |
| In native languages such as [[C (programming language)|C]] or [[C++]], DSU systems can use specialized compilers that insert indirection into the program. At update time, this indirection is updated to point to the newest version. If a DSU system does not use a compiler to insert these indirections statically, it insert them at runtime with '''binary rewriting'''. Binary rewriting is the process of writing low-level code into the memory image of a running native program to re-direct functions. While this requires no static analysis of a program, it is highly platform-dependent.
| |
| | |
| [[#Ekiden and Kitsune|Ekiden and Kitsune]] load new program code via starting an entirely new program, either through [[fork-exec]] or [[dynamic loading]]. The existing program state is then transferred to the new program space.<ref name="ekiden" /><ref name="kitsune" />
| |
| | |
| == State Transformation ==
| |
| | |
| During an update, program state must be transformed from the original representation to the new version's representation. This is referred to as '''state transformation'''. A function which transforms a state object or group of objects is referred to as a ''transformer function'' or ''state transformer''.
| |
| | |
| DSU systems can either attempt to synthesize transformer functions, or require that the developer manually supply them. Some systems mix these approaches, inferring some elements of transformers while requiring developer input on others.
| |
| | |
| These transformer functions can either be applied to program state lazily, as each piece of old-version state is accessed, or eagerly, transforming all state at update time. Lazy transformation ensures that the update will complete in constant time, but also incurs steady-state overhead on object access. Eager transformation incurs more expense at the time of update, requiring the system to [[Stop_and_copy#Stop-the-world_vs._incremental_vs._concurrent|stop the world]] while all transformers run. However, eager transformation allows compilers to fully optimize state access, avoiding the steady-state overhead involved with lazy transformation.
| |
| | |
| == Update Safety ==
| |
| | |
| Most DSU systems attempt to show some safety properties for updates. The most common variant of safety checking is type safety, where an update is considered safe if it does not result in any new code operating on an old state representation, or vice versa.
| |
| | |
| Type safety is typically checked by showing one of two properties, '''activeness safety''' or '''cons-freeness safety'''. A program is considered activeness-safe if no updated function exists on the [[call stack]] at update time. This proves safety because control can never return to old code that would access new representations of data.
| |
| | |
| ''Cons-Freeness'' is another way to prove type safety, where a section of code is considered safe if it does not access state of a given type in a way that requires knowledge of the type representation. This code can be said to not access the state ''concretely'', while it may access the state ''abstractly''. It is possible to prove or disprove ''cons-freeness'' for all types in any section of code, and the DSU system Ginseng uses this to prove type safety.<ref name="cons-freeness" /><ref name="ginseng" /> If a function is proven ''cons-free'', it can be updated even if it is live on the stack, since it will not cause a type error by accessing state using the old representation.
| |
| | |
| Empirical analysis of ''cons-freeness'' and activeness safety by Hayden et all show that both techniques permit most correct updates and deny most erroneous updates. However, manually selecting update points results in zero update errors, and still allows frequent update availability.<ref name="testing" />
| |
| | |
| == Existing DSU systems==
| |
| | |
| === DYMOS ===
| |
| | |
| DYMOS is notable in that it was the earliest proposed DSU system. DYMOS consists of a fully integrated environment for programs written in a derivative of [[Modula]], giving the system access to a command interpreter, source code, compiler, and runtime environment, similar to a [[REPL]]. In DYMOS, updates are initiated by a user executing a command in the interactive environment. This command includes directives specifying when an update can occur, called ''when-conditions''. The information available to DYMOS enables it to enforce type-safety of updates with respect to the running target program.<ref name="dymos" />
| |
| | |
| === Ksplice ===
| |
| | |
| [[Ksplice]] is a specialized DSU system that targets only the [[Linux (kernel)|kernel Linux]]. It uses a [[diff]] to determine changes between current and updated versions of Linux, and then uses binary rewriting to insert the changes into the running kernel. Ksplice is unique among DSU systems in that it supports a single target program, and that target program is an [[Kernel (computing)|operating system kernel]].<ref name="ksplice" />
| |
| | |
| Ksplice was maintained by a commercial venture founded by its original authors, Ksplice Inc.. Ksplice Inc. was acquired by Oracle in July 2011.<ref>{{cite news|url=http://www.oracle.com/us/corporate/Acquisitions/ksplice/index.html|accessdate=21 July 2011}}</ref>
| |
| | |
| === Ginseng ===
| |
| | |
| Ginseng is a general-purpose DSU system. It is the only DSU system to use the ''cons-freeness'' safety technique, allowing it to update functions that are live on the stack as long as they do not make concrete accesses to updated types.
| |
| | |
| Ginseng is implemented as a source-to-source compiler written using the [[C Intermediate Language]] framework in [[OCaml]]. This compiler inserts indirection to all function calls and type accesses, enabling Ginseng to lazily transform state at the cost of imposing a constant-time overhead for the entirety of the program execution.<ref name="ginseng" /> Ginseng's compiler proves the ''cons-freeness'' properties of the entire initial program and of dynamic patches.
| |
| | |
| Later versions of Ginseng also support a notion of transactional safety. This allows developers to annotate a sequence of function calls as a logical unit, preventing updates from violating program semantics in ways that are not detectable by either activeness safety or ''cons-freeness'' safety. For example, in two versions of [[OpenSSH]] examined by Ginseng's authors, important user verification code was moved between two functions called in sequence. If the first version of the first function executed, an update occurred, and the new version of the second function was executed, then the verification would never be performed. Marking this section as a transaction ensures that an update will not prevent the verification from occurring.<ref name="vc" />
| |
| | |
| === UpStare ===
| |
| | |
| UpStare is a DSU system that uses a unique updating mechanism, '''stack reconstruction'''. To update a program with UpStare, a developer specifies a mapping between any possible stack frames. UpStare is able to use this mapping to immediately update the program at any point, with any number of threads, and with any functions live on the stack.<ref name="upstare" />
| |
| | |
| === PoLUS ===
| |
| | |
| PoLUS is a binary-rewriting DSU system for [[C (programming language)|C]]. It is able to update unmodified programs at any point in their execution. To update functions, it rewrites the prelude to a target function to redirect to a new function, chaining these redirections over multiple versions. This avoids steady-state overhead in functions that have not been updated.<ref name="polus" />
| |
| | |
| === Kitsune and Ekiden ===
| |
| | |
| Ekiden and Kitsune are two variants of a single DSU system that implements the state-transfer style of DSU for programs written in [[C (programming language)|C]]. Rather than updating functions within a single program, Ekiden and Kitsune perform updates over whole programs, transferring necessary state between the two executions. While Ekiden accomplishes this by starting a new program using the [[UNIX]] idiom of [[fork-exec]], serializing the target program's state, and transferring it, Kitsune uses [[dynamic linking]] to perform "in-place" state transfer. Kitsune is derived from Ekiden's codebase, and can be considered a later version of Ekiden.
| |
| | |
| Ekiden and Kitsune are also notable in that they are implemented primarily as application-level libraries, rather than specialized runtimes or compilers. As such, to use Ekiden or Kitsune, an application developer must manually mark state that is to be transferred, and manually select points in the program where an update can occur. To ease this process, Kitsune includes a specialized compiler that implements a [[domain-specific language]] for writing state transformers.<ref name="ekiden" /><ref name="kitsune" />
| |
| | |
| === Erlang ===
| |
| | |
| [[Erlang (programming language)|Erlang]] supports Dynamic Software Updating, though this is commonly referred to as "[[Erlang_(programming_language)#Hot_code_loading_and_modules|hot code loading]]". Erlang requires no safety guarantees on updates, but Erlang culture suggests that developers write in a defensive style that will gracefully handle type errors generated by updating.
| |
| | |
| == See also ==
| |
| | |
| *[[Ksplice]]
| |
| *[[Persistence (computer science)]]
| |
| | |
| == External links==
| |
| *[http://ksplice.com Ksplice Homepage]
| |
| *[https://github.com/cormander/ksplice Ksplice Source Code]
| |
| *[http://www.cs.umd.edu/projects/dsu/ Ginseng Project Page and Source Code] UpStare Paper] PoLUS Paper]
| |
| *[http://www.erlang.org/ Erlang Homepage]
| |
| | |
| == References ==
| |
| | |
| {{Reflist|
| |
| refs = <ref name="ekiden">{{cite journal
| |
| |first1 = Chris | last1 = Hayden
| |
| |first2 = Edward K. | last2 = Smith
| |
| |first3 = Michael | last3 = Hicks
| |
| |first4 = Jeffery | last4 = Foster
| |
| |journal = Data Engineering Workshops (ICDEW), 2011 IEEE 27th International Conference on
| |
| |pages = 179–184
| |
| |publisher = IEEE
| |
| |url = http://www.cs.umd.edu/~jfoster/papers/hotswup11.pdf
| |
| |year = 2011
| |
| |title = State transfer for clear and efficient runtime updates }}</ref><ref name="kitsune">{{cite journal
| |
| | last1 = Hayden
| |
| | first1 = Chris
| |
| | last2 = Smith
| |
| | first2 = Edward K.
| |
| | first3 = Michail | last3 = Denchev
| |
| | first4 = Michael | last4 = Hicks
| |
| | first5 = Jeffery | last5 = Foster
| |
| | year = 2011
| |
| | title = Kitsune: Efficient, General-purpose Dynamic Software Updating for C
| |
| | url = http://www.cs.umd.edu/~mwh/papers/kitsune.pdf }}</ref><ref name="testing">{{cite journal
| |
| |title = Evaluating dynamic software update safety using systematic testing
| |
| |first1 = Chris | last1 = Hayden
| |
| |first2 = Edward K | last2 = Smith
| |
| |first3 = Eric | last3 = Hardisty
| |
| |first4 = Michael | last4 = Hicks
| |
| |first5 = Jeffery | last5 = Foster
| |
| | year = 2011
| |
| |journal = Software Engineering, IEEE Transactions on
| |
| |issue = 99
| |
| |publisher = IEEE
| |
| |url = http://www.cs.umd.edu/~hayden/papers/empiricalsafety-draft.pdf }}</ref><ref name="ginseng">{{cite journal
| |
| | title = Practical dynamic software updating for C
| |
| | first1 = Iulian | last1 = Neamtiu
| |
| | first2 = Michael| last2 = Hicks
| |
| | first3 = Gareth | last3 = Stoyle
| |
| | first4 = Manuel | last4 = Oriol
| |
| | journal = ACM SIGPLAN Notices
| |
| | volume = 41
| |
| | issue = 6
| |
| | pages = 72–83
| |
| | publisher = ACM
| |
| | url = http://www.cs.umd.edu/~mwh/papers/ginseng.pdf }}</ref><ref name="cons-freeness">{{cite journal
| |
| |title = Mutatis mutandis: Safe and predictable dynamic software updating
| |
| |first1 = Gareth | last1 = Stoyle
| |
| |first2 = Michael | last2 = Hicks
| |
| |first3 = Gavin | last3 = Bierman
| |
| |first4 = Peter | last4 = Sewall
| |
| |first5 = Iulian | last5 = Neamtiu
| |
| |year = 2005
| |
| |journal = Proceedings of the ACM Conference on Principles of Programming Languages
| |
| | url = http://www.cs.umd.edu/~mwh/papers/proteus-popl.pdf }}</ref><ref name="upstare">{{cite journal
| |
| |title= Immediate Multi-Threaded Dynamic Software Updates Using Stack Reconstruction
| |
| |first1 = Kristis | last1 = Makris
| |
| |first2 = Rida A. | last2 = Bazzi
| |
| |journal = Proceedings of the 2009 conference on USENIX Annual technical conference
| |
| |url = http://files.mkgnu.net/files/upstare/doc/misc/upstare_usenix_09.pdf
| |
| |year = 2009 }}</ref><ref name="polus">{{cite journal
| |
| |title = POLUS: A POwerful Live Updating System
| |
| |author1 = Haibo Chen
| |
| |author2 = Jie Yu
| |
| |author3 = Rong Chen
| |
| |author4 = Binyu Zang
| |
| |author5 = Pen-Chung Yew
| |
| |journal = Software Engineering, 29th International Conference on
| |
| |year = 2007
| |
| |pages = 271–281
| |
| |url = http://ppi.fudan.edu.cn/system/publications/paper/chen-polus.pdf }}</ref><ref name="ksplice">{{cite journal
| |
| |title = Ksplice: automatic rebootless kernel updates
| |
| |first1 = Jeff |last1 = Arnold
| |
| |first2 = M. Frans | last2 = Kaashoek
| |
| |authorlink2 = Frans Kaashoek
| |
| |year = 2009
| |
| | journal = Proceedings of the 4th ACM European conference on Computer systems
| |
| | doi = 10.1145/1519065.1519085
| |
| |url = https://www.ksplice.com/doc/ksplice.pdf }}</ref><ref name="dymos">{{cite thesis
| |
| |author = Insup Lee
| |
| |title = DYMOS: A DYNAMIC MODIFICATION SYSTEM
| |
| |degree = Doctor of Philosophy (Computer Science)
| |
| |year=1983
| |
| |publisher = University of Wisconsin - Madison
| |
| |url = http://www.cis.upenn.edu/~lee/mydissertation.doc }}</ref><ref name="gupta">{{cite journal
| |
| |last1 = Gupta | first1 = Deepak
| |
| |last2 = Jalote | first2 = Pankaj
| |
| |last3 = Barua | first3 = Gautam
| |
| |title = A Formal Framework for On-line Software Version Change
| |
| |journal = IEEE Transactions on Software Engineering
| |
| |volume = 22
| |
| |number = 2
| |
| |pages = 120–131
| |
| |url = http://www.win.tue.nl/~hmei/SoftwareUpdate/A%20formal%20framework%20for%20on-line%20software%20version%20change.pdf
| |
| |year = 1996}}</ref>
| |
| <ref name="vc">{{cite journal
| |
| | first1 = Iulian | last1 = Neamtiu
| |
| | first2 = Michael| last2 = Hicks
| |
| | first3 = Jeffrey | last3 = Foster
| |
| | first4 = Polyvios | last4 = Pratikakis
| |
| |title = Contextual Effects for Version-Consistent Dynamic Software Updating and Safe Concurrent Programming
| |
| |journal = Proceedings of the {ACM} Conference on Principles of Programming Languages (POPL)
| |
| |year = 2008
| |
| |pages= 37–58 }}
| |
| </ref> }}
| |
| | |
| [[Category:System administration]]
| |