When you press Enter then a shell is started and you can test work
inside a system which you have just created.
-Možná vylepšení
-===============
+Possible Enhancements
+=====================
-Dále můžete provést drobná vylepšení vašeho systému, která vám mohou
-zjednodušit další práci.
+Additionally, you can work out minor improvements to the system that
+can simplify your further work within a booted system.
1. Můžete připojit souborový systém `/proc`, aby fungovaly příkazy
jako např. `ps` (výpis běžících procesů). Příkaz spusťte v
emulátoru, ne na vaší pracovní stanici.
+ You can mount a `/proc` virtual filesystem to allow commands such as `ps`
+ (listing running processes) to function correctly. Use next command in
+ the emulator, not on your workstation.
+
mount -t proc none /proc
-2. V RAM-disku můžete vytvořit soubor `/etc/init.d/rcS`, který bude
- obsahovat příkazy, které budou spuštěny při bootu systému.
+2. The commands intended to be executed during each system start
+ should be writtent into newly created file `/etc/init.d/rcS`.
mkdir -p _install/etc/init.d
cat <<EOF > _install/etc/init.d/rcS
EOF
chmod +x _install/etc/init.d/rcS # nastavení spustitelnosti
- Nyní musíte znovu vytvořit RAM-disk a nabootovat.
+ The RAM-disk has to be build again and the system should be booted
+ again to test added functionality.
-Jaderné moduly
-==============
+Kernel Loadable Modules
+=======================
Jaderné moduly jsou přeložené kusy kódu, které lze za běhu nahrávat do
Linuxového jádra. Pokud bychom chtěli nalézt analogickou věc v
firewall) či sloužit jako knihovna pomocných funkcí pro jiné moduly
(např. libata).
-Zdrojový kód jednoduchého jaderného modulu vypadá následovně:
+Kernel modules are separate compiled pieces of code that can be loaded
+into running Linux kernel. If we wanted to find an analogy in the user
+environment, then it would be shared *shared/dynamically linked library*
+or program *plugins*. Kernel module can provide device driver functionality,
+can add support for a file system, can add new features to the core
+(i.e., firewalls), or serve as a library of utility functions for other
+modules (i.e., libata).
+
+The example of source code of a simple kernel module follows:
#include <linux/init.h>
#include <linux/module.h>
module_init(hello_init);
module_exit(hello_exit);
-*Příklad převzat z [LDD3][LDD3].*
+*Example taken from [LDD3][LDD3].*
-Překlad modulu provedeme pomocí jednoduchého souboru Makefile, který
-bude obsahovat jedinou řádku (zde předpokládáme, že výše uvedený
-soubor se jmenuje **khello.c**):
+The compilation can be controlled by a simple Makefile,
+which will contain a single line (here we assume that the
+above file is named **khello.c**):
obj-m = khello.o
-Nyní stačí zavolat `make` se správnými parametry:
+Now a `make` program has to be invoked with right parameters:
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
-Tímto říkáme, že příkaz `make` načte `Makefile` z adresáře se
-zdrojovými kódy aktuálně běžícího jádra (o který adresář se jedná
-můžete zjistít pomocí `readlink -f /lib/modules/$(uname -r)/build`),
-pomocí proměnné `M` řeknete, že se váš modul nachází v aktuálním
-adresáři a slovo `modules` na konci znamená, že chcete, aby se
-zkompilovaly pouze moduly.
+The parameter `-C` direct a `make` build control tool
+to read kernel installation provided `Makefile` from actual
+running kernel sources/build directory directory (where
+are actual directory located can be check by link examination
+`readlink -f /lib/modules/$(uname -r)/build`). The parameter
+`M` specifies that your module is located in the current
+directory and kernel make-system should build only in that directory.
+The word `modules` on the end means that you want to compiled modules only.
-Pokud vše dopadlo dobře, objevil se vám soubor `khello.ko`, což je
-modul, který můžete zavést do jádra příkazem
+If everything goes well, the file `khello.ko` is created as a result
+of compilation, which is module which can be load into kernel by command
insmod khello.ko
+Assignment
+==========
-Zadání
-======
-
-Vytvořte jednoduchý jaderný modul, který po zavedení do jádra vypíše
-vaše jméno (objeví se ve výstupu příkazu `dmesg`). Jinak nemusí dělat nic.
-Předveďte činnost vašeho modulu ve vámi vytvořeném systému běžícím v
-emulátoru.
+Create a simple kernel module, which after logs your name after insertion
+into the kernel. The kernel log can be examined by `dmesg` command.
+No other functionality is required from the module.
+Demonstrate functionality of result of your work in a emulator
+environment with root filesystem created according above described steps.
-Kdo se bude nudit, může zkusit rozšířit modul tak, aby se jeho jméno
-objevilo v souboru `/proc/myname` nebo vytvořit jednoduchý ovladač,
-který bude vracet vaše jméno při čtení z `/dev/myname`. Návod najdete
-v [tomto článku][henson_drivers] (strany 2 a 3).
+Who will get bored, may try to extend the module such way that his/her
+name appeared in the file `/proc/myname` or a simple driver
+can be created which would return your name when read from `/dev/myname`
+is issued. Instructions can be found in [this article][henson_drivers] (page 2 and 3).
-Tipy a triky
-============
+Tips and Tricks
+===============
-* Pro vyvolání určitého příkazu z historie můžete použít klávesu
- `Ctrl-R` následovanou textem hledaného příkazu. Např:
+* The shell history search by Ctrl-`R` followed by search text
+ can be used to repeat a command already issued. For example:
<Ctrl-R>cpio<Enter>
-* Pro rychlé kopírování textu mezi programy (např. příkazy z této stránky do shellu),
- můžete použít prostřední tlačítko myši. Funguje to tak, že text označíte myší
- (nemačkáte při tom Ctrl-C) a stiskem prostředního tlačítka myši v terminálovém
- okně ho vložíte na příkazovou řádku shellu. Tím, že při tom nemusíte šahat na
- klávesnici vám to půjde rychleji.
-
-* Pokud je Qemu spouštěný přes vzdálené připojení (např. server postel),
- je potřeba pro zobrazení emulované obrazovky spouštěného stroje
- buď provést protunelování X protokolu (`ssh -X`) nebo používat Qemu
- s emulací obrazovky v textovém režimu `qemu -curses`. Další možnost
- je emulovat HW bez grafické karty `qemu -nographic` a nastavit testovaný
- systém tak, aby systémová konzole směřovala na sériový port.
-
-Reference
-=========
+* To quickly copy text between programs (i.e., commands from the shell of this page)
+ use a middle mouse button. It works so that the text is selected by mouse
+ left button (the Ctrl-C is not pressed/used) and then position mouse
+ to desired target terminal/window/location and press the middle mouse button.
+ It is not necessary to touch keyboard at all and you get forward faster.
+
+* If the QEMU is executed over a remote connection (i.e. on server postel)
+ then tunneling of X protocol (`ssh -X`) is required to allow
+ QEMU emulated screen of target system to be launched. Or the QEMU
+ and target system can be run with text mode console (`qemu -curses`).
+ Yet another option is to run QEMU without console and graphic card
+ emulation at all (`qemu -nographic`) and setup emulated system system
+ console to be redirected to serial port.
+
+References
+===========
* [ramfs, rootfs and initramfs](http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=blob;f=Documentation/filesystems/ramfs-rootfs-initramfs.txt;hb=HEAD)
* [Early userspace support](http://git.kernel.org/?p=linux/kernel/git/torvalds/linux-2.6.git;a=blob;f=Documentation/early-userspace/README;hb=HEAD)
projects / edu / osp-wiki.git / commitdiff