Linux pun mendukung pipa bernama, yang dikenal dengan FIFO karena prinsip kerjanya FIFO. Data yang pertama kali ditulis ke pipa adalah data pertama yang dibaca. Tidak seperti pipa, FIFO bukan merupakan objek yang bersifat sementara, ia adalah entity di sistem file dan bisa dibuat dengan perintah mkfifo. Proses-proses bebas menggunakan FIFO selama mereka punya hak akses ke sana. Cara FIFO dibuka sedikit berbeda dengan pipa. Sebuah pipa (dua struktur data filenya, inode VFSnya dan halaman data bersama) dibuat sekaligus sementara FIFO sudah ada dan dibuka dan ditutup oleh penggunanya. Linux harus menangani pembaca-pembaca yang membuka FIFO sebelum penulis-penulis

membukanya dan juga penulis-penulis yang membacanya sebelum penulis-penulis sudah menulisnya. Selain itu, FIFO ditangani dengan cara yang hampir sama dengan pipa dan FIFO menggunakan struktur data dan operasi yang sama

Semua shells Linux yang biasa, membolehkan redirection. Sebagai contoh

$ ls | pr | lpr

memipakan output dari perintah ls, yang melist file yang ada di dalam direktori, sampai standar input dari perintah pr yang mempaginasi file tersebut. Pada akhirnya standard output dari perintah pr dipipakan ke standar input dari perintah lpr yang mencetak hasil-hasilnya ke printer default. Pipa-pipa berikutnya adalah unidirectional byte streams yang menghubungkan standard output dari suatu proses ke standar input dari proses lainnya. Proses tidak peduli terhadap redirection ini dan berperilaku seolah-olah ia berjalan normal saja. Adalah shell yang membangun pipa-pipa yang bersifat sementara ini di antara dua proses tersebut.

Penerapan

Di Linux, suatu pipa diterapkan dengan menggunakan dua struktur data file yang keduanya menunjuk ke inode VFS sementara yang sama yang ia sendiri menunjuk pada halaman fisik di dalam memori.
Gambar di atas menunjukkan bahwa setiap struktur data file mengandung pointer ke vektor-vektor routine operasi file yang berbeda; satu untuk menulis ke pipa, satu lagi untuk membaca dari pipa.

Hal tersebut menyembunyikan perbedaan-perbedaan yang mendasar dari system calls umum yang membaca dan menulis file biasa. Saat proses menulis tersebut menulis ke pipa, byte-byte dikopi ke halaman data bersama dan ketika proses membaca membaca dari pipa, byte-byte dicopi dari halaman data bersama. Linux harus mensinkronisasikan akses ke pipa tersebut. Linux harus memastikan bahwa pembaca dan penulis pipa berada pada jalur dan untuk melakukannya Linux menggukan kunci, antrian wait dan sinyal.Bagaimana menulis data

Saat penulis ingin menulis ke pipa, ia menggunakan fungsi-fungsi pustaka penulisan yang standar. Semuanya ini melewatkan pendeskripsi file yang diindeks ke perangkat proses dari sturktur data file, masing-masing merepresentasikan file yang sedang terbuka atau pun, dalam kasus ini, pipa yang terbuka. routine penulis itu menggunakan informasi yang ada di dalam inode VFS yang merepresentasikan pipa untuk mengatur permintaan menulis.

Bila ada cukup ruangan untuk menulis semua bytes kedalam pipa dan, sepanjang pipa tidak dikunci oleh pembacanya, Linux menguncinya untuk si penulis dan mengkopikan bytes tersebut dari ruang alamat proses itu ke halaman data bersama. Bila pipa itu dikunci oleh pembaca atau bila tidak ada cukup ruang bagi data maka proses sekarang disuruh tidur di antrian tunggu inode pipa itu dan scheduller dipanggil sehingga proses lainnya dapat berjalan. Proses yang tidur ini interruptible, sehingga ia masih dapat menerima sinyal dan dapat dibangunkan oleh pembaca ketika ruangan telah cukup untuk ditulisi data atau pun ketika pipa sudah tidak dikunci. Setelah data ditulis, inode VFS dari pipa dibuka kuncinya dan semua pembaca yang menunggu di antrian tunggu inode akan dibangunkan oleh mereka sendiri.


Bagaimana membaca data

Membaca data dari pipa sangat mirip dengan menulis.Proses boleh membaca dengan tidak melakukan pemblokiran (tergantung pada mode di mana proses tersebut membuka file atau pipa) dan, dalam kasus ini, bila tidak ada data untuk dibaca atau bila pipa dikunci, pesan kesalahan akan dikembalikan. Artinya, proses tersebut dapat terus berjalan. Cara lainnya adalah dengan menunggu di antrian tunggu inode pipa sampai proses menulis sudah selesai. Saat kedua proses sudah selesai berurusan dengan pipa, inode pipa tersebut dibuang bersama halaman data bersama.

Untuk mengatur kegiatan proses mereka perlu saling berkomunikasi. Linux mendukung berbagai mekanisme komunikasi antar proses (KAP). Sinyal dan pemipaan merupakan dua di antaranya, tapi linux juga mendukung system sistem ke lima mekanisme KAP. Sinyal

Sinyal merupakan salah satu metode KAP tertua sistem Unix. Sinyal digunakan untuk memberitahukan kejadian yang asinkronus pada satu atau lebih proses. misalnya sinyal yang dihasilkan oleh keyboard saat ditekan oleh pemakai. Sinyal juga dapat dihasilkan oleh kondisi yang menyatakan error, misalnya saat suatu proses mencoba mengakses lokasi yang tidak pernah ada di dalam memori utama. Sinyal pun digunakan oleh shells untuk memberitahu perintah kontrol kerja kepada proses child.


Beberapa sinyal di Linux

Ada satu perangkat sinyal terdefinisi yang bisa digenerate oleh kernel atau oleh proses lain di dalam sistem, tentunya setelah proses tersebut punya hak untuk melakukannya. Anda dapat melihat daftar dari seperangkat sinyal sistem dengan menggunakan perintah kill (kill -l). Di dalam box Linux Intel, perintah kill tersebut menghasilkan keluaran sebagai berikut:

1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL

5) SIGTRAP 6) SIGIOT 7) SIGBUS 8) SIGFPE

9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2

13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD

18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN

22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ

26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO

30) SIGPWR

Jumlah sinyal tersebut berbeda untuk sebuah kotak Linux AXP Alpha.


Bagaimana suatu sinyal disikapi

