Allow running a single unmodified regular (non-PIE) Linux executable

[nyh]

OSv currently can only run position-independent shared objects.

This means we usually can't run a random Linux application without recompiling it (with -fPIC -shared), unless we're lucky and the application is already mostly a .so (like is the case in the JVM).

I want to allow running a single position-dependent executable, while moving the rest of OSv to where this executable allows us.

This will probably come with some strings attached: Obviously, only one such executable can be run at a time. Also, we may need to know at boot time about this executable. But I think this should be doable, and will make it really easy to create OSv images out of existing Linux software (e.g., Fedora RPMs) without any recompilation of anything.

[tzach]

@nyh
Would it be possible to scan the executable for non implemented sys call (e.g. fork)?
If it can be done as part of image building, it can gracefully fail early.

[nyh]

It is possible (and very easy) to know if a dynamically-linked executable
might fork, eg by using 'nm'. The problem though is it might use fork in
a non-interesting code path (eg if an option is enabled but you don't plan
to enable it). So you can have false positives.
On Feb 13, 2014 3:54 PM, "Tzach Livyatan" notifications@github.com wrote:

@nyh https://github.com/nyh
Would it be possible to scan the executable for non implemented sys call
(e.g. fork)?
If it can be done as part of image building, it can gracefully fail early.

Reply to this email directly or view it on GitHubhttps://github.com//issues/190#issuecomment-34979507
.

[tzach]

Sound like we need a script which given a binary code of a program,
decide whether the program finishes running or continues to run forever.
Shouldn't be too hard!

[glommer]

On Thu, Feb 13, 2014 at 8:38 PM, Tzach Livyatan notifications@github.comwrote:

Sound like we need a script which given a binary code of a program,
decide whether the program finishes running or continues to run forever.
Shouldn't be too hard!

IMHO, the way to do it is to just let the program run and abort on fork().
An external tool like capstan could have an optional check option to check
if a binary is fully compliant.
If it is, fine. If it isn't, use it at your own risk.

Reply to this email directly or view it on GitHubhttps://github.com//issues/190#issuecomment-34997319
.

[nyh]

Good idea. I'll do it right after I figure out a way to square a circle :-)
On Feb 13, 2014 6:38 PM, "Tzach Livyatan" notifications@github.com wrote:

Sound like we need a script which given a binary code of a program,
decide whether the program finishes running or continues to run forever.
Shouldn't be too hard!

Reply to this email directly or view it on GitHubhttps://github.com//issues/190#issuecomment-34997319
.

[copumpkin]

It is possible (and very easy) to know if a dynamically-linked executable
might fork, eg by using 'nm'. The problem though is it might use fork in
a non-interesting code path (eg if an option is enabled but you don't plan
to enable it). So you can have false positives.

Doesn't really affect the overall point, but you can also have false negatives, if someone forks directly via syscall without using the libc call.

[gebi]

which would be the case for all golang executables (they use the libc only for the resolver which is configurable, and AFAIK for getpwuid_r)

(sorry for the noise, i've no idea why i got notified by github for this thread, but anyway if i already got the message i thought i could also write back about it).

[elazarl]

@copumpkin you can still find that out, by scanning the assembly instructions. This heuristic should work fine for "normal" programs without JIT or self modified code.

[copumpkin]

@elazarl determining actual executable code to disassemble in a compiled binary is pretty hard to approximate, and generally impossible to get right :) either way, this discussion is entering the realm of impracticality

[elazarl]

objdump -d ELF|grep syscall is not always correct, but would work for many
"normal" program.

On Mon, Aug 17, 2015 at 9:40 PM, Daniel Peebles notifications@github.com
wrote:

@elazarl https://github.com/elazarl determining actual executable code
to disassemble in a compiled binary is pretty hard to approximate, and
generally impossible to get right :) either way, this discussion is
entering the realm of impracticality

—
Reply to this email directly or view it on GitHub
#190 (comment)
.

[copumpkin]

@elazarl I don't think we're disagreeing 😄