Tugas 1 Sistem Operasi

5/14/2018 Tugas 1 Sistem Operasi - slidepdf.com

http://slidepdf.com/reader/full/tugas-1-sistem-operasi 1/33

1

TUGAS I

IPC System - Mach

Dosen: Dr.-Ing. M.Reza Pulungan, S.Si, M.Sc

Oleh :

Ervin Kusuma Dewi 323335

Khadijah 325316

Lelly Hidayah Anggraini 309045

Ika Candradewi 322924

PROGRAM ILMU KOMPUTER

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM

UNIVERSITAS GADJAH MADA

YOGYAKARTA

2011



i

DAFTAR ISI

DAFTAR ISI ........................................................................................................................... i BAB I PENDAHULUAN ....................................................................................................... 1 BAB II PEMBAHASAN ........................................................................................................ 2

2.1. Komponen System Mach ....................................................................................... 2 2.2. Interproses Communcation.................................................................................... 4 2.2.1. Port .................................................................................................................... 4

2.2.1.1. Port Right ................................................................................................... 6

2.2.1.2. Port Name space......................................................................................... 8

2.2.1.3. Port Set ....................................................................................................... 9

2.2.1.4. Manipulasi Antarmuka Port ........................................................................ 9

2.2.1.5. Penciptaan Port ........................................................................................ 10

2.2.1.6. Penghacuran Port ..................................................................................... 10

2.2.1.7. Nama Port ................................................................................................ 11

2.2.2. Message .............................................................................................................. 12 2.2.2.1. Mach Message Calls ................................................................................. 12

2.2.2.2. Message Format........................................................................................ 13

2.2.2.3. Pertukaran Port Right ............................................................................... 14

2.2.2.4. Memory .................................................................................................... 14

2.2.2.5. Message Send ........................................................................................... 15

2.2.2.6. Message Receive ...................................................................................... 15

2.3. Kelebihan Mach .................................................................................................. 16 2.4. Contoh program IPC-Mach ................................................................................. 17

BAB III KESIMPULAN ....................................................................................................... 25



ii

DAFTAR PUSTAKA ........................................................................................................... 26 LAMPIRAN ......................................................................................................................... 27



1

BAB I PENDAHULUAN

Dalam komputasi, kernel merupakan komponen utama dari komputer, yang merupakan

jembatan antara aplikasi dan pengelolaan data yang sebenar-benarnya dilakukan pada tingkat

hardware. Tanggung jawab kernel termasuk sumber daya sistem pengelolaan (komunikasi

hardware dan software komponen). Biasanya sebagai komponen dasar dari suatu sistem

operasi, kernel dapat memberikan tingkat terendah lapisan abstraksi untuk sumber daya

(terutama prosesor dan I / O device) bahkan perangkat lunak aplikasi harus kontol untuk

melakukan fungsinya.

Seiring perkembangan sistem operasi yang berfungsi sebagai inti dari pemrograman

komputer , Mach hadir dikembangkan dalam sebuah proyek di Carnegie Mellon University.

Mach merupakan sebuah sistem operasi kernel yang dikembangkan untuk mendukung

penelitian sistem operasi, terutama komputasi terdistribusi dan paralel. Mach kernel sering

disebut-sebut sebagai salah satu contoh awal dari sebuah microkernel. Derivatif Mach adalah

dasar dari kernel sistem operasi modern di Mac OS X dan GNU Hurd.

Proyek di Carnegie Mellon dari 1985-1994 yang berakhir dengan kegagalan dengan

Mach 3.0. Mach dikembangkan sebagai piranti kernel di BSD versi UNIX, sehingga tidak ada

sistem operasi baru harus dirancang pada waktu itu.Mach dan turunannya digunakan di

sejumlah system operasi komersial, seperti NeXSTEP dan OPENSTEP, dan terutama Mac OS

X menggunakan xnu kernel sistem operasi yang menggabungkan non-microkernel Mach

sebagai komponen utamanya.



2

BAB II

PEMBAHASAN

Kernel Mach dirancang sebagai “drop-in” pengganti untuk kernel UNIX tradisional.

Carnegie Mellon University mulai bereksperimen sepanjang garis-garis di bawah kernel

Accent, menggunakan sistem IPC yang didasarkan pada shared memory. Accent adalah sistem

murni eksperimental dengan banyak fitur, yang dikembangkan dalam mode ad-hoc selama

periode waktu dengan perubahan kepentingan penelitian. Selain itu, kegunaan Accent untuk

penelitian terbatas karena tidak compatible dengan UNIX, sedangkan UNIX sudah menjadi

standar de-facto hampir semua penelitian sistem operasi.

Mach dikembangkan pada konsep Accent yang IPC, tapi membuat sistem yang lebih

dari UNIX, bahkan mampu menjalankan program UNIX dengan sedikit atau tanpa modifikasi,

yaitu dengan memperkenalkan konsep dari sebuah port , yang mewakili masing-masing titik

akhir dari dua arah IPC. Port memiliki keamanan dan hak-hak seperti file di bawah UNIX,

yang memungkinkan model UNIX untuk perlindungan.

2.1. Komponen System Mach

Untuk mencapai tujuan desain Mach, para pengembang mengurangi sistem operasi yangfungsionalitas untuk abstraksi dasar, fungsi yang lain diturunkan. Pendekatan Mach adalah

menempatkan sedikit mungkin di dalam kernel tetapi untuk membuat fitur yang ada cukup.

Filosofi desain Mach adalah untuk memiliki sebuah desain simple, kernel yang dapat

dikembangkan, fokus pada fasilitas komunikasi. Sebagai contoh, semua permintaan ke kernel,

dan semua pergerakan data antar proses akan di tangani melalui suatu mekanisme komunikasi.

Mach adalah contoh dari sistem berorientasi objek dimana data dan operasi memanipulasi

data yang dikemas menjadi objek abstrak. Hanya operasi objek dapat bertindak atas entitas

yang didefinisikan di dalamnya. Abstraksi Mach adalah jantung dari sistem yang akan

dijelaskan sebagai berikut :

Task adalah objek yang terdiri dari serangkaian sumber daya sistem yang

memungkinkan “Thread ” untuk menjalankan.



3

Thread adalah suatu unit eksekusi, ada dalam konteks ‘Task ’ dan sumber daya ‘Task ’.

Port adalah antrian message untuk komunikasi antara task , task sendiri mengirim dan

menerima hak masing-masing port .

Message adalah objek data yang hanya dapat dikirim ke port .

Gambar 2.1 Dasar Abstraksi Mach

Sistem IPC awalnya mengalami masalah kinerja, sehingga beberapa strategidikembangkan untuk meminimalkan dampak. Seperti, pendahulunya Accent, Mach

menggunakan mekanisme single physical shared memory untuk melewati message dari suatu

program ke yang lain. Secara fisik menyalin message akan terlalu lambat sehingga Mach

bergantung pada mesin Memory Mangement Unit (MMU). Sehingga data yang akan ditulis

harus disalin secara fisik, proses yang dikenal sebagai copy-on-write. Pendekatan ini memiliki