Proses dapat memilih untuk mengabaikan kebanyakan sinyal yang digenerate dengan dua pengecualian: baik sinyal SIGSTOP, yang menyebabkan suatu proses menghentikan pekerjaannya, maupun sinyal SIGKILL, yang menyebabkan suatu proses berhenti, tidak dapat diabaikan. Selain itu, suatu proses dapat memilih bagaimana cara ia mengatasi bermacam-macam sinyal. Proses dapat menghalangi sinyal tersebut dan, bila tidak menghalanginya, proses itu dapat memilih antara mengatasinya sendiri atau membiarkan kernel mengatasinya. Bila kernel mengatasi sinyal tersebut maka sejumlah tindakan default akan dilakukan untuk mengatasi sinyal ini. Misalnya, tindakan default saat sebuah proses menerima sinyal SIGPE (exception floating point) adalah dengan core dump kemudian keluar. Sinyal tidak punya prioritas-prioritas yang terkait. Bila dua sinyal dihasilkan untuk suatu proses pada waktu yang sama, maka keduanya dapat diberikan ke proses tersebut atau ditangani dengan urutan tertentu. Selain itu, tidak ada mekanisme untuk mengatasi sinyal yang sama dan banyak sekaligus. Tidak ada cara bahwa suatu proses dapat memberitahukan apakah ia menerima 1 atau 42 sinyal SIGCONT.


Penerapan sinyal

Linux menerapkan sinyal dengan menggunakan informasi yang disimpan dalam task_struct untuk proses tersebut. Jumlah sinyal yang didukung terbatas pada ukuran word prosesornya. Proses dengan ukuran word 32 bit dapat memiliki 32 sinyal sementara prosesor 64 bit seperti Alpha AXP dapat memiliki sampai 64 sinyal. Sinyal-sinyal yang tertunda saat ini disimpan dalam field sinyal dengan sebuah mask dari sinyal-sinyal terblokir yang disimpan di blocked. Dengan pengecualian SIGTOP dan SIGKILL, semua sinyal dapat diblokir. Bila sinyal yang diblokir digenerate, maka sinyal itu akan tetap tertahan sampai ia tidak diblokir lagi.

Linux juga menyimpan informasi tentang bagaimana setiap proses menangani sinyal-sinyal yang mungkin terjadi. Informasi ini disimpan dalam suatu array stuktur data sigaction yang ditunjuk oleh task_struct untuk setiap proses. Di antara hal-hal yang lain, informasi ini mengandung baik alamat routin yang nantinya menangani sinyal atau flag, yang memberitahu Linux bahwa proses tersebut ingin mengabaikan sinyal ini atau membiarkan kernel menanganinya. Proses tersebut memodifikasi penanganan default sinyal dengan membuat system call ,dan call ini mengubah sigaction untuk sinyal yang sesuai dan juga mask daripada blocked.

Tidak semua proses di dalam sistem dapat mengirimkan sinyal ke proses lainnya. Kernel dapat melakukannya demikian pula super users. Proses-proses biasa hanya dapat mengirim sinyal pada proses-proses yang memiliki uid dan gid yang sama atau pun pada kelompok proses yang sama. Sinyal digenerate dengan mengatur bit yang sesuai di dalam field signal task_struct. Jika proses tersebut belum memblokir sinyal dan sedang menunggu (namun dapat diinterrupt di status Interruptible), maka ia akan dibangunkan dengan mengubah statusnya ke Running dan memastikan bahwa proses ini berada pada antrian run. Dengan cara itu scheduler akan menganggapnya sebagai suatu yang akan running pada jadwal sistem berikutnya. Jika penanganan default diperlukan, maka Linux dapat mengoptimalkan penganganan sinyal tersebut. Sebagai contoh, jika sinyal SIGWINCH (fokus yang berubah dari jendela X) dan penangan default sedang digunakan, maka tidak ada yang perlu dilakukan.

Sinyal-sinyal tidak diberikan ke proses segera saat mereka digenerate. Sinyal-sinyal ini harus menunggu sampai proses tersebut berjalan kembali. Setiap kali sebuah proses keluar dari suatu system calls, field signals dan blocked dicek dan bila ada sinyal-sinyal apapun yang tidak terblokir, sekarang sinyal-sinyal ini dapat disampaikan. Kelihatannya cara ini bukanlah cara yang dapat diandalkan, namun setiap proses di dalam sistem pasti membuat system calls, sebagai contoh, untuk menulis suatu karakter ke terminal sepanjang waktu. Proses dapat memilih untuk menunggu sinyal bila ia mau, kemudian dapat disuspend di status Interruptible sampai sinyal itu datang. Kode pemrosesan sinyal Linux melihat pada struktur sigaction untuk setiap sinyal yang saat ini belum diblokir.

Jika sebuah penangan sinyal diset ke tindakan default, maka kernel akan mengatasinya. Penangan default sinyal SIGSTOP akan mengubah status proses saat ini ke status Stopped dan selanjutnya menjalankan scheduler untuk memilih sebuah proses baru untuk berjalan. Tindakan default untuk sinyal SIGFPE akan core dump proses dan menyebabkannya keluar. Cara lainnya, proses tersebut dapat menentukan handler sinyalnya sendiri. Penangan ini merupakan suatu routine yang akan dipanggil kapan pun sinyal digenerate dan struktur sigactionnya menyimpan alamat routine ini. Kernel tersebut harus memanggil routine penangan sinyal proses tersebut dan bagaimana ini terjadi adalah kekhususan masing-masing prosesor tetapi intinya semua CPU harus berhasil mengatasi kenyataan bahwa proses saat ini sedang berjalan di mode kernel dan mengembalikan proses yang tadi memanggil kernel atau system routine di mode user. Masalah ini terpecahkan dengan memanipulasi stack dan register daripada proses tersebut. Program counter dari proses diset ke alamat sinyalnya, yang menangani routine, dan parameter-parameter ke routine dimasukkan ke frame callnya atau dilewatkan di register. Ketika proses tersebut menerima operasi, proses ini terlihat seolah-olah routine penangan sinyalnya dipanggil secara normal.

Linux bersifat POSIX compatible dan oleh karena itu prosesnya dapat menentukan sinyal-sinyal mana yang diblokir saat routine tertentu penangan sinyal dipanggil. Hal ini berarti mengubah mask blocked tersebut selama pemanggilan penangan sinyal proses-proses tersebut. mask blocked harus dikembalikan ke nilai aslinya ketika routine penangan routine tersebut telah selesai. Oleh karena itu Linux menambahkan suatu call pada sebuah routine perapih yang akan mengembalikan mask asli daripada blocked ke dalam stack call dari proses yang disinyal. Linux juga mengoptimalkan kasus di mana beberapa routine penangan sinyal perlu dipanggil dengan stacking routine-routine ini sehingga setiap saat sebuah routine penangan ada, routine penangan berikutnya dipanggil sampai routine perapih dipanggil.

