\nWindows lets you hibernate the entire machine, but why can’t\nit hibernate just one process? Record the state of the process\nand then resume it later.\n<\/p>\n
\nBecause there is state in the system that is not part of the process.\n<\/p>\n
\nFor example, suppose your program has taken a mutex, and then it\ngets process-hibernated. Oops, now that mutex is abandoned\nand is now up for grabs. If that mutex was protecting some\nstate, then when the process is resumed from hibernation,\nit thinks it still owns the mutex and the state should therefore\nbe safe from tampering, only to find that it doesn’t\nown the mutex any more<\/b> and its state is corrupted.\n<\/p>\n
\nImagine all the code that does something like this:<\/p>\n
\n\/\/ assume hmtx is a mutex handle that\n\/\/ protects some shared object G\nWaitForSingleObject(hmtx, INFINITE);\n\/\/ do stuff with G\n...\n\/\/ do more stuff with G on the assumption that\n\/\/ G hasn't changed.\nReleaseMutex(hmtx);\n<\/pre>\n\nNobody expects that the mutex could secretly get released\nduring the “…” (which is what would happen if the process\ngot hibernated). That goes against everything mutexes stand for!<\/p>\n
\nConsider, as another example, the case where you have a file\nthat was opened for exclusive access. The program will\nhappily run on the assumption that nobody can modify\nthe file except that program. But if you process-hibernate\nit, then some other process can now open the file (the exclusive owner\nis no longer around), tamper with it, then resume the original program.\nThe original program on resumption will see a tampered-with file and\nmay crash or (worse) be tricked into a security vulnerability.\n<\/p>\n
\nOne alternative would be to keep all objects that belong to\na process-hibernated program still open. Then you would have\nthe problem of a file that can’t be deleted because it is\nbeing held open by a program that isn’t even running!\n(And indeed, for the resumption to be successful across a reboot,\nthe file would have to be re-opened upon reboot. So now you have\na file that can’t be deleted even after a reboot because it’s\nbeing held open by a program that isn’t running. Think of the\namazing denial-of-service you could launch against somebody:\nCreate and hold open a 20GB file, then hibernate the process\nand then delete the hibernation file.\nHa-ha, you just created a permanently undeletable 20GB file.)\n<\/p>\n
\nNow what if the hibernated program had created windows.\nShould the window handles still be valid while the program\nis hibernated? What happens if you send it a message?\nIf the window handles should not remain valid, then what happens\nto broadcast messages? Are they “saved somewhere” to be replayed\nwhen the program is resumed? (And what if the broadcast message\nwas something like “I am about to remove this USB hard drive,\nhere is your last chance to flush your data”?\nThe hibernated program wouldn’t get a chance to flush its data.\nResult: Corrupted USB hard drive.)\n<\/p>\n
\nAnd imagine the havoc if you could take the hibernated process\nand copy it to another machine, and then attempt to restore it there.\n<\/p>\n
\nIf you want some sort of “checkpoint \/ fast restore” functionality\nin your program, you’ll have to write it yourself.\nThen you will have to deal explicitly with issues like the above.\n(“I want to open this file, but somebody deleted it in the meantime.\nWhat should I do?”\nOr\n“Okay, I’m about to create a checkpoint, I’d better purge all my buffers\nand mark all my cached data as invalid because the thing I’m\ncaching might change while I’m in suspended animation.”)<\/p>\n","protected":false},"excerpt":{"rendered":"
Windows lets you hibernate the entire machine, but why can’t it hibernate just one process? Record the state of the process and then resume it later. Because there is state in the system that is not part of the process. For example, suppose your program has taken a mutex, and then it gets process-hibernated. Oops, […]<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[2],"class_list":["post-39723","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-history"],"acf":[],"blog_post_summary":"
Windows lets you hibernate the entire machine, but why can’t it hibernate just one process? Record the state of the process and then resume it later. Because there is state in the system that is not part of the process. For example, suppose your program has taken a mutex, and then it gets process-hibernated. Oops, […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/39723","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=39723"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/39723\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=39723"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=39723"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=39723"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}