beberapa keuntungan sebagai berikut :

1. Meningkatkan fleksibilitas dalam manajemen memori untuk penggunaan program-

program.

2. Peningkatan kinerja melalui message passing UNIX



4

2.2. Interproses Communcation

Sebagian besar sistem operasi komersial, seperti UNIX menyediakan komunikasi antara

proses dan host (internet addres). Kernel Mach memberikan oriented-message yaitu

kemampuan komunikasi berbasis interproses. Interposes Comunication (IPC) mendukung

bebagai interaksi, termasuk didalamnya Remote Procedure Calls (RPC), pemrograman

berorientasi objek terdistribusi, streaming data, dan pengiriman data dalam jumlah yang sangat

besar.

2.2.1. Port

Port adalah communication channel satu arah antara client yang meminta layanan dan

sebuah server yang menyediakan layanan. Sebuah port dapat memiliki banyak pengirim

(multiple senders) dan hanya mempunyai satu penerima (single receiver ). Sebuah port

berhubungan dengan message queue. Port juga memelihara sejumlah right (hak akses)

kepadanya. Setiap entitas sistem (selain cakupan virtual memory) dinamai oleh sebuah port ,

sehingga port juga diciptakan secara implisit ketika entitas-entitas tersebut diciptakan.

Pada gambar 2.2 menunjukkan struktur port secara umum. Port terdiri atas satu atau lebih

send right dan satu receive right . Message queue yang berhubungan dengan port terdiri atas

serangkaian urutan message. Message terdiri atas port tujuan (destination port ), reply port

reference, send right dan receive right yang dilewatkan ke message, dan out-of-line data

(virtual copy).

Beberapa system call menyediakan port dengan fungsi sebagai berikut ini :

Mengalokasikan sebuah port baru untuk tugas terntentu dan memberikan tugas akses

semua port baru.

Mengalokasiskan akses port .

Memperoleh status port .

Membuat port cadangan.



5

Gambar 2.2 Struktur port secara umum

Beberapa operasi mempengaruhi port itu sendiri, sebagian operasi mempengaruhi port

right atau port name space yang berisi right tersebut, atau mempengaruhi message queue.

Sebuah port diciptakan secara implisit ketika entitas sistem lainnya (threads, tasks,

processors, processor sets, hosts, atau devices) diciptakan. mach_reply_port juga

menciptakan sebuah port . Sebuah port diciptakan secara eksplisit oleh port_name_space

mach_port_allocate dan port_name_space [ port_name]

mach_port_allocate_name. Sebuah port tidak dapat dihancurkan secara eksplisit. Port hanya

dihancurkan ketika receive right dihancurkan.

Keberadaan port sangat penting untuk semua hal yang terlibat, seperti banyak task yang

menggunakan sebuah port akan menunggu untuk dinotifikasi, melalui sebuah message ketika

mereka mati. Notifikasi seperti ini diminta dengan opsi ke mach_msg, sebagaimana dengan

port_name_space[ port_name] mach_ port _request_notification.



6

2.2.1.1. Port Right

Sebuah port hanya dapat diakses melalui sebuah port right . Port right adalah sebuah

entitas yang mengindikasikan hak akses ke sebuah spesifik port dengan cara yang spesifik.

Dalam konteks ini, terdapat tiga tipe port right , yaitu:

1) receive right , mengijinkan pemegang untuk menerima message dari port yang

berhubungan.

2) send right , mengijinkan pemegang untuk mengirimkan message ke port yang

berhubungan.

3) send-once right , mengijinkan pemegang untuk mengirimkan sebuah message ke port

yang berhubungan. Send-once right lalu menghancurkan dirinya sendiri setelah

message ini dikirimkan.

Port right dapat di-copy dan dipindah di antara sejumlah task melalui berbagai macam

pilihan dalam pemanggilan mach_msg, dan juga oleh perintah eksplisit (explicit command ).

Bereda dengan perasi message, port right dapat dimanipulasi hanya sebagai anggota dari

sebuah port name space.

Port right diciptakan secara implisit ketika entitas sistem lainnya diciptakan dan secara

eksplisit melalui explicit port operation. Kernel akan memberikan notifikasi ketika ada lebih

send right untuk sebuah port . Penghancuran send-once right menghasilkan sebuah send-once

notification yang dikirimkan ke port yang berkorespondensi. Port rights adalah suatu

keamanan, pada suatu jalan yang independen pada pengidentifikasian ports. Hak akses kernel

dilindungi oleh entities, client memanipulasi port rights hanya via port names, ketika mereka

harus melakukannya.

mach_msg adalah salah satu prinsip dimana hak dimanipulasi. Ports right dapat

dipindahkan antar task (dihapus dari pengirim dan ditambahkan ke penerima) dalam message.

Option flags pada suatu message akan menyebabkan mach_msg untuk membuat copy dari

pengiriman right yang telah ada, atau untuk mengenerate, mengirim, atau suatu send-once

right dari right yang diterima. Rights dapat pula dipaksa secara penuh untuk dikopi, atau

dipindahkan oleh port_name_space [port_name]→ mach_port_extrac-t_right

(sama dengan penerimaan target pada right message), Selain operasi message. Port rights

dapat dimanipulasi hanya oleh member dari port name space.



7

Gambar 2.3. memperlihatkan urutan dari port rights, beberapa diantaranya terdiri dari port

name space dan beberapa transit dalam message. Selain itu juga terlihat dari port name space

pada port set . Suatu port right dirusak oleh instruksi port_name_space [port_name]→

mach_port_deallocate dan port_name_space [port_name]→ mach_port_destroy.

Perusakkan dapat pula sebagai product dari port-name pada suatu manipulasi space, seperti

port_name_space [port_name]→mach_port_mod_refs.

Beberapa informasi status dapat diperoleh, diberikan suatu penerimaan right, dengan

port_name_space [port_name]→ mach_port_get_receive_status.

Gambar 2.3. Struktur Port Right

Sistem dirawat dengan suatu (system-wide) penghitungan sejumlah pengiriman (send-

once) rights untuk tiap port (termasuk didalamnya transit pada message, tujuan dan balasan

port rights). Penerima dari suatu port mungkin lebih tertarik jika tidak ada lagi pengiriman

rights dari port. Notifikasi dari bentuk ini dapat diminta (port_name_space [port_name]→



8

mach_port_request_no-tification). Notifikasi ini tergantung pada istilah dari make-send

count, yang didiskusikan sebagai bagian dari port name space. Perpindahan (ke task yang

lainnya) dari penerimaan rights tidak secara langsung berpengaruh pada beberapa no-more-

senders permintaan notifikasi. (Perubahan rencana dibatalkan keluar dari tidak adanya

permintaan notifikasi, dan untuk mengirim suatu send-once notification untuk

mengidentifikasi pembatalan ini). Suatu send-once right mengizinkan suatu message untuk

dikirmkan via jalan tersebut. Rights digenerate hanya dari receive right . Send-once right

memiliki properti yang memberi garansi bahwa message akan memberikan hasil dari itu. Pada