Shareable dan Unshareable


1.

Shareable

Isinya dapat dishare (digunakan bersama) dengan sistem lain,
gunanya untuk menghemat tempat.
2.

Unshareable

Isinya tidak dapat dishare(digunakan bersama) dengan sistem lain,
biasanya untuk alasan keamanan.


Variabel dan Static

1.

Variabel

Isinya sering berubah-ubah.
2.

Static

Sekali dibuat, kecil kemungkinan isinya akan berubah. Bisa berubah
jika ada campur tangan sistem admin.

Load dan Eksekusi Program

1.

Penempatan program dalam memori

Linux membuat tabel-tabel fungsi untuk loading program, memberikan kesempatan kepada setiap fungsi untuk meload file yang diberikan saat sistem call exec dijalankan. Pertama-tama file binari dari page ditempatkan pada memori virtual. Hanya pada saat program mencoba mengakses page yang telah diberikan terjadi page fault, maka page akan diload ke memori fisik.
2.

Linking statis dan linking dinamis

1.

Linking statis:

librari-librari yang digunakan oleh program ditaruh secara
langsung dalam file binari yang dapat dieksekusi. Kerugian dari linking
statis adalah setiap program harus mengandung kopi library sistem yang umum.
2.

Linking dinamis:

hanya sekali meload librari sistem menuju memori. Linking dinamis
lebih efisien dalam hal memori fisik dan ruang disk.

Pengaksesan memori virtual bersama

Memori virtual mempermudah proses untuk berbagi memori saat semua akses ke memori menggunakan tabel page. Proses yang akan berbagi memori virtual yang sama, page fisik yang sama direference oleh banyak proses. Tabel page untuk setiap proses mengandung anggota page table yang mempunyai PFN fisik yang sama.

Efisiensi

Desainer dari CPU dan sistem operasi berusaha meningkatkan kinerja dari sistem. Disamping membuat prosesor, memori semakin cepat, jalan terbaik adalah manggunakan cache. Berikut ini adalah beberapa cache dalam manajemen memori di linux:

1.

Page Cache

Digunakan untuk meningkatkan akses ke image dan data dalam disk. Saat dibaca dari disk, page dicache di page cache. Jika page ini tidak dibutuhkan lagi pada suatu saat, tetapi dibutuhkan lagi pada saat yang lain, page ini dapat segera diambil dari page cache.

2.

Buffer Cache

Page mungkin mengandung buffer data yang sedang digunakan oleh kernel, device driver dan lain-lain. Buffer cache tampak seperti daftar buffer. Contohnya, device driver membutuhkan buffer 256 bytes, adalah lebih cepat untuk mengambil buffer dari buffer cache daripada mengalokasikan page fisik lalu kemudian memecahnya menjadi 256 bytes buffer-buffer.

3.

Swap Cache

Hanya page yang telah ditulis ditempatkan dalam swap file. Selama page ini tidak mengalami perubahan setelah ditulis ke dalam swap file, maka saat berikutnya page di swap out tidak perlu menuliskan kembali jika page telah ada di swap file. Di sistem yang sering mengalami swap, ini dapat menghemat akses disk yang tidak perlu.

Salah satu implementasi yang umum dari hardware cache adalah di CPU, cache dari anggota tabel page. Dalam hal ini, CPU tidak secara langsung membaca tabel page, tetap mencache terjemahan page yang dibutuhkan.

Swaping

Jika memori fisik tiba-tiba habis dan proses ingin memindahkan sebuah page ke memori, sistem operasi harus memutuskan apa yang harus dilakukan. Sistem operasi harus adil dalam mambagi page fisik dalam sistem diantara proses yang ada, bisa juga sistem operasi menghapus satu atau lebih page dari memori untuk membuat ruang untuk page baru yang dibawa ke memori. Cara page virtual dipilih dari memori fisik berpengaruh pada efisiensi sistem.

Linux menggunakan tehnik page aging agar adil dalam memilih page yang akan dihapus dari sistem. Ini berarti setiap page memiliki usia sesuai dengan berapa sering page itu diakses. Semakin sering sebuah page diakses, semakin muda page tersebut. Page yang tua adalah kandidat untuk diswap.

Demand Paging

Cara untuk menghemat memori fisik adalah dengan hanya meload page virtual yang sedang digunakan oleh program yang sedang dieksekusi. Tehnik dimana hanya meload page virtual ke memori hanya ketika program dijalankan disebut demand paging.

Ketika proses mencoba mengakses alamat virtual yang tidak ada di dalam memori, CPU tidak dapat menemukan anggota tabel page. Contohnya, dalam gambar, tidak ada anggota tabel page untuk proses x untuk virtual PFN 2 dan jika proses x ingin membaca alamat dari virtual PFN 2, CPU tidak dapat menterjemahkan alamat ke alamat fisik. Saat ini CPU bergantung pada sistem operasi untuk menangani masalah ini. CPU menginformasikan kepada sistem operasi bahwa page fault telah terjadi, dan sistem operasi membuat proses menunggu selama sistem operasi menagani masalah ini.

CPU harus membawa page yang benar ke memori dari image di disk. Akses disk membutuhkan waktu yang sangat lama dan proses harus menunggu sampai page selesai diambil. Jika ada proses lain yang dapat dijalankan, maka sistem operai akan memilihnya untuk kemudian dijalankan. page yang diambil kemudian dituliskan di dalam page fisik yang masih kosong dan anggota dari virtual PFN ditambahkan dalam tabel page proses. Proses kemudian dimulai lagi pada tempat dimana page fault terjadi. Saat ini terjadi pengaksesan memori virtual, CPU membuat penerjemahan dan kemudian proses dijalankan kembali.

Demand paging terjadi saat sistem sedang sibuk atau saat image pertama kali diload ke memori. Mekanisme ini berarti sebuah proses dapat mengeksekusi image dimana hanya sebagian dari image tersebut terdapat dalam memori fisik.

Manajemen Memori Fisik

Bagian ini menjelaskan bagaimana linux menangani memori
dalam sistem. Memori manajemen merupakan salah satu
bagian terpenting dalam sistem operasi. Karena adanya
keterbatasan memori, diperlukan suatu strategi dalam
menangani masalah ini. Jalan keluarnya adalah dengan
menggunakan memori virtual. Dengan memori virtual,
memori tampak lebih besar daripada ukuran yang sebenarnya.

