[Samsung Galaxy Tab Plus] garyd9:
After a PM exchange with the author of the "supercharger" script, I'd STRONGLY advise you NOT to use that script. It will override kernel parameters that the author has no f***ing clue what they do or why they exist.

In particular, several people might be seeing the so-called "sleep of death" as a direct result of his script. When the tablet encounters a kernel error, it runs a routine called "panic()" Within that routine is a parameter called panic_timeout. If panic_timeout is non-zero, the device will reboot after that many seconds. If panic_timeout is set to 0, instead of rebooting, the device will go into an infinite loop. The author of this "supercharger" script is setting that panic_timeout to 0 (and doesn't even know WHY he is doing it or realize the problems with it.)

Some more explanation might be useful: linux was originally written with desktop systems in mind. Any kernel needs some function to call when the **** hits the fan. In windows, it's known as the blue screen of death (BSOD.) In linux, it's "oops" or "panic." (oops is when the kernel realizes something bad has happened. Panic is the name of the function called when the kernel oops's.) So, people realized early on that there are two types of linux users: those who want to see the kernel panic information (which includes processor register info, stack traces, etc), and those who need the system to get back up ASAP (such as realtime systems.)

Therefore, they created that kernel parameter. If you are a geek running linux on a desktop machine (with a monitor attached - also known as a console), you set the panic_timeout to 0. If the kernel panics when you are away, linux displays lots of debugging type info and puts itself into an infinite loop (it's unstable now, so thats all it CAN do), when you get back, you'll see the panic info on the monitor and can do whatever you want with the info. This would be a bad thing for a device on battery, as that infinite loop is sucking CPU cycles. sleep states are considered unstable once panic() is called.

If you are most other people (or you are running linux on a machine with no console - such as an android tablet/phone), you set the kernel parameter to a number greater than 0 so that the kernel reboots the device... The debugging info is lost (not always... android has a special way of trying to keep it around called an android ram console) but at least you can use your phone... and after the reboot, your phone can go back into standby.

Most other people don't have this level of knowledge, but what they do know is this: if you don't know what you are doing, don't muck with it until you learn.

Oh, and yes... I _am_ pissed. I take personal offense when someone runs around acting like they know what they are doing when they really don't. This author of that "supercharger" script (who has the balls to insist that he owns the modifications he is making on an open source system) responded to me that he turned that off to prevent excess reboots. (what?) Then he suggested (as if he had a clue) that I enable a kernel parameter that has the kernel panic if it detects a soft lockup. Well, you *bleep*'ing *bleep*, that doesn't do any f'ing good if the code is ALREADY in the kernel panic!

That is about the one personality type on this Earth that really offends me.

I need a beer...

Gary