kasus yang normal, send-once right dikonsumsi dengan menggunakan hal itu sebagai port

tujuan pada message. Pada right secara perlahan dirusak ketika message diterima. Send-once

right dapat dipindahkan dari satu task ke task yang lain (disamping digunakan sebagai tujuandari right) hingga beberapa waktu, ini dikonsumsi. Jika right dirusak, disamping

menggunakannya untuk mengirim message, notifikasi send-once dikirim ke port dalam

keadaan stabil.

2.2.1.2. Port Name space

Port dan port right tidak mempunyai system-wide names yang mengijinkan sejumlah

port atau port right untuk dimanipulasi secara langsung. Port dapat dimanipulasi hanya

melalui port right dan port right dapat dimanipulasi hanya ketika mereka diisikan ke dalamsebuah port name space. Sebuah port right dispesifikasi dengan sebuah port name dengan

sebuah indeks ke dalam port name space. Setiap task yang berhubungan dengan sebuah single

port name space.

Sebuah masukan dalam sebuah port name space dapat mempunya kemungkinan nilai, yaitu:

1) MACH_PORT _NULL — Tidak ada port right yang berhubungan.

2) MACH_PORT _DEAD — Sebuah right yang dihubungkan dengan nama ini, tetapi

port yang mana right mengacu telah dihancurkan.

3) port right — Sebuah send-once right , send right , atau receive right untuk sebuah port .

4) port set name —Sebuah nama yang bertindak seperti receive right , tetapi mengijinkan

penerimaan dari multiple port s.



9

2.2.1.3. Port Set

Sebuah port set adalah sekumpulan port yang dapat diperlakukan sebagai sebuah

single unit ketika menerima sebuah message. Sebuah operasi receive dari mach_msg diijinkan

melanggar sebuah port name yang menamai receive right , atau sebuah port set . Sebuah port

set berisi sekumpulan receive right . Ketika sebuah receive operation dilakukan dengan

melanggar sebuah port set , sebuah message akan diterima pada salah satu port yang dipilih

secara acak dalam port set . Setiap receive right dalam port set mempunyai nama sendiri, dan

port set juga memiliki nama sendiri. Sebuah receive right yang melanggar port set melaporkan

nama receive right tersebut yang port -nya menyediakan message. Receive right hanya dapat

termasuk ke dalam satu port set . Sebuah task tidak dapat secara langsung menerima dari

receive right yang berada di dalam port set.Sebuah port set diciptakan dengan port_name_space [ port_name]

mach_ port _allocate atau port_name_space [ port_name]

mach_ port _allocate_name. Port set dihancurkan oleh port_name_space [ port_name]

mach_ port _destroy atau port_name_space [ port_name] mach_ port _deallocate.

Manipulasi port set dilakukan dengan port_name_space [ port_name]

mach_ port _move_member. Pemanggilan ini dapat menambahkan sebuah anggota ke sebuah

port set , menghapus anggota dari port set , atau memindahkannya dari satu port set ke port set

yang lain. Keanggotaan dari sebuah port set dapat ditemukan dengan port_name_space

[ port_name] mach_ port _get_set_status.

2.2.1.4. Manipulasi Antarmuka Port

Bagian ini menggambarkan antarmuka untuk menciptakan, merusak dan memanipulasi

port , port dan set hak port . Jenis data ipc_space_t ini adalah task _t (dan dengan demikian

mach_ port _t a), yang memegang nama port yang terkait dengan port yang mewakili ruang

IPC di kernel. Ruang IPC digunakan oleh kernel untuk mengelola nama port dan hak-hak

yang tersedia untuk task . Ruang IPC tidak mendapatkan nama port sendiri. Sebaliknya nama

port dari tugas mengandung ruang IPC digunakan untuk nama ruang IPC tugas (seperti yang

ditunjukkan oleh fakta bahwa jenis ipc_space_t sebenarnya task _t). Ruang IPC tugas hanya

dapat diakses di luar kernel.



10

Berikut ini adalah jenis-jenis antarmuka port dalam Mach:

1) Penciptaan Port , cara membuat port baru dan set port .

2) PengahancuranPort , bagaimana untuk merusak port dan set port .

3) Port Name, bagaimana query dan memanipulasi nama port .

4) Port right , bagaimana bekerja dengan hak port .

5) Port dan Tugas lainnya, bagaimana untuk memindahkan hak antara tugas.

6) Receiving right , bagaimana bekerja dengan menerima hak.

7) Port Set , bagaimana bekerja dengan set port .

8) NotificationRequest , bagaimana meminta pemberitahuan untuk acara.

2.2.1.5. Penciptaan Port

Fungsi mach_ port _allocate menciptakan hak baru dalam tugas tertentu. Nama yang

tepat baru dikembalikan dalam nama, mungkin nama yang tidak digunakan.

Argumen yang tepat mengambil nilai berikut :

MACH_PORT_RIGHT_RECEIVE

MACH_PORT_RIGHT_PORT_SET

MACH_PORT_RIGHT_DEAD_NAME

2.2.1.6. Penghacuran Port

Fungsi mach_port_deallocate melepaskan referensi pengguna untuk hak tugas IPC. Hal

ini memungkinkan tugas untuk melepaskan referensi pengguna untuk mengirim atau kirim-

sekali tepat tanpa gagal jika port telah meninggal dan kanan adalah sekarang benar-benar

nama mati.

Jika nama menunjukkan nama mati, mengirim kanan, atau kirim-sekali benar, maka hak

kehilangan satu referensi pengguna. Jika hanya memiliki satu referensi pengguna, kemudian

kanan ini hancur.

Fungsi ini mengembalikan KERN_SUCCESS jika panggilan berhasil, KERN_INVALID_TASK jika tugas tidak sah, KERN_INVALID_NAME jika nama tidak menunjukkan hak dan

KERN_INVALID_RIGHT jika nama dinotasikan hak valid . Pemanggilan mach_ port _deallocate

sebenarnya RPC untuk tugas, biasanya hak kirim untuk port tugas, tetapi berpotensi kirim

benar. Selain kode kembali normal diagnostik dari server call (biasanya kernel), panggilan

dapat kembali kembali kode mach_msg.



11

2.2.1.7. Nama Port

Pada mach_ port _names fungsi mengembalikan informasi tentang ruang nama tugas itu

port . Untuk setiap nama, juga mengembalikan apa jenis tugas memegang hak (informasi yang

sama dikembalikan oleh mach_ port _type.) Nama dan tipe array dialokasikan otomatis ketika

message balasan diterima. Pengguna harus vm_deallocate mereka ketika data tidak lagi

diperlukan.

Mach_ port _names akan kembali nama nama-nama port , port set , dan nama ruang nama

mati dalam tugas itu port , tanpa urutan tertentu dan dalam ncount jumlah nama kembali. Ini

akan kembali dalam jenis jenis setiap nama yang sesuai, yang menunjukkan apa hak tugas

memegang dengan nama itu. tcount harus sama dengan count.

Para mach_ port _type fungsi mengembalikan informasi tentang hak tugas untuk nama

tertentu dalam ruang nama port . ptype dikembalikan adalah bitmask menunjukkan apa tugas

