bootimage | Tool to create bootable disk images from a Rust OS kernel | Runtime Evironment library

I'd like to explain zx485's comment in more detail:

I've often seen that assembly language beginners are confused about what instructions like int (x86), syscall (MIPS) or SWI (ARM) actually do.

Actually, these instructions are a special form of call instruction: They call some sub-routine which is typically located in the operating system.

64-bit x86 CPUs have different operating modes. One of them is named "real mode". In this mode the CPU can only execute 16-bit code.

The BIOS sub-routine that can be called using int 0x16 only works when the PC is operating in "real mode".

The fact that your program is a 64-bit program (registers like rax are used) tells us that your CPU is not running in real mode.

If you are writing your own operating system, you can define own sub-routines that are called by certain int instructions:

You can define a sub-routine that is called by int 0x16 which reads the keyboard and another one called by int 0x10 writing to the screen.

However, you are also free to define that int 0x16 is used for writing to the screen and int 0x10 is used for hard disk access in your operating system.

And in every case you'll have to write the sub-routines yourself because the existing sub-routines in the BIOS cannot be used in any other operating mode than "real mode". (This is what Ross Ridge is indicating in his comment.)

A little more elaboration.

The problem was that you had the extra parenthesis make in line button = pygame.transform.scale(infobut, ((130, 80)).

The reason you got Syntax Error is python thought you were truing to type variable=(variable_declared="in parenthesis"), which is a Syntax Error.

If you commented all of the code after button = pygame.transform.scale(infobut, ((130, 80)) you get a more explanatory error:

I am not sure if you can save time this way (since this solution needs to zip/unzip multiple times which needs more time then to search for all Android.mks on my machine) but since your question is:

Is there a way to build the kernel and create a boot image withouth having to read all Android.mk files.

you could give this a try:

Preperations:

1. call make dist once
2. unzip the target_files.zip in out/dist/

now create a script that does the following for you:

1. overwrite the kernel in your unpacked target_files with your newly build kernel
2. zip your target_files with your new kernel
3. use the python script img_from_target_files from build/tools/releasetools/ with the extra parameter -z. Example: img_from_target_files -z out/dist/target_files.zip new_imgs.zip
4. inside the newly created new_imgs.zip you will find your new boot.img with your new kernel

In python 3, subprocess streams are binary.

To write a string, just encode a binary, in your case ascii codec is OK:

The first two properties you are listing [ro.bootimage.build.fingerprint] and [ro.vendor.build.fingerprint] are not related to a fingerprint reader device, but to the cryptographic fingerprint of the Android disk image for the boot partition (ro.bootimage) and vendor-specific software partition (ro.vendor).

The property [init.svc.fingerprintd] tells you the current state (running) of the fingerprint daemon (fingerprintd) service (svc). This service is needed to enroll fingerprints and perform other operations (see https://source.android.com/security/authentication/fingerprint-hal).

So you need to look elsewhere for a way to check if the fingerprint option is available and set. The FingerprintManager API has a public method hasEnrolledFingerprints() which can be used to determine if there is at least one fingerprint enrolled. You can call this API this from within an app.

From an adb shell, you might have to call the fingerprintd service directly instead of using the API (Use Android API functions with ADB).

After finding out that there is already a more or less working touchscreen definition in the device tree but that the pins are different, I ended up with the following device tree:

I run a buildroot make and during this build process a text file is created. After this happens another make as part of the build is run. I want to read the contents of the generated file into a variable and use them. This doesn't work as at the start of my buildroot make it sees the file as not existing, so even though it is generated before the code is run make has already decided it doesn't exist.

This happens because another make does not know what buildroot make produces, i.e. the dependency information is missing (this is why recursive make is problematic). In other words, another make does not know that buildroot make produces version.txt.

A few solutions come to mind:

1. Have a shell script that invokes the makefiles in sequence, e.g. make -f buildroot.mk && make -f another.mk. This way another.mk observes all files produced by buildroot.mk.

2. Invoke buildroot.mk from another.mk during the first phase, before the targets and dependencies are evaluated. E.g.: