As part of a little benchmarking I'm doing for an app, I'm opening an adb shell, running the SQLite command line interface (sqlite3), and executing a long-running query to see how it performs on the device's hardware, with the installed version of SQLite.
However, SQLite keeps exiting, bringing me back to the ADB shell. The only message that's displayed is "Killed". Since I've seen SQLite report sepecific errors like "out of memory" before, I assume Android is killing the process, as opposed to SQLite encountering a problem. Assuming that is the case, is there a way to prevent the system from doing so?
I was hoping that if a watchdog process was killing the process for being non-responsive or taking up too much CPU time for too long, stop might help but it didn't.
This is roughly what I'm doing when my process gets killed, shortened up a bit for this post:
$ adb shell
root#android:/ # cd /database/location/
root#android:/database/location # sqlite3 database.db
sqlite> .output /dev/null
sqlite> .timer ON
sqlite> SELECT ... FROM ... WHERE ...;
Killed
root#android:/database/location #
Related
I am running android-cts . The commands I run are mentioned below,
cts-tf
run-cts --plan --cts-camera
It is being running for two days . How do I stop the current task and save the existing logs .
Also it is mentioned in documentation ,that the cts logs will be stored in
CTS_ROOT/android-cts/results/start_time.zip
But I dont see a start_time.zip in the location specified .
There are few ways by which you can stop the CTS invocation and result will be generated of your runs,
Unplug the USB Cables from the devices, this will make tradefed to not detect any device and once timeout occurs, it will generate result on testcases and modules it ran.
Kill command, just write the kill in the tradefed, and it will kill and stop the invocation threads for the runs. once that is done, it will generate the result but make sure not to give kill command more than 1 or else it will exit from tradefed without generating the result.
I'm using the RootTools library, and I need to execute two commands. The first one runs a binary, the second sends SIGINT to it, to kill it.
RootTools (as far as I know) can only have one root shell open at a time, so commands can only be executed one by one. This is a problem, because I have no way to stop my binary after I've ran it.
How can I do any of the following things?
Execute two commands at once, so I can run my kill command when the binary is running
Send SIGINT to my native process some other way (e.g. with a RootTools function)
I need to use RootTools because it's the only way for me to read standard output from my program. If there's another way to do that, though, please comment.
Do you think you can concat the commands?
Let's say I want to launch a find command, but if it takes 5 seconds, I want it to stop:
find / & sleep 5 && kill $!
We can get a better suited one liner, too (i.e. ignore standard error, kill only if needed etc.).
You could also just store the PID and kill it later (be careful, if the daemon stopped to run, his PID can be reused by the OS):
run the daemon in a root shell
my-daemon >/dev/null & echo "PID: $!"
parse the output in Java and store the PID (SharedPreferences?)
var pid = outputLine.split(" ")[1]
later on, stop the daemon with a root shell
kill <pid>
My application has come c++ code and many pthreads. I close application with exit(0);. After that, I listed running process with adb shell ps. This command shows me current running processes on device.
Output shows there are still some processes related my application (their names are my applicaiton name). After running application several times, these garbage processes number increases. At some point, device cannot response, because of there is small memory left.
I realized some issues. When application starts, it has a pid and I can see that on process list (with adb shell ps). Also, I see some processes that theirs parent process is application processes. And, if I exit from application, application process is removed from list but previous child processes still remaining. And, their parent processes become 1 (I think it is main OS process or something like that).
This problems occurs on HTC One. it doesnt occur on Samsung Note 2. After close app, all child processes are killed automaticly on Samsung.
How can I prevent this child processes remaining?
I want to know why you have not use fork just use pthread,it can make a new process??(my linux program is not good)
mybe you can try the code before application exit
Runtime.getRuntime().exec("killall " + applicationName);
I'm appending init.rc in Android root with:
service logcat /system/bin/logcat -v long -f /mnt/sdcard/logcat.log
This solution doesn't generate any logs. The logcat.log file doesn't exist.
How can i start gathering logcat output through init.rc ?
A couple of things that could be causing problems above:
1. you defined your service to be called logcat. That looks awfully close to what might be a reserved/pre-existing name. I would choose a more distinguished service name.
2. there is no explicit start trigger for the service, hence its entirely dependent on the context in which its defined (i.e. which init phase). Pick the wrong phase (i.e. too early) and /mnt may not even exist.
3. the service will by default be running as root and thus the logcat.log file will be rw only by root. Not good to run processes as root. And not good to force readers to be root in order to read the log file.
Here the approach I've used to achieve what you're looking to do.
Problem: Ordinarily, Android log messages remain in the kernel’s (volatile) memory only and thus doesn’t survive across reboots.
Solution: To retain those log messages across reboots requires them to be written to persistent storage (i.e. the filesystem). The following code defines such a service that is started by Android during init.
Step 1, define a service that the Android init process will spawn to do this activity. This goes in init.rc.
service persistentLogging /system/bin/logcat -r 1024 -n 9 -v threadTime -f /cache/logs/log
user system
group system log
disabled
Notes about the above:
it creates a service called persistentLogging (that will be referred to in the second step below) by the start trigger.
it requests logcat to do a rolling log file (consisting of 10 files / 1Mb each) in directory - /cache/logs (i.e. log, log.1, log.2, … log.9). Adjust to suit your needs.
the service is to run as system user. This means the log file will be read+write only by system. If your app has system privileges then you’ll be able to read the log file. I’ve also defined the service to be in the log group too since that seems appropriate although since the files are not readable by group its a moot point.
the service is initially disabled. It will be started by a trigger defined below
the service is NOT oneshot. Hence, should it die, Android will attempt to restart it.
Step 2, define a trigger for starting the service. This also goes in your init.rc file.
on post-fs
mkdir /cache/logs 0775 system log
start persistentLogging
Notes about the above:
the commands are triggered during the ‘post-fs’ phase so that they occur after filesystem partitions have been mounted and when other system directories are having their permissions changed. Ideally, this service should start as late as possible because its not important or used by any other start-up activity.
the trigger first creates the target directory before starting the service. Remember the mkdir command syntax is defined by the init.rc language. In Android this syntax is not a sh syntax eventhough it looks a lot like it.
eventhough the above logging service doesn’t start until the post-fs phase of init, it will nevertheless dump all logging information since the beginning of kernel's startup as these log messages are already in the kernel buffers and this logging service is merely copying those messages to a file.
although both code fragments above ultimately need to appear in init.rc file, it is more maintainable if those additions are made to the init.${ro.hardware}.rc file defined for the device. e.g. init.freescale.rc which is automatically included by init.rc.
If we need to start the logcat and collect all the log buffers after on post-fs-data/boot completed from init.rc you can use below code in init.rc file.
on property:dev.bootcomplete=1
start logging
on post-fs-data
start logging
service logging /system/bin/logcat -b all -v threadTime -f /data/directory_name/log -r 100000 -n 9
user system
group root system log
disabled
first time poster here. I have a problem with android. I have cron daemon set up to run a script every once and a while. This script has alarms built in to it that trigger when the script fails or succeeds. The alarms use "am" commands to activate actions on some APKs (one wakes the device, the other plays music and or vibrates).
The script works fine. However, when it is called from the crond it behaves abnormally. dmesg shows init killed the process as per this bit of code:
svc = service_find_by_pid(pid);
if (!svc) {
ERROR("untracked pid %d exited\n", pid);
Obviously my script is not in the init.rc file, nor is crond for that matter, as a service (my phone is locked/reloads init.rc from ramdisk every boot). Is there a manner of fixing this problem without editing the init.rc?
this walkthrough seems like it had you in mind:
http://howto.ccroms.net/howto/cron
As I have always wanted an actual cron installation on my phone, I
worked on patching vixie-cron for just that. Below are the tales of my
adventures: