I mean the source code of sendto, recv, listen... I mean how they internally work at the kernel level...?
Of course you can get the kernel source code for the sockets API, simply download any of the open source UNIX or UNIX-like kernels: Linux, FreeBSD (Building and Installing a Custom Kernel), OpenBSD (Building the System from Source), NetBSD (NetBSD Documentation: Kernel) and probably others.
Related
I installed CentOS 7.6 then installed all things QEMU on my machine. I have a SPARC image I need to bringing up in a VM. I've been using qemu-system-sparc.
$ qemu-system-sparc -m 256 -hda solaris_v2-qemu_v2.2.0.disk -nographic -bios ./openbios-sparc32
This is on a box on which I have Fedora-30 installed.
Can I use qemu-sparc to bring up my Solaris image: solaris_v2-qemu_v2.2.0.disk ?
If so, how?
BTW, qemu-sparc come with (on CentOS 7.6):
$ sudo yum install qemu*
PS> I've tried to install qemu-system-sparc on my CentOS box but ended up in a never-ending whack-a-mole game of dependencies.
After a great deal of web searches, I found this:
QEMU as an userspace emulator
QEMU usually comes in two flavors: qemu-system-* are system emulators
(able to run entire operating systems as seen in the previous
section), while qemu-* are userspace emulators (only able to run
userspace applications).
QEMU as an userspace emulator is thus able to directly execute a SPARC
application, by emulating the syscalls that the application requests.
Among the greatest features of this approach are:
The output of application is directly displayed in the terminal,
Arguments to applications are directly given through the command line,
QEMU returns the return code of applications, etc. QEMU really just
acts as a wrapper around the application, as time or nice do.
The only complicated thing you have to do in this approach is to
compile a cross-toolchain for SPARC, so SPARC programs can be compiled
on the host computer. Such a cross-toolchain can be generated by using
the fabulous crosstool-ng.
So the answer appears to be: no, you CANNOT use qemu-sparc to run your image in a VM.
You need the qemu-system-sparc, wich will "emulate" a sparc system.
qemu-sparc will only emulate the CPU and syscalls, thus a SPARC compiled program (that you can extract from your disk image if needed) will run on non-sparc hosts, while most syscalls be "translated" by qemu into your host syscalls, thus a SPARC program can run on said host. file io, kernel stuff, it mostly get translated and run on your host. Handy for debugging or reverse engineering.
Try:
yum install qemu-kvm
The dependencies are required ofcourse. Not very usefull in your case but you could also compile qemu yourself, maybe the dependencies overlap:
git glib2-devel libfdt-devel pixman-devel zlib-devel
My question is rather conceptual. I noticed that there are different packages for the same architecture, like x86-64, but for different OSes. For example, RPM offers different packages for Fedora and OpenSUSE for the same x86-64 architecture: http://www.rpmfind.net/linux/rpm2html/search.php?query=wget - not to mention different packages served up by YUM and APT (for Ubuntu), all for x86-64.
My understanding is that a package contains binary instructions suitable for a given CPU architecture, so that as long as CPU is of that architecture, it should be able to execute those instructions natively. So why do packages built for the same architecture differ for different OSes?
Considering just different Linux distros:
Besides being compiled against different library versions (as Hadi described), the packaging itself and default config files can be different. Maybe one distro wants /etc/wget.conf, while maybe another wants /etc/default/wget.conf, or for those files to have different contents. (I forget if wget specifically has a global config file; some packages definitely do, and not just servers like Exim or Apache.)
Or different distros could enable / disable different sets of compile-time options. (Traditionally set with ./configure --enable-foo --disable-bar before make -j4 && make install).
For wget, choices may include which TLS library to compile against (OpenSSL vs. gnutls), not just which version.
So ABIs (library versions) are important, but there are other reasons why every distro has their own package of things.
Completely different OSes, like Linux vs. Windows vs. OS X, have different executable file formats. ELF vs. PE vs. Mach-O. All three of those formats contain x86-64 machine code, but the metadata is different. (And OS differences mean you'd want the machine code to do different things.
For example, opening a file on Linux or OS X (or any POSIX OS) can be done with an int open(const char *pathname, int flags, mode_t mode); system call. So the same source code works for both those platforms, although it can still compile to different machine code, or actually in this case very similar machine code to call a libc wrapper around the system call (OS X and Linux use the same function calling convention), but with a different symbol name. OS X would compile to a call to _open, but Linux doesn't prepend underscores to symbol names, so the dynamic linker symbol name would be open.
The mode constants for open might be different. e.g. maybe OS X defines O_RDWR as 4, but maybe Linux defines it as 2. This would be an ABI difference: same source compiles to different machine code, where the program and the library agree on what means what.
But Windows isn't a POSIX system. The WinAPI function for opening a file is HFILE WINAPI OpenFile(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle);
If you want to do anything invented more recently than opening / closing files, especially drawing a GUI, things are even less similar between platforms and you will use different libraries. (Or a cross platform GUI library will use a different back-end on different platforms).
OS X and Linux both have Unix heritage (real or as a clone implementation), so the low-level file stuff is similar.
These packages contain native binaries that require a particular Application Binary Interface (ABI) to run. The CPU architecture is only one part of the ABI. Different Linux distros have different ABIs and therefore the same binary may not be compatible across them. That's why there are different packages for the same architecture, but different OSes. The Linux Standard Base project aims at standardizing the ABIs of Linux distros so that it's easier to build portable packages.
I am interested in operating system development and have a basic knowledge of c, c++, and java. I would like to program a custom text based shell/command line that runs on top of the FreeBSD kernel.
My question is how would I go about obtaining the kernel and writing my custom environment into it, and what tools and resources would I need.
Btw. I am also open to linux, I just prefer the BSD License.
Shell is just an ordinary program, like any other. It doesn't use any special APIs. So, you can just install FreeBSD, write the software you would like to become the shell, and just set it up as user's shell, by using chsh command.
How to find the implementation of execv() (including its path) and where is it defined in the linux kernel 3.2?
I am trying to find its implementation and write a redirection code in this file which redirects to my custom system call.
What non-GUI programs (daemons) use glib?
I use glib quite a bit in non-GUI programming, especially for FUSE filesystems. Lots of routines to complement glibc, things like hash tables, a linked list implementation, a cross-platform threading library - lots of useful stuff for general-purpose programming. I think of it like C's version of Boost.
On my Ubuntu system apt-cache rdepends libglib2.0-0 gives me, among many others:
amanda-server (backup software)
bitlbee (IRC <-> various IM proxy)
blktool (tool to tune block device parameters; not a daemon AFAIU)
collectd (system statistics collection and monitoring daemon)
consolekit (framework for defining and tracking users, sessions and seats)
devicekit-disks (abstraction for enumerating block devices)
devicekit-power (abstraction for power management)
(I got bored at this point)
This lists package rather than actual binary dependencies; it's possible (but I don't think likely) that some of these packages ship GUI applications that depend on glib.
Let's take, say, consolekit and verify:
dpkg -L consolekit tells me the daemon is /usr/sbin/console-kit-daemon, and ldd /usr/sbin/console-kit-daemon tells me it depends on libglib, libgthread, libgmodule, libgobject, libgio, but no GUI stuff. So here you are, a genuine daemon using glib.
Irssi, an IRC client with support for scripts.
GStreamer is built upon GLib/GObject.
Most notable in my memory is libpurple aside from its GUI counterpart Pidgin