Command Line

Ha egy távoli gépre be tudunk lépni ssh-val és fájlokat is tudunk másolni scp-vel, akkor elég hamar felmerül, hogy az egyenkénti fájlmásolás helyett mennyivel kényelmesebb lenne, ha egy külön alkönyvtárban egyszerűen elérhetnénk a távoli gép fájljait.

Ehhez én a fuse egyik fájlrendszerét, az sshfs-t szoktam használni:

sshfs pi@192.168.1.227:/home/pi/test ~/test/

A parancs után a ~/test alkönyvtárban a 192.168.1.227 IP-című gép /home/pi/test alkönyvtárát érhetjük el. A használat végén

fusermount -u ~/test


paranncsal tudjuk leválasztani a csatolást.

Rögtön felmerülhet, mi szükség van erre, miért nem használok pl. NFS-et. Több különbség is van a két dolog között amit itt most nem sorolok fel, az egyik lényeges, hogy sshfs nem igényel szerver oldali konfigurációt.

Bár a bevezető mondatban ssh-t és scp-t említettem, sshfs valójában sftp-re épül. Az esetek többségében ez nem fontos, de ha mondjuk az OpenWrt-t használó routerünket szeretnénk elérni, ahol alapesetben DropBear van OpenSSH helyett, akkor sshfs nem fog működni, csak ha felinstalláljuk az sftp szervert is.

Ha valaki alaposabban szeretné megismerni fuse és sshfs projecteket, akkor érdemes Szeredi Miklós ( fuse és sshfs fejlesztő ) előadását megnézni:

Úgy látom a beágyazott videó nem mutatja rendesen a képernyőképeket, ide kattintson akit érdekel.

Bár a blog neve commandline, azért én is használok grafikus felületet. Ha több gépen kell egyszerre grafikusan dolgozni, akkor nekem mindig kényelmetlennek tűnt a több egér/billentyűzet. Ehelyett az x2x programmal megoldható, hogy két külön gép két külön X szerverét virtuálisan egymás mellé helyezzük, és az egyik képernyőn jobb oldalon kimenő egérkurzor a másik képernyő bal oldalán megjelenjen. Ezután a billentyűzettel is a másik gépen gépelhetünk.

Az összekapcsolás megy parancssorból (használatához ssh ( X11Forwardinggal ) szükséges):

ssh -X user@masikgep.akarmi.hu 'x2x -east -to :0'

Fontos, hogy itt nem arról van szó, hogy a gépünkhöz két monitort kötünk. A másik monitor egy teljesen másik X szerverhez tartozik, ami egy másik géphez csatlakozik.

Sikerült túl sok backportolt csomagot felinstallálnom, így megbízhatatlanná vált a gépem. Ahhoz, hogy kijavítsam a hibát, szükségem volt a frissen installált rpm csomagok listájára:

rpm -qa --queryformat '%{installtime} %{name}-%{version}-%{release} %{installtime:date}\n' | sort -n +1 | sed -e 's/^[^ ]* //'

A script az öszes installált csomagot kilistázza időrendben, így elég a lista végét nézni.

forrás: http://www.rpm.org/max-rpm/s1-rpm-query-handy-queries.html

Dicsértem már GNU parallelt, a korábbi példákban csak egyetlen számítógépet használtam. Parallel képes arra is, hogy az elvégzendő feladatot több számítógép között ossza szét. Itt most egy elég speciális esetet mutatok be, valójában nem osztjuk szét a feladatot, hanem inkább átadjuk egy gyorsabb számítógépnek.

Vegyünk egy alkönyvtárat, ahol sok jpg fájl van, ezeket szeretnénk png-re konvertálni és közben ( csak hogy lassabb legyen ) még egy kicsit életleníteni. A következő parancsot futtatjuk egy fájlra:

convert alma.jpg -gaussian-blur 5x5 alma.png


Parallel segítségével az alkönyvtár összes jpeg fájljának feldolgozása:

find . -name "*.jpg" | parallel convert {} -gaussian-blur 5x5 {.}.png

A lassú számítógépen ez 12 perc 17 másodpercig fut, a gyors számítógépen 48 másodpercig.

Felmerülhet a kérdés, hogyan fértem hozzá a laptopomnál 15-ször gyorsabb számítógéphez. A válasz egyszerű, a példában a laptop a gyors gép, egy 15-ször lassabb géphez fértem hozzá.