Dengan memori virtual kita dapat:

1.

Ruang alamat yang besar

Sistem operasi membuat memori terlihat lebih besar
daripada ukuran memori sebenarnya. Memori virtual
bisa beberapa kali lebih besar daripada memori fisiknya.
2.

Pembagian memori fisik yang dil

Manajemen memori membuat pembagian yang adil dalam
pengalokasian memori antara proses-proses.
3.

Perlindungan

Memori manajemen menjamin setiap proses dalam sistem
terlindung dari proses-proses lainnya. Dengan demikian,
program yang crash tidak akan mempengaruhi proses lain
dalam sistem tersebut.
4.

Penggunaan memori virtual bersama

Memori virtual mengijinkan dua buah proses berbagi memori
diantara keduanya, contohnya dalam shared library.
Kode library dapat berada di satu tempat, dan tidak
dikopi pada dua program yang berbeda.

Kernel Linux 2.0 adalah kernel Linux pertama yang stabil untuk mendukung perangkat keras symmetric multiprocessor (SMP). Proses maupun thread yang berbeda dapat dieksekusi secara paralel dengan processor yang berbeda. Tapi bagaimana pun juga untuk menjaga kelangsungan kebutuhan sinkronisasi yang tidak dapat dipreemptive dari kernel, penerapan SMP ini menerapkan aturan dimana hanya satu processor yang dapat dieksekusi dengan kode mode kernel pada suatu saat. SMP menggunakan kernel spinlock tunggal untuk menjalankan aturan ini. Spinlock ini tidak memunculkan permasalahan untuk pekerjaan yang banyak menghabiskan waktu untuk menunggu proses komputasi, tapi untuk pekerjaan yang melibatkan banyak aktifitas kernel, spinlock dapat menjadi sangat mengkhawatirkan.

Sebuah proyek yang besar dalam pengembangan kernel Linux 2.1 adalah untuk menciptakan penerapan SMP yang lebih masuk akal, dengan membagi kernel spinlock tunggal menjadi banyak kunci yang masing - masing melindungi terhadap masuknya kembali sebagian kecil data struktur kernel. Dengan menggunakan teknik ini, pengembangan kernel yang terbaru mengijinkan banyak processor untuk dieksekusi oleh kode mode kernel secara bersamaan.

Sinkronisasi Kernel

Cara penjadwalan kernel pada operasinya secara mendasar berbeda dengan cara penjadwalan suatu proses. Terdapat dua cara agar sebuah permintaan akan eksekusi kernel-mode dapat terjadi. Sebuah program yang berjalan dapat meminta service sistem operasi, dari system call ataupun secara implisit (untuk contoh:ketika page fault terjadi). Sebagai alternatif, device driver dapat mengirim interupsi perangkat keras yang menyebabkan CPU memulai eksekusi kernel-define handler untuk suatu interupsi.

Problem untuk kernel muncul karena berbagai tasks mungkin mencoba untuk mengakses struktur data internal yang sama. Jika hanya satu kernel task ditengah pengaksesan struktur data ketika interupsi service routine dieksekusi, maka service routine tidak dapat mengakses atau merubah data yang sama tanpa resiko mendapatkan data yang rusak. Fakta ini berkaitan dengan ide dari critical section (baca sinkronisasi proses).

Sehagai hasilnya, sinkronisasi kernel melibatkan lebih banyak dari hanya penjadwalan proses saja. sebuah framework dibutuhkan untuk memperbolehkan kernel's critical sections berjalan tanpa diinterupsi oleh critical section yang lain.

Solusi pertama yang diberikan oleh linux adalah membuat normal kernel code nonpreemptible (baca proses). Biasanya, ketika sebuah timer interrupt diterima oleh kernel, membuat penjadwalan proses, kemungkinan besar akan menunda eksekusi proses yang sedang berjalan pada saat itu dan melanjutkan menjalankan proses yang lain. Biar bagaimanapun, ketika timer interrupt diterima ketika sebuah proses mengeksekusi kernel-system service routine, penjadwalan ulang tidak dilakukan secara mendadak; cukup, kernel need_resched flag terset untuk memberitahu kernel untuk menjalankan penjadwalan kembali setelah system call selesai dan control dikembalikan ke user mode.

Sepotong kernel code mulai dijalankan, akan terjamin bahwa itu adalah satu-satunya kernel code yang dijalankan sampai salah satu dari aksi dibawah ini muncul:

*

interupsi
*

page fault
*

kernel code memanggil fungsi penjadwalan sendiri

Interupsi adalah suatu masalah bila mengandung critical section-nya sendiri. Timer interrupt tidak secara langsung menyebabkan terjadinya penjadwalan ulang suatu proses; hanya meminta suatu jadwal untuk dilakukan kemudian, jadi kedatangan suatu interupsi tidak mempengaruhi urutan eksekusi dari noninterrupt kernel code . Sekali interrupt service selesai, eksekusi akan menjadi lebih simpel untuk kembali ke kernel code yang sedang dijalankan ketika interupsi mengambil alih.

Page faults adalah suatu masalah yang potensial; jika sebuah kernel routine mencoba untuk membaca atau menulis ke user memory, akan menyebabkan terjadinyapage fault yang membutuhkan I/O disk untuk selesai, dan proses yang berjalan akan di tunda sampai I/O selesai. Pada kasus yang
hampir sama, jika system call service routine memanggil penjadwalan ketika sedang berada di mode kernel, mungkin secara eksplisit dengan membuat direct call pada code penjadwalan atau secara implisit dengan memanggil sebuah fungsi untuk menunggu I/O selesai, setelah itu proses akan menunggu dan penjadwalan ulang akan muncul. Ketika proses jalan kembali, proses tersebut akan melanjutkan untuk mengeksekusi dengan mode kernel, melanjutkan intruksi setelah call (pemanggilan) ke penjadwalan.

Kernel code dapat terus berasumsi bahwa ia tidak akan diganggu (preemted) oleh proses lainnya dan tidak ada tindakan khusus dilakukan untuk melindungi critical section. Yang diperlukan adalah critical section tidak mengandung referensi ke user memory atau menunggu I/O selesai.

Teknik kedua yang di pakai Linux untuk critical section yang muncul pada saat interrupt service routines . Alat dasarnya adalah perangkat keras interrupt-control pada processor. Dengan meniadakan interupsi pada saat critical section, maka kernel menjamin bahwa ia dapat melakukan proses tanpa resiko terjadinya ketidak-cocokan akses dari struktur data yang di share.