memegang hak untuk port , set port atau nama mati. Bitmask ini terdiri dari bit berikut:

MACH_PORT_TYPE_SEND

Nama menunjukkan suatu kirim tepat.

MACH_PORT_TYPE_RECEIVE

Nama menunjukkan suatu menerima hak.

MACH_PORT_TYPE_SEND_ONCE

Nama menunjukkan hak-sekali mengirim.

MACH_PORT_TYPE_PORT_SET

Nama menunjukkan suatu set port .

MACH_PORT_TYPE_DEAD_NAME

Nama adalah nama mati.

MACH_PORT_TYPE_DNREQUEST

Permintaan mati-nama telah terdaftar untuk kanan. MACH_PORT_TYPE_MAREQUEST

Permintaan msg-diterima untuk kanan adalah tertunda.

MACH_PORT_TYPE_COMPAT

Hak port diciptakan dalam modus kompatibilitas.



12

2.2.2. Message

Sebuah message terdiri atas header , message dikirim dan diterima. Task mengirim

message ke port , message yang dikirim ke port akan disampaikan dengan tepat (message tidak

mungkin hilang) dan diterima dalam urutan dimana message tersebut dikirim. Message berisi

header yang berukuran tetap dan sejumlah variabel data dimasukan dalam header , header

menggambarkan tujuan dan ukuran message.

2.2.2.1. Mach Message Calls

Untuk menggunakan panggilan mach_msg, kita dapat menyertakan file header

mach/port.h and mach/message.h

1) Fungsimach_msg_return_t mach_msg (

mach_msg_header_t *msg,

mach_msg_option_t option, mach_msg_size_t send_size,

mach_msg_size_t rcv_size, mach_port_t rcv_name,

mach_msg_timeout_t timeout, mach_port_t notify )

Fungsi mach_msg digunakan untuk mengirim dan menerima message. Mach message berisi

data, yang dapat mencakup port right dan acuan ke memori. Msg adalah alamat dari buffer

dalam alamat pemanggil. Buffer message harus sejajar pada panjang-batas kata. Message

mempunyai opsi pilihan yang sedikit nilai, dikombinasikan dengan bitwise. Satu atau kedua

MACH_SEND_MSG dan MACH_RCV_MSG harus digunakan. Pilihan lain bertindak sebagai

pengubah. Saat mengirim message, send_size menentukan ukuran buffer message. Jika

tidak nol harus diberikan. Ketika menerima message, rcv_size menentukan ukuran buffer

message. Jika tidak nol harus diberikan. Ketika menerima message, rcv_name menentukan

port atau set port . Jika tidak MACH_PORT_NULL harus diberikan. Bila menggunakan

MACH_SEND_TIMEOUT dan pilihan MACH_RCV_TIMEOUT, timeout menentukan waktu dalam

milidetik untuk menunggu sebelum menyerah. Jika tidak MACH_MSG_TIMEOUT_NONE harus

diberikan. Bila menggunakan MACH_SEND_NOTIFY, MACH_SEND_CANCEL, dan pilihan

MACH_RCV_NOTIFY, memberitahukan menentukan port yang digunakan untuk

pemberitahuan. Jika tidak MACH_PORT_NULL harus diberikan.



13

Jika argumen pilihan MACH_SEND_MSG, mengirimkan message. Argumen send_size

menentukan ukuran message untuk mengirim. Field msgh_remote_port dari header

message menentukan tujuan message.

Jika argumen pilihan MACH_RCV_MSG, menerima message. Argumen rcv_size

menentukan ukuran buffer message yang akan menerima message, message lebih besar dari

rcv_size tidak diterima. Argumen rcv_name menentukan port atau set port dari mana

untuk menerima.

Jika argumen pilihan adalah MACH_SEND_MSG | MACH_RCV_MSG, maka mach_msg tidak baik

mengirim dan menerima operasi. Jika operasi mengirim menemukan kesalahan (kembali

kode selain MACH_MSG_SUCCESS), kemudian memanggil kembali segera tanpa mencoba

menerima operasi. Panggilan gabungan setara untuk memisahkan mengirim dan menerimapanggilan, tetapi menghemat panggilan sistem dan memungkinkan optimasi internal

lainnya.

Jika argumen tidak menspesifikasikan MACH_SEND_MSG atau MACH_RCV_MSG, maka

mach_msg tidak apa-apa. Beberapa pilihan, seperti MACH_SEND_TIMEOUT dan

MACH_RCV_TIMEOUT, berbagi argumen pendukung. Jika pilihan ini digunakan bersama-

sama, mereka menggunakan independen dari nilai argumen yang mendukung itu.

2) Data Type

mach_msg_timeout_t

Mach msf_timeout_t adalah natural_t digunakan oleh mekanisme timeout. Unit adalah

milidetik, nilai yang digunakan ketika ada batas waktu tidak ada

MACH_MSG_TIMEOUT_NONE.

2.2.2.2. Message Format

Message Mach terdiri dari header message ukuran tetap, mach_msg_header _t, diikuti

oleh nol atau lebih item data. Item data yang diketik. Setiap item memiliki deskriptor jenis

diikuti dengan data aktual (atau alamat dari data, untuk out-of-line daerah memori). Jenis data

berikut terkait dengan Message Mach :

mach_msg_bits_t

Tipe data mach_msg_bits_t adalah unsigned int digunakan untuk menyimpan berbagai

flag message.



14

mach_msg_size_t

Tipe data mach_msg_size_t adalah unsigned int digunakan untuk menyimpan ukuran

message.

mach_msg_id_t

Tipe data mach_msg_id_t adalah integer_t biasanya digunakan untuk menyampaikan

fungsi atau id operasi untuk penerima.

mach_msg_header _t

Struktur ini adalah awal dari setiap message dalam sistem IPC Mach

2.2.2.3. Pertukaran Port Right

Port adalah hak dengan bilangan bulat positif. Kecuali untuk nilai MACH_PORT_NULL

dicadangkan (0) 1 dan MACH_PORT_DEAD (~ 0), dengan 32-bit nama lengkap. Ketika kernel

memilih nama untuk hak baru, ia bebas untuk memilih nama yang tidak digunakan. Sebuah message dapat membawa port right ; msgt_name (msgtl_name)

mendiskripsikan jenis port dan mana port yang tepat harus diekstrak. Nilai MACH_PORT_NULL

dan MACH_PORT_DEAD selalu valid di tempat port right . Dalam message terkirim, nilai

msgt_name berikut menunjukkan hak port :

MACH_MSG_TYPE_MAKE_SEND

MACH_MSG_TYPE_COPY _SEND

MACH_MSG_TYPE_MOVE_SEND

MACH_MSG_TYPE_MAKE_SEND_ONCE

MACH_MSG_TYPE_MOVE_SEND_ONCE

MACH_MSG_TYPE_MOVE_RECEIVE

MACH_MSG_TYPE_PORT _SEND

MACH_MSG_TYPE_PORT _SEND_ONCE

MACH_MSG_TYPE_PORT _RECEIVE