Ha a lassú gépen dolgozunk, akkor alapesetben az input fájlokat össze kell csomagolnunk, átmásolnunk a gyors gépre, ott ugyanazt a scriptet lefuttatni, majd a végeredményt visszamásolni. Parallel mindezt megteszi helyettünk:

find . -name "*.jpg" | parallel -S user@gyors.akarmi.hu --trc {.}.png convert {} -gaussian-blur 5x5 {.}.png

A -S kapcsoló után kell megadnunk a gépek listáját, melyek elvégzik a feladatot. Itt egyetlen egy gépet adtam meg. A --trc a transfer, return, cleanup rövidítése, hatására az input fájlokat ( jpeg fájlok ) átmásolja parallel a másik gépre, majd a png fájlokat visszamásolja, és a a távoli gépről le is törli.

Több dolog is szükséges ahhoz, hogy a fenti parancs működjön:

• Minden gépen fel kell installálnunk parallelt.
• Azt a programot is fel kell installálnunk, amit a parallel meghív ( példában: convert ),
• Jelszó nélkül be kell tudnunk lépni a másik gépre ssh-val.

A parancs futtatásához 2 perc 20 másodperc kell, ami persze lényegesen több a 48 másodpercnél ( a fájlok másolása, a parancsok ütemezése elvesz némi időt ), de sokkal gyorsabb a kiinduló 12 perc 17 másodpercnél.

Általában persze nagyon hasznos, hogy ha egy távoli gépre be akarunk lépni ssh-val, akkor jelszót kell megadnunk, de ha egy scriptet írunk, akkor nagyon kényelmetlen ha futás közben megáll a script és jelszót kérdez.

ssh-keygen és ssh-copy-id használatával jelszó nélkül is be tudunk lépni a távoli gépre. Először is RSA kulcsokat gyártunk ssh-keygennel a host gépen ( ahonnan be szeretnénk lépni ), majd átmásoljuk a publikus kulcsot a távoli gépre ( ahová be szeretnénk lépni ):

$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
The key fingerprint is:
b2:46:91:0d:83:de:7a:e7:1a:b5:3a:9d:11:0a:96:99 user@host.akarmi.hu
The key's randomart image is:
+--[ RSA 2048]----+
|   E= ..         |
|...o.=           |
|.o.=o.o          |
|  + *.           |
|   = +o S        |
|  o =.S o        |
| . +  o          |
| o .             |
|                 |
+-----------------+

$ ssh-copy-id -i ~/.ssh/id_rsa.pub tavoliuser@tavoligep.akarmi.hu
29
tavoliuser@tavoligep.akarmi.hu's password:
Now try logging into the machine, with "ssh 'tavoliuser@tavoligep.akarmi.hu'", and check in:

  .ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.



forrás: http://www.thegeekstuff.com/2008/11/3-steps-to-perform-ssh-login-without-password-using-ssh-keygen-ssh-copy-id/

A RandR-re épülő xbacklight segítségével parancssorból tudjuk a monitor fényerejét állítani, illetve a beállított fényerőt lekérdezni:

$ xbacklight -set 100
$ xbacklight -get
100.000000
$ xbacklight -set 80
$ xbacklight -get
79.166667


Az értékekek százalékot jelentenek.

Arra voltam kíváncsi, mennyi tinta van még a nyomtatóm tonerjében. Mivel HP nyomtatóm van, hplip csomag hp-levels programját használtam:

hp-levels


Sajnos a program nekem csak interaktív módon volt hajlandó működni, a nyomtatót a -p és -d kapcsolókkal nem sikerült meghatároznom, így mindig megkérdezte, hogy melyik nyomtatóra is vagyok kíváncsi. Mivel a 0-s sorszámúra, azért csak sikerült kikerülni az interaktív kérdést:

echo '0' | hp-levels

A program meglepő módon ahelyett, hogy kiírna egyetlen számot, ami a toner töltöttségét jelzi százalékben, a következő grafikusnak szánt módon jelzi a toner töltöttségét:

Black toner cartridge
Part No.: 35A
Health: Good/OK

---------------------------------------------------
|/////////////////////////////////////////////////| (approx. 100%)
---------------------------------------------------


Done.