Untuk meniadakan interupsi terdapat sebuah pinalti. Pada arsitektur perangkat keras kebanyakan, pengadaan dan peniadaan suatu interupsi adalah sesuatu yang mahal. Pada prakteknya, saat interupsi ditiadakan, semua I/O ditunda, dan device yang menunggu untuk dilayani akan menunggu sampai interupsi diadakan kembali, sehingga kinerja meningkat. Kernel Linux menggunakan synchronization architecture yang mengijinkan critical section yang panjang dijalankan untuk seluruh durasinya tanpa mendapatkan peniadaan interupsi. Kemampuan secara spesial berguna pada networking code : Sebuah interupsi pada network device driver dapat memberikan sinyal kedatangan dari keseluruhan paket network, dimana akan menghasilkan code yang baik dieksekusi untuk disassemble, route, dan forward paket ditengah interrupt service routine.

Linux mengimplementasikan arsitektur ini dengan memisahkan interrupt service routine menjadi dua seksi: the top half dan the bottom half. The top half adalah interupsi yang normal, dan berjalan dengan rekursif interupt ditiadakan ( interupsi dengan prioritas yang lebih tinggi dapat menginterupsi routine, tetapi interupsi dengan prioritas yang sama atau lebih
rendah ditiadakan). The bottom half service routine berjalan dengan semua interupsi diadakan, oleh miniatur penjadwalan yang menjamin bahwa bottom halves tidak akan menginterupsi dirinya sendiri. The bottom half scheduler dilakukan secara otomatis pada saat interupt service routine ada.

Pemisahan itu berarti bahwa kegiatan proses yang komplek dan harus selesai diberi tanggapan untuk suatu interupsi dapat diselesaikan oleh kernel tanpa kecemasan tentang diinterupsi oleh interupsi itu sendiri. Jika interupsi lain muncul ketika bottom half dieksekusi, maka interupsi dapat meminta kepada bottom half yang sama untuk dieksekusi, tetapi eksekusinya akan dilakukan setelah proses yang sedang berjalan selesai. Setiap eksekusi dari bottom half dapat di interupsi oleh top half tetapi tidak dapat diinterupsi dengan bottom half yang mirip.

Arsitektur Top-half bottom-half komplit dengan mekanisme untuk meniadakan bottom halver yang dipilih ketika dieksekusi secara normal, foreground kernel code. Kernel dapat meng-codekan critical section secara mudah dengan mengunakan sistem ini: penanganan interupsi dapat meng-codekan critical section-nya sebagai bottom halves, dan ketika foreground kernel ingin masuk ke critical section, setiap bottom halves ditiadakan untuk mencegah critical section yang lain diinterupsi. Pada akhir dari critical section, kernel dapat kembali mengadakan bottom halves dan menjalankan bottom half tasks yang telah di masukkan kedalam queue oleh top half interrupt service routine pada saat critical section .

Penjadwalan Proses Linux

Ketika kernel telah mencapai titik penjadwalan ulang, entah karena terjadi interupsi penjadwalan ulang maupun karena proses kernel yang sedang berjalan telah diblokir untuk menunggu beberapa signal bangun, harus memutuskanproses selanjutnya yang akan dijalankan. Linux telah memiliki dua algoritma penjadwalan proses yang terpisah satu sama lain. Algoritma yang pertama adalah algoritma time-sharing untuk penjadwalan preemptive yang adil diantara sekian banyak proses. Sedangkan algoritma yang kedua didesain untuk tugas real-time dimana proritas mutlak lebih utama daripada keadilan mendapatkan suatu pelayanan.

Bagian dari tiap identitas proses adalah kelas penjadwalan, yang akan menentukan algoritma yang digunakan untuk tiap proses. Kelas penjadwalan yang digunakan oleh Linux, terdapat dalam standar perluasan POSIX untuk sistem komputer waktu nyata.

Untuk proses time-sharing, Linux menggunakan teknik prioritas, sebuah algoritma yang berdasarkan pada kupon. Tiap proses memiliki sejumlah kupon penjadwalan; dimana ketika ada kesempatan untuk menjalankan sebuah tugas, maka proses dengan kupon terbanyaklah yang mendapat giliran. Setiap kali terjadi interupsi waktu, proses yang sedang berjalan akan kehilangan satu kupon; dan ketika kupon yang dimiliki sudah habis maka proses itu akan ditunda dan proses yang lain akan diberikan kesempatan untuk masuk.

Jika proses yang sedang berjalan tidak meiliki kupon sama sekali, linux akan melakukan operasi pemberian kupon, memberikan kupon kepada tiap proses dalam sistem, dengan aturan main: kupon = kupon / 2 + prioritas Algoritma ini cenderung untuk menggabungkan dua faktor yang ada: sejarah proses dan prioritas dari proses itu sendiri. Satu setengah dari kupon yang dimiliki sejak operasi pembagian kupon terakhir akan tetap dijaga setelah algoritma
telah dijalankan, menjaga beberapa sejarah sikap proses. Proses yang berjalan sepanjang waktu akan cenderung untukmenghabiskan kupon yang dimilikinya dengan cepat, tapi proses yang lebih banyak menunggu dapat mengakumulasi kuponnya dari. Sistem pembagian kupon ini, akan secara otomatis memberikan proritas yang tinggi ke proses I/O bound ataupun interaktif, dimana respon yang cepat sangat diperlukan.

Kegunaan dari proses pemberian prioritas dalam menghitung kupon baru, membuat prioritas dari suatu proses dapat ditingkatkan. Pekerjaan background batch dapat diberikan prioritas yang rendah; proses tersebut akan secara otomatis menerima kupon yang lebih sedikit dibandingkan dengan pekerjaan yang interaktif, dan juga akan menerima persentase waktu CPU yang lebih sedikit dibandingan dengan tugas yang sama dengan prioritas yang lebih tinggi. Linux menggunakan sistem prioritas ini untuk menerapkan mekanisme standar pembagian prioritas proses yang lebih baik.

Penjadwalan waktu nyata Linux masih tetap lebih sederhana. Linux, menerapkan dua kelas penjadwalan waktu nyata yang dibutuhkan oleh POSIX 1.b: First In First Out dan round-robin. Pada keduanya, tiap proses memiliki prioritas sebagai tambahan kelas penjadwalannya. Dalam penjadwalan time-sharing , bagaimanapun juga proses dengan prioritas yang berbeda dapat bersaing dengan beberapa pelebaran; dalam penjadwalan waktu nyata, si pembuat jadwal selalu menjalankan proses dengan prioritas yang tinggi. Diantara proses dengan prioritas yang sama, maka proses yang sudah menunggu lama, akan dijalankan. Perbedaan satu - satunya antara penjadwalan FIFO dan round-robin adalah proses FIFO akan melanjutkan prosesnya sampai keluar ataupun diblokir, sedangkan proses round-robin akan dipreemptivekan setelah beberapa saat dan akan dipindahkan ke akhir antrian, jadi proses round-robin dengan prioritas yang sama akan secara otomatis membagi waktu jalan antar mereka sendiri.