2.2.2.4. Memory

Sebuah message dapat berisi alamat pengirim yang harus ditransfer sebagai bagian dari

message. Message membawa salinan dari memor, tapi kernel menggunakan teknik VM untuk

menyalin halaman, kecuali pengirim atau penerima memodifikasi data halaman fisik tetap.



15

Transfer out-of-line terjadi ketika deskripsi jenis data menentukan msgt_inline sebagai

FALSE. Alamat dari memory (sebuah vm_offset_t atau vm_address_t) harus mengikuti

deskripsi Message. Data out-of-line tidak memberikan kontribusi untuk ukuran message.

Nama, ukuran dan nomor komlom deskripsi tipe jenis dan panjang dari out-of-line,

bukan alamat di line. Ou-of-line memori sering memerlukan tipe yang

panjang(mach_msg_type_long_t) karena field msgt_number terlalu kecil untuk

menggambarkan sebuah halaman 4K byte.

2.2.2.5. Message Send

Operasi antrian mengirim message ke port , message membawa salinan data pemanggil.

Setelah mengirim, pemanggil datap dengan bebas memodifikasi buffer message atau out-of-

line memory dan isi message tidak akan berubah. Jika antrian port sudah penuh, maka

beberapa hal bisa terjadi. Dibawah ini merupakan tahapan memodifikasi message send yang

tidak bisa diabaikan :

MACH_SEND_TIMEOUT

MACH_SEND_NOTIFY

MACH_SEND_NOTIFY_IN_PROGRESS.

MACH_SEND_INTERRUPT

MACH_SEND_CANCEL

2.2.2.6. Message Receive

Operasi menerima messagean dari port , Task memperoleh right menerima thread dan

dibawah message memori-of-line. rvc_name menetapkan sekumpulan port penerima. Sebuah

message yang diterima dapat memuat right port dan out-of-line. Para msgh_local_port

tidak menerima right thread , tindakan menerima message mengirim ke port tujuan.

Msg_remote_ port menerima, menjawab, dan membawa port dan memori jika

MACH_MSGH_BITS_COMPLEX berada dalam msgh_bits.

Kode-kode di bawah ini menandakan sebuah message diterima :

MACH_RCV_INVALID_NAME

Yang ditentukan rcv_name tidak valid.

MACH_RCV_IN_SET



16

Port tertentu adalah anggota dari sebuah set port .

MACH_RCV_TIMED_OUT

Interval timeout berakhir.

MACH_RCV_INTERRUPTED

Sebuah software interrupt terjadi.

MACH_RCV_PORT _DIED

Penelepon kehilangan hak-hak yang ditentukan oleh rcv_name .

MACH_RCV_PORT _CHANGED

rcv_name ditentukan hak menerima yang dipindah ke port diatur selama panggilan.

MACH_RCV_TOO_LARGE

Bila menggunakan MACH_RCV_LARGE , dan message itu lebih besar dari rcv_size .

Message dibiarkan antri, dan ukuran sebenarnya dikembalikan dalam msgh_size

bidang buffer message.

2.3. Kelebihan Mach

Sistem operasi Mach dirancang untuk menyediakan dasar kekurangan sistem operasi.

Tujuanya adalah untuk merancang sebuah sistem operasi BSD yang kompatible. Di bawah ini

merupakan keunggulan Mach :

Sup port untuk arsitektur yang beragam, termasuk Multiprosesor dengan akses memori

bersama : Uniform Memory Access (UMA), Nonuniform Memory Access (NUMA),

dan Remote Memory Access (NORMA)

Mampu untuk berbagai kecepatan intercomputer jaringan dari jaringan wide-area

berkecepatan tinggi maupun jaringan local area.

Struktur kernel yang sederhan dengan sejumlah abstraksi (abstraksi-abstraksi ini cukup

memungkinkan sistem operasi lain untuk diimplementasikan di atas Mach).

Operasi yang terdistribusi, menyediakan transparasi jaringan untuk klien dan

berorientasi objek baik secara internal dan eksternal.

Manajemen memori terpadu dan komunikasi interproses. Menyediakan komunikasi

yang efesien dari sejumlah data serta komunikasi berbasis manajemen memori



17

Mendukung sistem heterogen, untuk membuat Mach tersedia secara luas dan

dioperasikan antara sistem komputer dari beberapa vendor

Pada desainer Mach sangat dipengaruhi oleh BSD (dan oleh UNIX pada umumnya) yang

meberikan manfaat sebagai berikut :

Antarmuka yang sederhana dan konsisten.

Port abilitas untuk class uniprosesor .

Library yang luas untuk utilitas dan aplikasi.

Kemampuan untuk menggabungkan utilitas melalui pipa.

Selain di atas, para desaigner Mach juga ingin memperbaiki kelemahan BSD, yaitu :

Sebuah kernel yang menjadi berlebihan banyak fitur dan akibatnya sulit untuk

mengelola dan memodifikasi.

Tujuan desain asli sulit untuk memberikan dukungan prosesor untuk sistem distribusi

dan shared program. Misalnya kernel diracang untuk uniprosesor, ia tidak memiliki

ketentuan untuk kode penguncian namun prosesor lainya mungkin menggunakan.

Abstraksi mendasar terlalu banyak.

Berdasarkan penjelasan di atas, perkembangan Mach terus menjadi usaha besar. Manfaatsistem tersebut sama-sama besar namun Sistem operasi bejalan pada uni dan ada banyak

arsitektur multiprosesor. Wilayah eksperimen Mach meliputi operasi sistem, database, sistem

terdistribusi , bahasa multiprosesor, keamanan dan distrsibusi kecerdasan buatan.

2.4. Contoh program IPC-Mach

Contoh program berikut menunjukkan bagaimana message dilewatkan antara 2 task .

Contoh ini mengilustrasikan beberapa fitur Mach yang mendasar, yaitu alokasi, dealokasi, dan

penggunaan port , penggunaan environment manager , mengatur struktur message, dan

komunikasi antara dua proses melalui message atau port . Pada contoh ini, parent task akan

menciptakan sebuah child task , yang akan mengirimkan message ke berisi data ke parent .

Parent kemudian akan menotifikasi child tersebut dengan mengirimkan reply message.



18

Contoh ini menggunakan versi Mach dari UNIX fork utility untuk menciptakan ( fork )

sebuah child task . Fork dalam UNIX menciptakan salinan lengkap dari address space parent

dan menyiapkan child untuk mulai mengeksekusi segera setelah pemanggilan fork . Fork

dalam Mach menciptakan dua port untuk child task , didefinisikan dengan task _self(), dan

sebuah notification port , didefinisikan dengan task_notify. Task port adalah port yang

merepresentasikan task terebut dalam pemanggilan ke kernel. Notify port adalah port yang

mana task tersebut bisa menerima message khusus dari kernel. Child task juga mewarisi

exception port , bootstrap port dan beberapa port untuk sistem server sepeti environment

manager dan NetMsgServer. Akses ke user defined port tidak diwariskan melalui forking.

Thread yang diciptakan memiliki sebuah thread kernel port , diacu oleh thread _self(), dan