Ezen a blogon értthető okokból nem fogom a kdenlive-ot bemutatni, mivel az egy grafikus felülettel használható videóeditáló program. Ugyanakkor kdenlive az MLT ( Media Lovin' Toolkit ) keretrendszerre épül, és szerencsére a projecteket leíró .kdenlive fájlformátum olyan módon bővíti az MLT által is használt MLT XML fájlformátumot, hogy használni tudjuk az MLT parancssoros melt programját.

Én a renderelést, vagyis a végső videófájl előállítását szoktam a parancssorra bízni:

melt input.kdenlive -consumer avformat:output.mp4 vcodec=libx264 threads=2 b=5000k acodec=aac ab=128k tune=film preset=slow s=1280x720 aspect=@16/9 progress=1

Az avi és mkv összefűzéshez hasonlóan most mp4 fájlokat kellett összeragasztanom (újrakódolás nélkül persze). Ehhez MP4Box parancsot használtam ( GPAC csomag része ):

MP4Box -cat input1.mp4 -cat input2.mp4 output.mp4

Kiegészítés:

Nemrég azt tapasztaltam, hogy szerencsésebb ezt a változatot használni:

MP4Box -force-cat -cat input1.mp4 -cat input2.mp4 -new output.mp4

Egy olyan scriptre volt szükségem, ami megadja, hogy az alkönyvtárban található videófájloknak mennyi az összesített hossza. Szerencsére találtam egy ilyen scriptet, így nem kellett nekem megírnom:

find -type f -name "*.mp4" -print0 | xargs -0  mplayer -vo dummy -ao dummy -identify 2>/dev/null | perl -nle '/ID_LENGTH=([0-9\.]+)/ && ($t +=$1) && printf "%02d:%02d:%02d\n",$t/3600,$t/60%60,$t%60' | tail -n 1

A működés rövid magyarázata:

• find segítségével megkeressük a minket érdeklő fájlokat ( Az eredeti példában .avi szerepelt, nekem .mp4-re volt szükségem )
• mplayer segítségével sok-sok infót iratunk ki ( innen látszik, hogy a script mindennel elboldogul, amit mplayer kezelni tud )
• Az mplayer által kiírt adatok közül az ID_LENGTH érdekes számunkra, ez másodpercben írja ki a hosszt.
• perl program(ocska) összeadja a másodperceket és óra:perc:másodperc formában kiírja
• A tail miatt csak a legutolsó sor, a végösszeg íródik ki.

Elég bosszantó, amikor egy scriptünk azért nem fut le teljesen, mert az egyik parancs a script közepén feltesz valami kérdést ( tényleg teljesen biztos vagy benne...? ) amire válaszolnunk kell. Mást is bosszantott ez, így elkészült a meglehetősen egyszerű yes program, ami semmi mást nem csinál, mint 'y' karaktereket ( sortöréssel ) ír ki, egészen addig ameddig le nem állítjuk:

yes


Ha a feltett kérdésre nem az 'y'  a helyes válasz, akkor persze más string kiírására is lehetőségünk van:

yes 'commandline.blog.hu'


(CTRL-C-vel tudjuk leállítani.)

A JRE install például ( általam nem teljesen értett okokból ) egy ENTER lenyomását várja az install végén, amit így tudunk scriptből megvalósítani:

yes '' | ./jdk-6u31-linux-i586.bin

A feh --info kapcsolóját bemutató bejegyzés után felmerülhet a kérdés, mennyire kényelmes egy ilyen hosszú parancsot mindig begépelni. Nyilván nem az. Az igazat megvallva többnyire CTRL-R segítségével használom fel újra az ilyen parancsokat. Persze ha már nagyon régen használtam utoljára, akkor ez nem segít.

Sokkal hasznosabb alias segítségével megadni, hogy feh mindig használja ezt a kapcsolót:

alias feh='feh --info "exiftool -focalLength -shutterSpeed -aperture -iso %F | cut -d : -f 2"'

Ezután elég a szokásos

feh -Fd *.jpg


és megjelennek az exif információk.

Egyszerűen kilistázhatjuk a beállított aliasokat:

alias


Végül törölhetünk is egy aliast:

unalias feh


A feh képnéző programnál lehetőségünk van a --info kapcsolóval tetszőleges feliratot elhelyezni a kép bal alsó sarkában. Legtöbb értelme talán alapvető exif információk kiírásának van:

feh -Fd --info "exiftool -focalLength -shutterSpeed -aperture -iso %F | cut -d : -f 2" *.jpg


A parancs hatására az expozíció legfontosabb jellemzői íródnak ki. Ha nem elég új a gépünkön installált feh, akkor %F helyett %f használatával érdemes próbálkozni.

Felmerült bennem az a kérdés is, miért nem támogatja feh direkt módon az exif információk kiírását, miért van szükség külső parancsra. A saját doksija alapján úgy tűnik, egy ideje van erre támogatás, de ők sem igazán javasolják ennek a funkciónak a használatát.

Ha egy nyaralás során több helyen is fényképezünk, akkor jellemzően fájlnév alapján egyszerűen meghatározhatunk egy intervallumot, amin belül ugyanazt a kulcsszót szeretnénk a képekhez adni. Az egyszerűség kedvéért tegyük fel, hogy 1000 képet készítettünk: imgp0000.jpg, ..., imgp0999.jpg, ezek közül imgp0053.jpg, ..., imgp0125.jpg képek a kies Helyszín település látványosságait örökítik meg. Ekkor a következő paranccsal adhatjuk hozzá a képekhez a megfelelő címkét seq -f segítségével.

exiftool -P -keywords+="Helyszín" $(seq -f 'imgp%04g.jpg' 53 125)

Amikor digitális fényképet készítünk, akkor a fájl dátuma a készítés időpontját jelzi. Ha editáljuk a fájlt, akkor egy idő után ez a dátum már nem feltétlenül a fényképezés dátumát, hanem az editálás dátumát jelzi. Nyilván mindkét időpont jelzésének van jogosultsága, de nekem legtöbbször a fényképezés dátuma fontosabb. Az exif infotmációk alapján exiftool segítségével újra szinkronba hozhatjuk a dátumokat:

exiftool '-DateTimeOriginal>FileModifyDate' test.jpg


Bár find + xargs segítségével rengeteg érdekes problémát meg tudunk oldani, túlzás lenne azt állítani, hogy a túl kényelmes a két parancs használata. A neve alapján GNU parallelről azt gondoltam, hogy csak a párhuzamos feldolgozásban ( lásd xargs -P ) fog segíteni, de némi használat után úgy látom hogy a párhuzamosságon kívül a használata is egyszerűbb.

Ha egy alkönyvtár png fájljait szeretném jpeg formátumra átkonvertálni és egyben átméretezni, akkor a find + xargs használatával a következőképpen tehetem ezt meg:

find . -name '*.png' | xargs -n1 -i basename {} .png | xargs -P 2 -n1 -i convert -resize 1200x1200 {}.png {}_web.jpg

Ha xargs helyett parallelt használok, akkor több kapcsolóra és a basename használatára sincsen szükség:

find . -name '*.png' | parallel convert -resize 1200x1200 {} {.}_web.jpg

Következő lépésben a find-ot is megszüntethetjük a ::: használatával:

parallel convert -resize 1200x1200 {} {.}_web.jpg ::: *.png

Ha egyszerre szeretnék két méretre is átméretezni, akkor erre is van lehetőségünk:

parallel convert -resize {2}x{2} {1} {1.}_{2}.jpg ::: *.png ::: 1200 300

 A parancs hatására alma.png fájlból alma_300.jpg, alma_1200.jpg fájlokat kapjuk.

Számtalan példát írhatnék még, de szerintem egyszerűbb a program írójának, Ole Tangénak a bemutatását megnézni:

Korábban már mutattam egy interaktív vi tutorialt, ami segít a vi ( pontosabban vim ) kezelésének megtanulásában. Úgy tűnik, még mindig nem terjed el eléggé a vim, ezért készítettek egy kalandjátékot, ami játékos formában tanítja meg a vim kezelését.

Nem vagyok teljesen meggyőződve arról, hogy a vim-adventures.com tényleg segít a vim tanulásában, de mindenképpen érdemes kipróbálni.

Bár tail -f nagyon hasznos ha egy folyamatosan bővülő fájlt vizsgálunk, az esetek többségében mégis kényelmesebb a less parancsot használni egy logfájl vizsgálatakor. Lehetőségünk van less parancsnál is a folyamatos figyelésre, ha +F kapcsolóval ( szokásos - helyett itt + van ) indítjuk:

less +F log.txt

A figyelést CTRL-C lenyomásával tudjuk beszüntetni, ekkor less a szokásos üzemmódba vált vissza.

Még kényelmesebb, hogy egy teljesen hagyományos less parancs esetén is

less log.txt

lehetőségünk van a tail -f üzemmódjába átváltani, ha az F ( shift + f ) billentyűt lenyomjuk.

A groff paranccsal egy man oldalt installálás nélkül is megtekinthetünk:

groff -man -Tascii pktriggercord-cli.1 | more

Ahhoz, hogy a számomra kényelmesebb less paranccsal is működjön, szükség lehet még pár kapcsolóra:

groff -man -Tascii -mwww pktriggercord-cli.1 -P -c | less

A módszer különösen hasznos, ha mi írjuk a man oldalt, és emiatt folyamatosan ellenőrizni kell a formátumot.

Leginkább focus stacking közben merül fel, hogy egy alkönyvtárban lévő kep-0000.jpg, kep-0001.jpg, ..., kep-0049.jpg sorozatból csak egy szűkebb intervallumot szeretnék parancssorban használni. A seq parancs -f kapcsolójával ezt könnyen elérhetjük, a következő parancs kep-0005.jpg, ..., kep-0024.jpg fájlokat listázza ki:

 ls -l $(seq -f 'kep-%04g.jpg' 5 24)

A $() a parancsbehelyettesítés miatt kell.

A photo.stackexchange oldalon tette fel valaki a kérdést, miként lehet egy fényképet úgy kinyomtatni, hogy gömbfelületre lehessen felragasztani a képet.

Az IP-Slicer perl script segítségével oldaható meg a feladat:

sphere-slicer.pl 12 1500 sampleimage.jpg

A fenti script 12 darabra vágja a képet úgy, hogy a az "egyenlítő" 1500 pixel hosszú lesz.

Az elkészült darabok:

Már írtam arról, miként tudunk rpm-et készíteni .src.rpm-ből, és arrról is, miként lehet egy programhoz patchet készíteni. Most a két dolgot kötöm össze, vagyis azt írom le, miként lehet egy .src.rpm-et úgy lefordítani, hogy használja a saját patchünket.

Előkészületként érdemes a két lépést külön kipróbálni, vagyis arról is győződjünk meg, hogy működik a patchünk, és arról is, hogy patch nélkül le tudjuk fordítani a forrás rpm-et!

Először is installáljuk a .src.rpm-et:

rpm -ivh ufraw-0.18-4.src.rpm

Ennek hatására rpmbuild alkönyvtárunkban létrejönnek a következő fájlok, de a rendszer nem végzi el a fordítást:

SOURCES/ufraw-0.18.tar.gz
SPECS/ufraw.spec

A program forráskódját tartalmazó .tar.gz mellé másoljuk át a patchünket:

SOURCES/ufraw_kx.patch

Ezen kívül módosítanunk kell a .spec fájlt:

%define name            ufraw
%define version         0.18
%define release         %mkrel 4
Patch0: ufraw_kx.patch
...
%prep
%setup -q
%patch0 -p1


A spec fájlnak csak a számunkra érdekes részét mutatom, a módosításokat kiemelve.

Ezután már lefordíthatjuk a .src.rpm-et:

rpmbuild -bb rpmbuild/SPECS/ufraw.spec


A már említett diff parancs segítségével egy programon elvégzett módosításainkból patcheket készíthetünk. A következő példa szándékosan leegyszerűsített, de egy valódi programhoz készített patchet mutat be.

A Pentax K-x gép által készített DNG fájl 4352x2868 pixel, de a kép jobb szélen több oszlopnyi fekete pixel található. Ha exiftool segítségével belenézünk a DNG fájlba, azt is látjuk, hogy default cropnak 4288x2848-as méret van beállítva a 10,10 koordinátájú pixeltől kezdve. A raw konverterek eléggé eltérően kezelik ezt a furcsaságot, a már korábban említett ufraw program egyszerűen levágja a kép jobb szélét és 4309x2868 méretű jpeg fájlokat gyárt. Ez elég furcsa méret, ehelyett én jobban szeretem, ha pont 3:2 arányú az oldal, ezért 4272x2848-as méretet szeretnék. Ehhez alul és felül 10-10 pixelt,  balra 18, jobbra 62 pixelt szeretnék levágni ( a jobb oldali 44 pixel fekete miatt nem szimmetrikus a vágás).

Ha belenézünk ufraw forrásába, akkor dcraw.cc fájlban találjuk a következő részt, ami meghatározza a vágás méretét:

  if (!strcmp(model,"K-r") || !strcmp(model,"K-x"))
    {                   width  = 4309; filters = 0x16161616; }


Ezt kell módosítani erre:

  if (!strcmp(model,"K-r") || !strcmp(model,"K-x"))
    { left_margin = 18; height = 2848; top_margin = 10; width  = 4272; filters = 0x16161616; }
 

Egy ilyen egyszerű esetben még csak-csak el lehet magyarázni, hogy mit kell átírni, de ha több fájlt módosítunk több helyen, akkor ez követhetetlen. Ehelyett érdemes egy alkönyvtárban ( a példában: ufraw-0.18) a program eredeti változatát, egy másik alkönyvtárban ( a példában: ufraw-0.18_modified) a program módosított változatát eltárolni, és patchet készíteni:

diff -uNr ufraw-0.18 ufraw-0.18_modified > ufraw_kx.patch

Figyeljünk arra oda, hogy a két alkönyvtár a módosításunkat leszámítva egyforma legyen! Ne felejtsünk ott például tesztfájlokat! A parancs hatására a következő fájlt kapjuk:

diff -uNr ufraw-0.18/dcraw.cc ufraw-0.18_modified/dcraw.cc
--- ufraw-0.18/dcraw.cc 2011-02-20 08:56:15.000000000 +0100
+++ ufraw-0.18_modified/dcraw.cc        2012-02-26 10:39:23.452480315 +0100
@@ -7104,7 +7104,7 @@
   if (height == 3136 && width == 4864)  /* Pentax K20D and Samsung GX20 */
     { height  = 3124;   width  = 4688; filters = 0x16161616; }
   if (!strcmp(model,"K-r") || !strcmp(model,"K-x"))
-    {                  width  = 4309; filters = 0x16161616; }
+    { left_margin = 18; height = 2848; top_margin = 10; width  = 4272; filters = 0x16161616; }
   if (!strcmp(model,"K-5"))
     { left_margin = 10; width  = 4950; filters = 0x16161616; }
   if (!strcmp(model,"K-7"))
Ez a fájl írja le a módosításainkat olyan formában, amit a patch parancs megért. Ha elküldjük a patchet valakinek akinél az eredeti ufraw-0.18 alkönyvtár van, a következő módon tudja frissíteni a programot:

$ patch -p0 < ufraw_kx.patch
patching file ufraw-0.18/dcraw.cc


A módszer akkor is hasznos ha saját magunknak akarjuk eltárolni a módosításokat, de különösen akkor hasznos, ha egy nyílt forráskódú program fejlesztésében akarunk segíteni.

Bevallom, hosszú évek alatt sosem gondolkodtam el azon, hogy mi az a sys rq gomb a billentyűzetemen, de egy érdekes commandlinefu bejegyzés hatására utánanéztem. A gomb segítségével alacsony szintű utasításokat adhatunk a Linux kernelnek, így egy lefagyott gépet éleszthetünk újra, vagy legalább fájdalommentesen újraindíthatunk.

A sok lehetőség közül először az m betűvel elérhető ( memóriainformációt /var/log/syslog ill. /var/log/messages fájlba író ) parancsot próbáltam ki. A leírásnak megfelelően sok lehetőséget kipróbálva az én gépemen a következő módon használható a módszer:

1. alt gr lenyomása
2. fn lenyomása
3. sys rq/delete lenyomása
4. fn felengedése
5. sys rq/delete felengedése
6. m lenyomása
7. m felengedése
8. alt gr felengedése

A memóriainformációkért persze nem éri meg ennyit szenvedni, a SysRq leginkább hasznos funkciója a biztonságos bootolás, amit a REISUB parancsokkal érhetünk el:

• r: billentyűzet vezérlés visszavétele X-től
• e: SIGTERM küldése az összes processnek
• i: SIGKILL küldése az összes processnek
• s: adatok kiírása a diszkekre
• u: read-only módban újramountolása a diszkeknek
• b: újraindítás

Az egyes betűk után érdemes pár másodpercet várni, hogy lefuthassanak a parancsok.

Mivel a gépen éppen rendesen működik, azt nem teszteltem ki, hogy tényleg újraindít-e egy lefagyott gépet. A rendesen működő gépet valóban jól újraindította.

Rendrakás közben belebotlottam pár ősrégi mod zenefájlba. Bár eleinte tartottam tőle, hogy nem tudom semmivel sem lejátszani, elég hamar rátaláltam a mikmodra:

mikmod -q teszt.mod

Bár már a mikmod fejlesztését is évekkel ezelőtt abbahagyták, nagyszerűen lejátszotta a fájlokat.