Perlu diingat bahwa penjadwalan waktu nyata di Linux memiliki sifat yang lunak. Pembuat jadwal Linux menawarkan jaminan yang tegas mengenai prioritas relatif dari proses waktu nyata, tapi kernel tidak menjamin seberapa cepat penjadwalan proses waktu-nyata akan dijalankan pada saat proses siap dijalankan. Ingat bahwa kode kernel Linux tidak akan pernah bisa dipreemptive oleh kode mode pengguna. Apabila terjadi interupsi yang membangunkan proses waktu nyata, sementara kernel siap untuk mengeksekusi sebuah sistem call sebagai bagian proses lain, proses waktu nyata harus menunggu sampai sistem call yang sedang dijalankan selesai atau diblokir.

Penjadwalan

Penjadwalan adalah suatu pekerjaan yang dilakukan untuk mengalokasikan CPU time untuk tasks yang berbeda-beda dalam sistem operasi. Pada umumnya, kita berfikir penjadwalan sebagai menjalankan dan menginterupsi suatu proses, untuk linux ada aspek lain yang penting dalam penjadwalan: seperti menjalankan dengan berbagai kernel tasks . Kernel tasks meliputi task yang diminta oleh proses yang sedang dijalankan dan tasks yand dieksekusi internal menyangkut device driver yang berkepentingan.

Memori Virtual di Linux..??


Memori fisik dan memori virtual dibagi menjadi bagian-bagian yang disebut page. Page ini memiliki ukuran yang sama besar. Tiap page ini punya nomor yang unik, yaitu Page Frame Number (PFN). Untuk setiap instruksi dalam program, CPU melakukan mapping dari alamat virtual ke memori fisik yang sebenarnya.

Penerjemahan alamat di antara virtual dan memori fisik dilakukan oleh CPU menggunakan tabel page untuk proses x dan proses y. Ini menunjukkan virtial PFN 0 dari proses x dimap ke memori fisik PFN 1. Setiap anggota tabel page mengandung informasi berikut ini:

1. Virtual PFN
2. PFN fisik
3. informasi akses page dari page tersebut


Untuk menerjemahkan alamat virtual ke alamat fisik, pertama-tama CPU harus menangani alamat virtual PFN dan offsetnya di virtual page. CPU mencari tabel page proses dan mancari anggota yang sesuai degan virtual PFN. Ini memberikan PFN fisik yang dicari. CPU kemudian mengambil PFN fisik dan mengalikannya dengan besar page untuk mendapat alamat basis page tersebut di dalam memori fisik. Terakhir, CPU menambahkan offset ke instruksi atau data yang dibutuhkan. Dengan cara ini, memori virtual dapat dimap ke page fisik dengan urutan yang teracak.

Resolusi Konflik

Keanekaragaman konfigurasi perangkat keras komputer serta driver yang mungkin terdapat pada sebuah komputer pribadi telah menjadi suatu masalah tersendiri. Masalah pengaturan konfigurasi perangkat keras tersebut menjadi semakin kompleks akibat dukungan terhadap device driver yang modular, karena device yang aktif pada suatu saat bervariasi.

Linux menyediakan sebuah mekanisme penyelesaian masalah untuk membantu arbitrasi akses terhadap perangkat keras tertentu. Tujuan mekanisme tersebut adalah untuk mencegah modul berebut akses terhadap suatu perangkat keras, mencegah autoprobes mengusik keberadaan driver yang telah ada, menyelesaikan konflik di antara sejumlah driver yang berusaha mengakses perangkat keras yang sama.

Kernel membuat daftar alokasi sumber daya perangkat keras. Ketika suatu driver hendak mengakses sumber daya melalui Input-Output port, jalur interrupt, ataupun kanal DMA, maka driver tersebut diharapkan mereservasi sumber daya tersebut pada basis data kernel terlebih dahulu. Jika reservasinya ditolak akibat ketidaktersediaan sumber daya yang diminta, maka modul harus memutuskan apa yang hendak dilakukan selanjutnya. Jika tidak dapat melanjutkan, maka modul tersebut dapat dihapus.

Apakah Modul Kernel Linux itu?

Modul kernel Linux adalah bagian dari kernel Linux yang dapat dikompilasi, dipanggil dan dihapus secara
terpisah dari bagian kernel lainnya saat dibutuhkan. Modul kernel dapat menambah fungsionalitas kernel tanpa perlu me-reboot sistem. Secara teori tidak ada yang dapat membatasi apa yang dapat dilakukanoleh modul kernel. Kernel modul dapat mengimplementasikan antara lain device driver, sistem berkas, protokol jaringan.

Modul kernel Linux memudahkan pihak lain untuk meningkatkan fungsionalitas kernel tanpa harus membuat sebuah kernel monolitik dan menambahkan fungsi yang mereka butuhkan langsung ke dalam image dari kernel. Selain hal tersebut akan membuat ukuran kernel menjadi lebih besar, kekurangan lainnya adalah mereka harus membangun dan me-reboot kernel setiap saat hendak menambah fungsi baru. Dengan adanya modul maka setiap pihak dapat dengan mudah menulis fungsi-fungsi baru dan bahkan mendistribusikannya sendiri, di luar GPL.

Kernel modul juga memberikan keuntungan lain yaitu membuat sistem Linux dapat dinyalakan dengan kernel standar yang minimal, tanpa tambahan device driver yang ikut dipanggil. Device driver yang dibutuhkan dapat dipanggil kemudian secara eksplisit maupun secara otomatis saat dibutuhkan.

Terdapat tiga komponen untuk menunjang modul kernel Linux. Ketiga komponen tersebut adalah manajemen modul, registrasi driver, dan mekanisme penyelesaian konflik. Berikut akan dibahas ketiga komponen pendukung tersebut.

Untuk membuat modul kernel yang baru dipanggil berfungsi, bagian dari kernel yang lain harus mengetahui keberadaan dan fungsi baru tersebut. Kernel membuat tabel dinamis yang berisi semua driver yang telah diketahuinya dan menyediakan serangkaian routines untuk menambah dan menghapus driver dari tabel tersebut. Routines ini yang bertanggungjawab untuk mendaftarkan fungsi modul baru tersebut.