sebuah thread reply port , diacu dengan thread _reply() yang diciptakan untuknya. Thread kernel port tersebut adalah port yang merepresentasikan thread di pemanggilan kernel. Thread

reply port adalah sebuah port yang mana thread dapat menerima beberapa initialization

message dari parent -nya.

Message passing antara parent dan child tidak dapat terjadi sampai sebuah port dikenal

oleh kedua proses tersebut. Sebelum forking, sebuah string disusun untuk digunakan sebagai

nama communication port dan sebuah port dialokasikan menggunakan pemanggilan

port_allocate. Kemudian, fungsi environment manager env_set_ port dipanggil untuk

menghubungkan nama dengan port . Nama ini tersedia untuk kedua proses tersebut setelah

forking karena nama tersebut merupakan variabel statis. Setelah fork , child dapat memperoleh

send right ke port menggunakan env_get_ port.

Sekarang kedua task mempunyai akses ke communication port , sebuah message disusun

oleh child . Message ini berisi sebuah fixed sized message header dan variable sized data

portion. Ketika membangun message, child mengatur field msg_remote_ port di haeder ke

communication port yang telah dibangun sebelumnya. Field ini menunjuk port ke mana

message dikirimkan. Header field lainnya yang harus diatur dengan tepat oleh child adalah

msg_local_ port. Ini adalah port di mana child akan menunggu reply message. Pada contoh

ini, child akan menerima reply message pada thread reply port -nya. Task yang menerima

message yang dibuat oleh child secara otomatis menerima send right ke msg_local_ port.



19

Karena child task berharap untuk mengirimkan message dan kemudian segera menerima reply

message, child memilih menggunakan msg_rpc daripada msg_send dan msg_receive.

msg_rpc mengirim dan menerima message menggunakan message buffer yang sama untuk

kedua pemanggilan tersebut.

Kode lengkap dari contoh program disajikan pada Lampiran, sedngkan penjelasan

berbagai fungsi yang digunakan dalam contoh akan diejalskan sebagai berikut

1) Mach Error Printing

mach_error adalah sebuah error routine yang menerima sebuah string dan nilai error.

String kemudian dicetak bersama dengan sebuah error string yang berhubungan dengan nilai

tersebut.

kern_return__t error;

mach_error("PARENT: port _allocate returned value of", error);

2) Port Allocation

port _allocate digunakan untuk mengciptakan sebuah port . Argumen pertama untuk.

port _allocate adalah task yang memiliki port , dalam kasus ini proses itu sendiri atau

task _selft().

port _t result;

kern_return_t error;

if ((error = port _allocate(task _self(), &result)) != KERN_SUCCESS) {

mach_error("PARENT: port _allocate returned value of ", error);

exit(1);

}

3) Port Deallocation

port _deallocate digunakan untuk melepaskan akses sebuah task ke sebuah port .

Jika task tersebut mempunyai kepemilikan dan receive right ke port , port _deallocate menghancurkan port dan menotifikasi (pada notify port ) semua task lain yang mempunyai

send right ke port tersebut.



20

port _t my_ port;


if ((error = port _deallocate(task _self(), my_ port)) != KERN_SUCCESS)

{

mach_error("PARENT: port _deallocate returned value of ", error);

exit(1);

}

4) Environment Manager Server/Checking in a Port

Environtment manager digunakan sebagai sebuah repository untuk port yang bernama.

env_get_ port dapat digunakan untuk menghubungkan sebuah nama dengan sebuah port .

Port harus telah ditangkap melalui sebuah message, atau port _allocate, atau menjadi salah

satu dari system port khusus yang ditangkap pada penciptaan task . Nama di-set ke sebuah

string.

env_name_t name;

port _t comm_ port;


if ((error = env_set_ port(environment_ port, name,comm_ port)) !=

KERN_SUCCESS) {

mach_error("PARENT: env_set_ port returned value of ", error);

exit(1);

}

5) Environment Manager Server/Looking up a Port

Dapat digunakan untuk mencari sebuah port ketika nama sebuah port diketahui. Jika

env_set_ port tidak dipanggil untuk menghubungkan sebuah port dengan nama yang

diberikan, env_get_ port akan gagal.

env_name_t name;

port _t comm_ port;


/* Name has been previously set to a desired string. */

if ((error = env_get_ port(environment_ port, name,&comm_ port)) !=

KERN_SUCCESS) {

mach_error("env_get_ port returned ", error);exit(1);

}

6) Mengatur simple message

Suatu pesan yang terdiri dari berbagai header yang panjang dan tetap didefinisikan dengan

struktur msg_header_t, diikuti oleh sejumlah tipe item data. Suatu message adalah pesan



21

sederhana jika tidak mengandung data (pointer) out-of-line dan port. Bidang

msg_remote_port harus berisi port dimana pesan akan dikirim. Pada kasus ini adalah

comm_port. Bidang msg_local_port harus ditetapkan ke set port atau port dimana pesan

balasannya diharapkan. Tthread_reply (), yang mengembalikan thread_replay_ports digunakan

sebagai port balasan.

typedef struct {

unsigned int :24,

msg_simple : 8;

unsigned int msg_size; /* in bytes */

int msg_type; /* NORMAL, EMERGENCY */

port_t msg_local_port;

port_t msg_remote_port;

int msg_id; /* user supplied id */

} msg_header_t;

struct simp_msg_struct {

msg_header_t h;

msg_type_t t;

int inline_data[MAXDATA];

};

struct simp_msg_struct msg_xmt;

port_t comm_port;

msg_xmt= &msg_xmt_data;

msg_xmt.h.msg_local_port = thread_reply();

msg_xmt.h.msg_remote_port = comm_port;

msg_xmt.h.msg_size = sizeof(struct simp_msg_struct);msg_xmt.h.msg_id = 0x12345678;

msg_xmt.h.msg_type = MSG_TYPE_NORMAL;

msg_xmt.h.msg_simple = TRUE;

msg_xmt.t.msg_type_name = MSG_TYPE_INTEGER_32;

msg_xmt.t.msg_type_size = 32;

msg_xmt.t.msg_type_number = MAXDATA;

msg_xmt.t.msg_type_inline = TRUE;

msg_xmt.t.msg_type_longform = FALSE;

msg_xmt.t.msg_type_deallocate = FALSE;

/* fill the msg_xmt.inline_data array with the desired data */

7) Sending Message

Parameter pertama untuk msg_send adalah suatu msg_header_t. Message ini akah

dikirim ke port yang diindikasikan dengan bidang msg_remote_port. Pengiriman secara

benar dari msg_local_port diberikan kepada pengirim., sehingga memungkinkan

pengiriman replay message.



22

msg_return_t ret;


msg_header_t h;

msg_type_t t;


};


if ((ret = msg_send(&msg_xmt.h, MSG_OPTION_NONE, 0)) != SEND_SUCCESS{

mach_error("CHILD: msg_send returned value of ", ret);

exit(1);

}

8) Receiving Message

msg_receive digunakan untuk mendapatkan kembali message selanjutnya dari port