Hal-hal yang masuk dalam tabel registrasi adalah:

* device driver
* sistem berkas
* protokol jaringan
* format binari

Manajemen modul akan mengatur pemanggilan modul ke dalam memori dan berkomunikasi dengan bagian
lainnya dari kernel. Memanggil sebuah modul tidak hanya memasukkan isi binarinya ke dalam memori kernel, namun juga harus dipastikan bahwa setiap rujukan yang dibuat oleh modul ke simbol kernel ataupun titik masukan diperbaharui untuk menunjuk ke lokasi yang benar di alamat kernel. Linux membuat tabel simbol internal di kernel. Tabel ini tidak memuat semua simbol yang didefinisikan di kernel saat kompilasi, namun simbol-simbol tersebut harus diekspor secara eksplisit oleh kernel. Semua hal ini diperlukan untuk penanganan rujukan yang dilakukan oleh modul terhadap simbol-simbol.

Pemanggilan modul dilakukan dalam dua tahap. Pertama, utilitas pemanggil modul akan meminta kernel untuk mereservasi tempat di memori virtual kernel untuk modul tersebut. Kernel akan memberikan alamat memori yang dialokasikan dan utilitas tersebut dapat menggunakannya untuk memasukkan kode mesin dari modul tersebut ke alamat pemanggilan yang tepat. Berikutnya system calls akan membawa modul, berikut setiap tabel simbol yang hendak, ke kernel. Dengan demikian modul tersebut akan berada di alamat yang telah dialokasikan dan tabel simbol
milik kernel akan diperbaharui.

Komponen manajemen modul yang lain adalah peminta modul. Kernel mendefinisikan antarmuka komunikasi yang dapat dihubungi oleh program manajemen modul. Saat hubungan tercipta, kernel akan menginformasikan proses manajemen kapanpun sebuah proses meminta device driver, sistem berkas,atau layanan jaringan yang belum terpanggil dan memberikan manajer kesempatan untuk memanggil layanan tersebut. Permintaan layanan akan selesai saat modul telah terpanggil.
Manajer proses akan memeriksa secara berkala apakah modul tersebut masih digunakan, dan akan menghapusnya saat tidak diperlukan lagi.

Pembuatan Proses Dan Thread

Linux menggunakan representasi yang sama untuk proses dan thread.
Secara sederhana thread dapat dikatakan sebuah proses baru yang
berbagi alamat yang sama dengan induknya. Perbedaannnya terletak
pada saat pembuatannya. Thread baru dibuat dengan system call
clone yang membuat proses baru dengan identitas sendiri, namun
diizinkan untuk berbagi struktur data dengan induknya.

Secara tradisional, sumber daya yang dimiliki oleh proses induk
akan diduplikasi ketika membuat proses anak. Penyalinan ruang
alamat ini berjalan lambat, sehingga untuk mengatasinya, salinan
hanya dibuat ketika salah satu dari mereka hendak menulis di
alamat tersebut. Selain itu, ketika mereka akan berbagi alamat
tersebut ketika mereka hanya membaca. Inilah proses ringan yang
dikenal juga dengan thread.

Thread dibuat dengan __clone(). __clone() merupakan rutin dari
library system call clone(). __clone memiliki 4 buah argumen yaitu:

*

fn

fungsi yang akan dieksekusi oleh thread baru
*

arg

pointer ke data yang dibawa oleh fn
*

flags

sinyal yang dikirim ke induk ketika anak berakhir dan
pembagian sumber daya antara anak dan induk.
*

child_stack

pointer stack untuk proses anak.

clone() mengambil argumen flags dan child_stack yang dimiliki oleh __clone
kemudian menentukan id dari proses anak yang akan mengeksekusi
fn dengan argumen arg.

Pembuatan anak proses dapat dilakukan dengan fungsi fork() dan vfork().
Implementasi fork() sama seperti system call clone() dengan sighandler
SIGCHLD di-set, semua bendera clone di-clear yang berarti tidak ada
sharing dan child_stack dibuat 0 yang berarti kernel akan membuat stack
untuk anak saat hendak menulis. Sedangkan vfork() sama seperti fork()
dengan tambahan bendera CLONE_VM dan CLONE_VFORK di-set. Dengan vfork(),
induk dan anak akan berbagi alamat, dan induk akan di-block hingga
anak selesai.

Untuk memulai pembuatan proses baru, clone() akan memanggil fungsi do_fork().
Hal yang dilakukan oleh do_fork() antara lain:

*

memanggil alloc_task_struct() yang akan menyediakan tempat di memori
dengan ukuran 8KB untuk deskriptor proses dan stack modus kernel.
*

memeriksa ketersediaan sumber daya untuk membuat proses baru.
*

find_empty_procees() memanggil get_free_taskslot() untuk mencari
sebuah slot di array task untuk pointer ke deskriptor proses yang baru.
*

memanggil copy_files/fm/sighand/mm() untuk menyalin sumber daya untuk
anak, berdasarkan nilai flags yang ditentukan clone().
*

copy_thread() akan menginisialisasi stack kernel dari proses anak.
*

mendapatkan PID baru untuk anak yang akan diberikan kembali
ke induknya ketika do_fork() selesai.

Beberapa proses sistem hanya berjalan dalam modus kernel di belakang layar.
Untuk proses semacam ini dapat digunakan thread kernel. Thread kernel hanya
akan mengeksekusi fungsi kernel, yaitu fungsi yang biasanya dipanggil oleh
proses normal melalui system calls. Thread kernel juga hanya dieksekusi dalam
modus kernel, berbeda dengan proses biasa. Alamat linier yang digunakan oleh
thread kernel lebih besar dari PAGE_OFFSET proses normal yang dapat berukuran
hingga 4GB. Thread kernel dibuat sebagai berikut: int kernel_thread(int (*fn) (void *),
void *arg, unsigned long flags); flags=CLONE_SIGHAND, CLONE_FILES, etc

Guna keperluan manajemen proses, kernel memelihara informasi tentang
setiap proses di sebuah deskriptor proses dengan tipe task_struct.
Setiap deskriptor proses mengandung informasi antara lain
status proses, ruang alamat, daftar berkas yang dibuka,
prioritas proses, dan sebagainya. Berikut gambaran isinya:

Isi deskriptor proses :