khusus dalam bidang msg_remote_port. Bidang msg_size harus diatur pada ukuran buffer

untuk message dan nilai dari ukuran maksimum pesan yang diizinkan untuk diterima. Jika

message yang diurutkan pada port terlalu besar, maka penerimaan akan gagal. Ketika

msg_receive dikembalikan. Bidang msg_remote_port tidak akan diatur sebagai pengirim

bidang msg_local_port, atau port dapat membalas message yang diharapkan dan msg_size

akan diatur pada ukuran message yang akan diterima.

msg_return_t ret;


msg_header_t h;

msg_type_t t;

int inline_data[MAXDATA];};

struct simp_msg_struct msg_rcv;

msg_rcv.h.msg_size = sizeof(msg_rcv);

msg_rcv.h.msg_local_port = comm_port;

if ((ret = msg_receive(&msg_rcv.h, MSG_OPTION_NONE, 0)) !=

RCV_SUCCESS){

mach_error("CHILD: msg_receive returned value of ", ret);

exit(1);

}

9) Mengatur Replay Message

Pada titik ini suatu message telah berhasil diterima pada strukturmsg_rcv.

Suatu replaymessage dibangun dan dikirm kepada pengirim dari msg_rcv. Sebagai catatan, replay

message, msg_xmt adalah bentuk simple dari msg_header_t sejak tidak ada data yang

tersedia. Bidang msg_remote_port, yang digunakan untuk mengirim message yang diatur ke

remote port dari message yang diterima sebelumnya. msg_receive yang terbaru memanggil



23

pengatur bidang remote port dari msg_rcv ke bidang msg_local_port yang dispesifikasikan

oleh sender. Contoh berikut adalah cara mengatur bidang msg_local_port.


msg_header_t h;msg_type_t t;


};

msg_header_t msg_xmt;

struct simp_msg_struct *msg_rcv;

msg_xmt.h.msg_remote_port = msg_rcv->h.msg_remote_port;

msg_xmt.h.msg_local_port = PORT_NULL; /* no reply expected */

msg_xmt.h.msg_id = 0x12345678;

msg_xmt.h.msg_size = sizeof(msg_header_t);


msg_xmt.h.msg_simple = TRUE;

10) RPC, Send/Receive

msg_rpc melakukan sebuah msg_send diikuti oleh sebuah msg_receive menggunakan

message buffer yang sama. msg_size adalah ukuran message yang sedang dikirim. Parameter

ketiga ke msg_rpc merepresentasikan ukuran maksimum message buffer untuk message yang

diterima. Dalam kasus ini, parameter ketiga ini adalah ukuran message yang dikirim karena

relpy message lebih kecil.

msg_return_t ret;

struct simp_msg_struct {msg_header _t h;

msg_type_t t;


};


if ((ret = msg_rpc(&msg_xmt.h, MSG_OPTION_NONE, sizeof(msg_xmt), 0, 0)) !=

RPC_SUCCESS) {

mach_error("CHILD: msg_rpc returned value of ", ret);

exit(1);

}

11) A Non-Simple Message

Message termasuk non-simple message jika message tersebut berisi sejumlah port atau

out-of-line data. Contoh berikut menunjukkan bagaimana membangun sebuah data yang berisi

out-of-line data. Alasan yang paling umum untuk mengirim out-of-line data adalah blok data

atau ukuran variabel yang sangat besar. In-line data di-copy oleh pengirim ke dalam struktur

message dan kemudian sering di-copy-kan ke message oleh penerima. Out-of-line data



24

dipetakan oleh kernel dari address space pengirim ke address space penerima. Tidak ada

peng-copy-an data yang dilakukan kecuali satu dari dua task yang berututan memodifikasi

data. Berikut ini adalah contoh dari copy-on-write data sharing.

struct ool_msg_struct {

msg_header _t h;

msg_type_t t;

int *out_of_line_data;

};

struct ool_msg_struct msg_xmt;

port _t comm_ port;

msg_xmt.h.msg_local_ port = thread _reply();

msg_xmt.h.msg_remote_ port = comm_ port;

msg_xmt.h.msg_size = sizeof(struct ool_msg_struct);

msg_xmt.h.msg_id = 0x12345678;


msg_xmt.h.msg_simple = FALSE;

msg_xmt.t.msg_type_name = MSG_TYPE_INTEGER_32;

msg_xmt.t.msg_type_size = 32;

msg_xmt.t.msg_type_number = MAXDATA;

msg_xmt.t.msg_type_inline = FALSE;

msg_xmt.t.msg_type_longform = FALSE;

msg_xmt.t.msg_type_deallocate = FALSE;

/* set msg_xmt.out_of_line_data to point to the data */



25

BAB III

KESIMPULAN

Dari penjelasan bab-bab di atas lahirnya sistem operasi Mach sangat mendukung

penelitian sistem operasi terutama sistem operasi yang terdistribusi dan komputasi paralalel.

Walaupun proyek Mach gagal pada pengembangan Mach 3.0 namun Mach menjadi

microkernel sejati yang mana Mach dikembangkan sebagai kernel BSD versi UNIX, selain itu

kernel Mach digunakan sebagai komponen utama oleh sejumlah sistem operasi komersial

seperti NeXTSTEP , OPENSTEP , dan Mac OS X.

Konsep yang dibangun pada Mach yaitu yang dirancang sebagai “drop-in” pengganti

untuk kernel UNIX tradisional, Mach menggunakan Interposes Communication (IPC) yaitu

seperti sebuah sistem yang memindahkan informasi atara dua program, sehingga semua fitur

dirancang untuk menjadi platform yang netral dimana Mach dikembangkan dengan

memperhatikan multiprosesing. Mach menggabungkan seluruh dukungan multiprosessing

yang sangat fleksible, mulai dari sistem memori bersama antar prosesor. Mach dirancang

untuk berjalan pada sistem komputer mulai dari satu sampai ribuan prosesor, selain itu Mach

mudah di porting ke banyak arsitektur komputer yang bervarias. Tujuan utama Mach adalah

menjadi sistem terdistrubusi yang mampu berfungsi pada hardware yang heterogen



26

DAFTAR PUSTAKA

anonim. “ Inter Process Communication”. http://www.gnu.org/software/hurd/gnumach-

doc/Inter-Process-Communication.html

anonim.” Mach (Kernel)”. 11-Oktober-2011. http://en.wikipedia.org/wiki/Mach_(kernel)

Brinkmann, Marcus. Matzigkeit ,Gordon. Hasnaoui ,Gibran. Baron, Robert V. Draves

,Richard P. Thompson, Mary R. Barrera, Joseph S. “The GNU Mach Reference

manual".2008. e-book.

Galvin, P.B. and A. Silberschatz, 1994, “Operating System Concepts”, Addison-Wesley

Publ. CO., Reading, Massachusetts

Loepere, Keith.”Open Software Foundation and Car negie Mellon University”.1992.Jurnal

Walmer , Linda R And Thompson, Mary R.” A Programer’s Guide to the Mach System

Calls”. 1989. Jurnal



27

LAMPIRAN

/*

* This program is an illustration of MACH message passing from a child

* to the parent process and back. In this example, the child is passing* a simple message where the data is stored in the message. The program

* allocates a port to use for communication. The environment manager

* is used to register the port with a name that both the parent

* and child know. The program forks a child process which

* then uses env_get_port to acquire the port needed for communication.

* A message, containing the data the parent needs, is formed by the child

* and sent with msg_rpc to the parent. msg_rpc does a send and a receive

* using the same message buffer. The parent does a receive on the

* established communication port receiving the message from the child.

* Upon receiving the child’s message, the parent constructs and sends

* a confirmation or reply message back to the child indicating he received

* the child’s message and data. The call to msg_rpc by the child

* receives the parent’s reply. The child then tells the environment* manager the communication port is no longer needed, and calls

* port_deallocate.

*

**********************************************************/

#include <stdio.h>

#include <mach.h>

#include <mach_error.h>

#include <mach/message.h>

#include <servers/env_mgr.h>

#define MAXDATA 20

/* simple message structure */

struct simp_msg_struct {msg_header_t h;

msg_type_t t;


};

/* This routine is used to set up the message containing the data that

* the child will send to the parent. Here the data is a simple array of

* integers. */

void setup_simp_request(msg_xmt, my_port)

struct simp_msg_struct *msg_xmt;

port_t my_port;

{int i;

msg_xmt->h.msg_local_port = thread_reply();

msg_xmt->h.msg_remote_port = my_port;

msg_xmt->h.msg_size = sizeof(struct simp_msg_struct);

msg_xmt->h.msg_id = 0x12345678;

msg_xmt->h.msg_type = MSG_TYPE_NORMAL;

msg_xmt->h.msg_simple = TRUE;

msg_xmt->t.msg_type_name = MSG_TYPE_INTEGER_32;

msg_xmt->t.msg_type_size = 32;



28

msg_xmt->t.msg_type_number = MAXDATA;

msg_xmt->t.msg_type_inline = TRUE;

msg_xmt->t.msg_type_longform = FALSE;

msg_xmt->t.msg_type_deallocate = FALSE;

for (i = 0; i < MAXDATA; i++)

msg_xmt->inline_data[i] = i;

}

/* This procedure is used to set up the reply message that the parent is

* sending to the child. Note that the remote_port of the received message

* designates where the reply message will be sent. No data is sent in this

* message, so the size of the message is simply the size of the message

* header. */

void setup_simp_reply(msg_xmt, msg_rcv)

msg_header_t *msg_xmt;

struct simp_msg_struct *msg_rcv;

{

msg_xmt->msg_remote_port = msg_rcv->h.msg_remote_port;

msg_xmt->msg_local_port = PORT_NULL;msg_xmt->msg_id = 0x12345678;

msg_xmt->msg_size = sizeof(msg_header_t);

msg_xmt->msg_type = MSG_TYPE_NORMAL;

msg_xmt->msg_simple = TRUE;

}

/* This procedure is used by the child to get the communication port.

* The child got the name as part of its inherited static variable space.

* Port rights, however, are not inherited across forks. env_get_port,

* a utility of the environment manager is called to return the port

* associated with the given name.

*/

port_t LookFor(name)

env_name_t name;

{

port_t result;


if ((error = env_get_port(environment_port, name, &result)) !=

KERN_SUCCESS) {

mach_error("CHILD: env_get_port returned ",error);

exit(1);

}

printf("CHILD: Successful env_get_port.\n");

return(result);

}

/* This routine is used by the parent to create a port, and to associate

the

* port name with the port via the environment manager.

* port_allocate is used to allocate a port, and then env_set_port is called

* passing the name of the port, and the newly allocated port. */

port_t Register(name)

env_name_t name;

{



29

port_t result;


if ((error = port_allocate(task_self(), &result)) != KERN_SUCCESS) {

mach_error("PARENT: port_allocate returned value of ", error);

exit(1);

}

if ((error = env_set_port(environment_port, name,result)) !=

KERN_SUCCESS) {

mach_error("PARENT: env_set_port returned value of ", error);

exit(1);

}

printf("PARENT: Successful env_set_port.\n");

return(result);

}

/* This routine is called to demonstrate the passing of a simple message.

* Please see program comment for order of events. */

void child_routine(my_port)

port_t my_port;{

msg_return_t ret;

int i;

struct simp_msg_struct msg_xmt, msg_rcv;

setup_simp_request(&msg_xmt, my_port);

if ((ret = msg_rpc(&msg_xmt.h,MSG_OPTION_NONE,sizeof(msg_xmt),0,0))

!= RPC_SUCCESS) {

mach_error("CHILD: msg_rpc returned value of ", ret);

exit(1);

}

printf("CHILD: Successful msg_rpc.\n");

}

void parent_routine(my_port)

port_t my_port;

{

msg_return_t ret;

int i;

int x;

msg_header_t msg_xmt;

struct simp_msg_struct msg_rcv;

msg_rcv.h.msg_local_port = my_port;

msg_rcv.h.msg_size = sizeof(msg_rcv);

if ((ret = msg_receive(&msg_rcv.h, MSG_OPTION_NONE, 0)) !=

RCV_SUCCESS) {

mach_error("PARENT: msg_receive returned value of ", ret);

exit(1);}

printf("PARENT: Successful msg_receive.\n");

printf("PARENT: Data..");

for (i = 0; i < MAXDATA; i++)

printf("%d ", msg_rcv.inline_data[i]);

printf("\n");

setup_simp_reply(&msg_xmt, &msg_rcv);

if ((ret = msg_send(&msg_xmt, MSG_OPTION_NONE, 0)) != SEND_SUCCESS){



30

mach_error("PARENT: msg_send returned value of ", ret);

exit(1);

}

printf("PARENT: Successful msg_send.\n");

}

main (argc, argv)

int argc;

char **argv;

{

kern_return_t err;

port_t my_port;

env_name_t port_name;

int fret;

if (argc > 1) {

printf("no arguments to simp_ipc\n");

exit(1);

}

/* create a port name that both the child and parent will know */sprintf(port_name, "ipc_test_%d", getpid());

/* create and register port for parent to receive on */

if ((my_port = Register(port_name)) == PORT_NULL)

exit(1);

/* fork returns 0 if child, and the child’s ID to the parent. */

fret = fork();

if (fret == 0) { /* child process */

if ((my_port = LookFor(port_name)) == PORT_NULL)

exit(1);

child_routine(my_port);

printf("CHILD: Finished successfully.\n");}

else if (fret >0) { /* parent process */

parent_routine(my_port);

if ((err = env_del_port(environment_port, port_name)) !=

KERN_SUCCESS) {

mach_error("PARENT: env_del_port returned ", err);

exit(1);

}

if ((err = port_deallocate(task_self(), my_port)) !=

KERN_SUCCESS) {

mach_error("PARENT: port_deallocate returned ", err);

exit(1);

}

printf("PARENT: Finished successfully.\n");}

else printf("Error from fork.\n");

}

Tugas 1 Sistem Operasi

Documents

Transcript of Tugas 1 Sistem Operasi