struct task_struct{
volatile long state;
/*-1 unrunnable,
0 runnable,
>0 stopped*/
unsigned long flags;
/* 1 untuk setiap flag proses */
mm_segment_t_addr_limit;
/* ruang alamat untuk thread */
struct exec_domain *exec_domain;
long need_resched;
long counter;
long priority;
/* SMP and runqueue state */
struct task_struct *next_task, *prev_task;
struct task_struct *next_run, *prev_run;
...
/* task state */
/* limits */
/* file system info */
/* ipc stuff */
/* tss for this task */
/* filesystem information */
/* open file information */
/* memory management info */
/* signal handlers */
...
};





Setiap proses di Linux memiliki status. Status proses merupakan array dari
flag yang mutually exclusive. Setiap proses memiliki tepat satu keadaan
(status) pada suatu waktu. Status tersebut adalah:

*

TASK_RUNNING

Pada status ini, proses sedang ataupun siap dieksekusi oleh CPU.
*

TASK_INTERRUPTIBLE

Pada status ini, proses sedang menunggu sebuah kondisi. Interupsi,
sinyal, ataupun pelepasan sumber daya akan membangunkan proses.
*

TASK_UNINTERRUPTIBLE

Pada status ini, proses sedang tidur dan tidak dapat dibangunkan
oleh suatu sinyal.
*

TASK_STOPPED

Pada status ini proses sedang dihentikan, misalnya oleh sebuah debugger.
*

TASK_ZOMBIE

Pada status ini proses telah berhenti, namun masih memiliki struktur
data task_struct di task vector dan masih memegang sumber daya yang sudah
tidak digunakan lagi.

Setiap proses ataupun eksekusi yang terjadwal secara independen memiliki
deskriptor prosesnya sendiri. Alamat dari deskriptor proses digunakan
untuk mengindentifikasi proses. Selain itu, nomor ID proses (PIDs) juga
digunakan untuk keperluan tersebut. PIDs adalah 32-bit bilangan yang
mengidentifikasikan setiap proses dengan unik. Linux membatasi PIDs
berkisar 0-32767 untuk menjamin kompatibilitas dengan sistem UNIX
tradisional.

Karena proses merupakan sesuatu yang dinamis, maka deskriptor proses
disimpan dalam memori yang dinamis pula. Untuk itu dialokasikan juga
memori sebesar 8KB untuk setiap proses untuk menyimpan proses deskriptornya
dan stack proses dari modus kernel. Keuntungan dari dal ini adalah pointer
dari deskriptor proses dari proses yang sedang berjalan (running) dapat
diakses dengan cepat menggunakan stack pointer. Selain itu,
8KB (EXTRA_TASK_STRUCT) dari memori akan di-cache untuk mem-bypass
pengalokasi memori kernel ketika sebuah proses dihapus dan sebuah proses
baru dibuat. Kedua perintah free_task_struct() dan alloc_task_struct()
akan digunakan untuk melepaskan atau mengalokasikan memori
seukuran 8KB sebagai cache.

Deskriptor proses juga membangun sebuah daftar proses dari semua proses
yang ada di sistem. Daftar proses tersebut merupakan sebuah doubly-linked
list yang dibangun oleh bagian next_task dan prev_task dari deskriptor
proses. Deskriptor init_task(mis:swapper) berada di awal daftar tersebut
dengan prev_task-nya menunjuk ke deskriptor proses yang paling akhir
masuk dalam daftar. Sedangkan makro for_each_task() digunakan untuk
memindai seluruh daftar.

Proses yang dijadwalkan untuk dieksekusi dari doubly-linked list dari
proses dengan status TASK_RUNNING disebut runqueue. Bagian prev_run dan
next_run dari deskriptor proses digunakan untuk membangun runqueue,
dengan init_task mengawali daftar tersebut. Sedangkan untuk memanipulasi
daftar di deskriptor proses tersebut, digunakan fungsi-fungsi:
add_to_runqueue(), del_from_runqueue(), move_first_runqueue(),
move_last_runqueue(). Makro NR_RUNNING digunakan untuk menyimpan
jumlah proses yang dapat dijalankan, sedangkan fungsi wake_up_process
membuat sebuah proses menjadi dapat dijalankan.

Untuk menjamin akurasinya, array task akan diperbarui setiap kali ada
proses baru dibuat ataupun dihapus. Sebuah daftar terpisah akan melacak
elemen bebas dalam array task itu. Ketika suatu proses dihapus, entrinya
ditambahkan di bagian awal dari daftar tersebut.

Proses dengan status task_interruptible dibagi ke dalam kelas-kelas yang
terkait dengan suatu event tertentu. Event yang dimaksud misalnya:
waktu kadaluarsa, ketersediaan sumber daya. Untuk setiap event ataupun
kelas terdapat antrian tunggu yang terpisah. Proses akan diberi sinyal
bangun ketika event yang ditunggunya terjadi. Berikut contoh dari
antrian tunggu tersebut:



void sleep_on(struct wait_queue **wqptr) {
struct wait_queue wait;
current_state=TASK_UNINTERRUPTIBLE;
wait.task=current;
add_wait_queue(wqptr, &wait);
schedule();
remove_wait_queue(wqptr, &wait);
}




Fungsi sleep_on() akan memasukkan suatu proses ke dalam antrian
tunggu yang diinginkan dan memulai penjadwal. Ketika proses itu
mendapat sinyal untuk bangun, maka proses tersebut akan dihapus
dari antrian tunggu.

Bagian lain konteks eksekusi proses adalah konteks perangkat keras,
misalnya: isi register. Konteks dari perangkat keras akan disimpan
oleh task state segment dan stack modus kernel. Secara khusus tss
akan menyimpan konteks yang tidak secara otomatis disimpan oleh
perangkat keras tersebut. Perpindahan antar proses melibatkan
penyimpanan konteks dari proses yang sebelumnya dan proses berikutnya.
Hal ini harus dapat dilakukan dengan cepat untuk mencegah terbuangnya
waktu CPU. Versi baru dari Linux mengganti perpindahan konteks
perangkat keras ini menggunakan piranti lunak yang mengimplementasikan
sederetan instruksi mov untuk menjamin validasi data yang disimpan
\serta potensi untuk melakukan optimasi.

Untuk mengubah konteks proses digunakan makro switch_to(). Makro
tersebut akan mengganti proses dari proses yang ditunjuk oleh prev_task
menjadi next_task. Makro switch_to() dijalankan oleh schedule() dan
merupakan salah satu rutin kernel yang sangat tergantung pada perangkat
keras (hardware-dependent). Lebih jelas dapat dilihat pada kernel/sched.c
dan include/asm-*/system.h.