Sora Ciel│

Seperti yang kita ketahui, setiap process dilinux selalu ada Process ID atau yang biasa disebut PID. PID ini adalah berupa nomer atau suatu angka tertentu yang unik disetiap processnya. Jadi tidak ada process yang mempunyai PID yang sama.
PID berguna untuk menghentikan atau mengunci suatu process dari aplikasi atau service. Dengan PID ini kita bisa menghentikan atau kill suatu process dan juga bisa melakukan blocking process apabila aplikasi/service itu sudah running. Sehingga kita bisa membatasi suatu applikasi/service hanya berjalan dengan process yang kita tentukan ( tidak ada double process ). Dan juga masih banyak lagi kegunaan dari PID ini.
Dilinux, PID bisa kita lihat dengan menggunakan perintah "ps". Tapi perintah ps ini menampilkan semua proses pada linux. Jadi kita harus memfilter lagi output dari ps untuk mendapatkan PID dari service yang kita inginkan.
Ada beberapa cara yang bisa dilakukan untuk memfilter PID dari ps. Salah satunya dengan menggunakan "grep" dan "awk" untuk mendapatkan PID yang diinginkan.
Contohnya:
# ps -ef | grep -i "firefox" | grep -v grep | awk '{print $2}'
outputnya adalah PID number dari firefox.
Berikut adalah contoh script killing PID yang saya buat:
#!/bin/bash
#Ganti dengan nama aplikasi yang mau dikill
APP=firefox
CHECK=`ps -ef | grep -i "$APP" | grep -v grep | awk '{print $2}' | wc -l`
if [ $CHECK -eq 0 ]; then
echo "No Process"; exit
elif [ $CHECK -gt 1 ]; then
echo "Double name Process. Try again and be more specific."; exit
fi
PID=`ps -ef | grep -i "$APP" | grep -v grep | awk '{print $2}'`
echo "killing pid $PID"
kill $PID
exit 0

Dalam Unix dan sistem operasi multitasking lainnya, Jurik atau Demit (Inggris: daemon)
Dalam bahasa Indonesia sendiri, daemon berarti Jurik atau Demit atau kita bisa menyebutnya Hantu. Ya memang benar jika dilihat dari sifatnya, daemon adalah sebuah proses yang bekerja di background serta tidak memiliki interface pengontrol (proses yang tidak terlihat).
Dalam keluarga Windows, service memiliki konsep yang sama dengan daemon. Service berjalan sebagai sebuah proses, umumnya tidak berinteraksi dengan keyboard, monitor dan mouse, serta pada umumnya prosesnya dimulai pada saat booting. Daemon biasanya bekerja untuk jangka waktu yang sangat lama dan bertugas "mendengarkan" request dan menjalankan responsnya.
Daemon process sendiri di Sistem Operasi Symbian dikenal dengan nama process saja. Contohnya process alarmserver.exe yang bertugas sebagai alarm server, btserver.exe pengendali Bluetooth, UsbWatcher.exe dan usbsrv.exe untuk pengendali USB kabel, dan masih banyak lagi hantu-hantu yang berkeliaran.
Dalam paket penginstalan Python S60 sudah tersedia python_launcher.exe yang siap dijalankan sebagai Daemon dengan parameter yang ditunjukan ke path python script.

contoh penerapan daemon:

Soal: membuat program yg berjalan di belakang layar, dimana jika kita membuat file format txt yg namanya tdk mengandung angka akan di pecah jadi 3 di folder tertentu

#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <dirent.h>
#include <sys/param.h>
#include <time.h>
//-------fungsi untuk memeriksa apakah filename mengandung angka atau tidak---------//
int cek(char inp[]){
//printf("msk fungsi cek.... arr= %s\n",inp);
int jml=strlen(inp);
int i;
int flag=0;
for(i=0;i<jml;i++){
//printf("karakter skrg: %c\n",inp[i]);
if(inp[i]=='0'||inp[i]=='1'||inp[i] == '2'|| inp[i]=='3'|| inp[i]=='4'|| inp[i]=='5'|| inp[i]=='6'|| inp[i]=='7'|| inp[i]=='8'|| inp[i]=='9')
{
//printf("file ini mengandung angka\n");
flag=1;
break;
}
}
if (flag==1) return 1;
else return 0;
}

//-----------------------------------------------------------------------------------//

            FILE* file[3]; //--deklarasi var file yg nanti jadi 3--//
        FILE* edit;    //--deklarasi var file utama--//
        FILE* loga;    //--deklarasi var file log--//

//-------------------fungsi utama---------------------------------------------------//
int walker() {
DIR           *d;
struct dirent *dir;
d = opendir( "." );

//loga=fopen("log","w+");

if( d == NULL ) {
    return 1;
}

while( ( dir = readdir( d ) ) ) {   //mulai membaca direktori

//   printf("FILE/folder skrg: %s\n",dir->d_name);
    if( strcmp( dir->d_name, "." ) == 0 ||
        strcmp( dir->d_name, ".." ) == 0 ) {
      continue;
    }
    if( dir->d_type == DT_DIR ) { //jika folder maka akan ditelusuri
//       printf("pndh dir\n");
      chdir( dir->d_name );
      walker( );
      chdir( ".." );
    } else {
    char arr[100];
    char arr2[100];
       strcpy(arr2,dir->d_name);
//puts("mau di cek");

//cek apa dia berformat txt atau tidak
int format=strlen(arr2);
//printf("format: %c%c%c%c\n",arr2[format-4],arr2[format-3],arr2[format-2],arr2[format-1]);

//printf("file yg diperiksa %s\n",arr2);

    int tes;
    tes= cek(arr2);
    if(tes==1); //printf("mengandung angka: %s\n",arr2);

    else {

//------memeriksa apakah format file txt atau bukan--------------//
        if(arr2[format-4]=='.'&& arr2[format-3]=='t' && arr2[format-2]=='x' && arr2[format-1]=='t' ){
    int cop;
    for(cop=0;cop<format-4;cop++){           //jika benar maka nama file akan diambil utk dijadikan nama
//   puts("masuk cop");               //pada 3 file yg baru
    arr[cop]=arr2[cop];
    }
//   printf("file yg akan dipecah %s\n",arr);

//--------------------------------------------------------------//
           char tampung[100];
           char tmp[100];
           edit=fopen(arr2,"r"); //file utama dibuka

//----------make log file----------------//

    loga=fopen("/home/nuning/TES/log","a");
    fprintf(loga,"%s       ",arr2);

    struct tm *sTm;
    char buff[20];
    time_t now = time (0);
    sTm = localtime (&now);

    strftime (buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", sTm);
    fprintf (loga,"%s\n", buff);

//-------------------------------------//

//-----------------------proses penamaan 3 file----------------------------//

            snprintf(tampung, sizeof(char) * 100, "%s_1.txt", arr);
            file[0] = fopen(tampung, "w+");
       memset(tampung,0,sizeof(tampung));
       snprintf(tampung, sizeof(char) * 100, "%s_2.txt", arr);
             file[1] = fopen(tampung, "w+");
       memset(tampung,0,sizeof(tampung));
            snprintf(tampung, sizeof(char) * 100, "%s_3.txt", arr);
            file[2] = fopen(tampung, "w+");
       memset(tampung,0,sizeof(tampung));
//------------------------------------------------------------------------//

//----proses penyalinan--------//
int i=0;
while(fgets(tmp,100,edit) != NULL){
//printf("pemindahan\n");
fprintf(file[i % 3],"%s",tmp);
i++;

}
//----------------------------//
//puts("done");

        //menutup kembali file
        fclose(file[0]);
        fclose(file[1]);
        fclose(file[2]);
fclose(loga);
        fclose(edit);
        remove(arr2);
        //-----------------------
}


}

}

}

closedir( d ); //menutup direktori
}

int main ()
{
    //------------Daemon------------------//
    pid_t pid, ppid, sid;
    pid=fork();

    if(pid == 0){
//       printf("--%d\n", getpid());
}

    if(pid > 0){
//       printf("--%d\n", getpid());
       exit(EXIT_SUCCESS);}

    //------------------------------------//

while(1)
    {
chdir ("/home/nuning/TES");

walker();
sleep(30);
       umask(0);
    }
}

IPC

IPC (Inter-Process Communication) adalah komunikasi antar proses untuk mengirim data dari satu proses ke proses yang lain, baik antar proses dalam satu komputer maupun proses-proses dalam komputer yang berbeda. IPC dapat dilakukan dengan berbagai cara yaitu Shared memory, Pipe, Messages passing, dan sebagainya. Berikut penjelasan mengenai cara-cara tersebut.

a. Shared memory

Sistem Berbagi Memori atau yang disebut juga sebagai Shared Memory System merupakan salah satu cara komunikasi antar proses dengan cara mengalokasikan suatu alamat memori untuk dipakai berkomunikasi antar proses. Alamat dan besar alokasi memori yang digunakan biasanya ditentukan oleh pembuat program. Pada metode ini, sistem akan mengatur proses mana yang akan memakai memori pada waktu tertentu sehingga pekerjaan dapat dilakukan secara efektif.

b. Pipe

Pipe merupakan komunikasi sequensial antar proses yang saling terelasi, namun pipe memiliki kelemahan yaitu hanya bisa digunakan untuk komunikasi antar proses yang saling berhubungan, dan komunikasinya yang dilakukan adalah secara sequensial. Urutan informasi yang ada dalam sebuah pipe ada yang mirip dengan antrian queue. Jika komunikasi yang diinginkan adalah komunikasi dua arah maka kita harus membuat dua pipe, karena sebuah pipe hanya bisa digunakan untuk komunikasi satu arah saja.

c. Messages passing

Sistem berkirim pesan adalah proses komunikasi antar bagian sistem untuk membagi variabel yang dibutuhkan. Proses ini menyediakan dua operasi yaitu mengirim pesan dan menerima pesan. Ketika dua bagian sistem ingin berkomunikasi satu sama lain, yang harus dilakukan pertama kali adalah membuat sebuah link komunikasi antara keduanya. Setelah itu, kedua bagian itu dapat saling bertukar pesan melalui link komunikasi tersebut. Sistem berkirim pesan sangat penting dalam sistem operasi. Karena dapat diimplementasikan dalam banyak hal seperti pembagian memori, pembagian bus, dan melaksanakan proses yang membutuhkan pengerjaan bersama antara beberapa bagian sistem operasi. Terdapat dua macam cara berkomunikasi, yaitu:

1. Komunikasi langsung

Setiap proses yang ingin berkomunikasi harus memiliki nama yang bersifat eksplisit baik penerimaan atau pengirim dari komunikasi tersebut. Dalam konteks ini, pengiriman dan penerimaan pesan secara primitive dapat dijabarkan sebagai :

Send (P, message) – mengirim sebuah pesan ke proses P.
Receive (Q, message) – menerima sebuah pesan dari proses Q.

Sebuah jaringan komunikasi pada bahasan ini memiliki beberapa sifat, yaitu:

Sebuah jaringan yang didirikan secara otomatis diantara setiap pasang dari proses yang ingin dikomunikasikan. Proses tersebut harus mengetahui identitas dari semua yang ingin dikomunikasikan.
Sebuah jaringan adalah terdiri dari penggabungan dua proses.
Diantara setiap pesan dari proses terdapat tepat sebuah jaringan.

Pembahasan ini memperlihatkan sebuah cara simetris dalam pemberian alamat. Oleh karena itu, baik keduanya yaitu pengirim dan penerima proses harus memberi nama bagi yang lain untuk berkomunikasi, hanya pengirim yang memberikan nama bagi penerima sedangkan penerima tidak menyediakan nama bagi pengirim. Dalam konteks ini, pengirim dan penerima secara sederhana dapat dijabarkan sebagai berikut:

Send (P, message) – mengirim sebuah pesan kepada proses P.
Receive (id, message) – menerima sebuah pesan dari semua proses. Variabel id diatur sebagai nama dari proses dengan komunikasi.

2. Komunikasi tidak langsung

Dengan komunikasi tidak langsung, pesan akan dikirimkan pada dan diterima dari/ melalui mailbox (kotak surat) atau terminal-terminal, sebuah mailbox dapat dilihat secara abstrak sebagai sebuah objek didalam setiap pesan yang dapat ditempatkan dari proses dan dari setiap pesan yang bias dipindahkan. Setiap kotak surat memiliki sebuah identifikasi (identitas) yang unik, sebuah proses dapat berkomunikasi dengan beberapa proses lain melalui sebuah nomor dari mailbox yang berbeda.

Dua proses dapat saling berkomunikasi apabila kedua proses tersebut sharing mailbox. Pengirim dan penerima dapat dijabarkan sebagai :

Send (A, message) – mengirim pesan ke mailbox A.
Receive (A, message) – menerima pesan dari mailbox A.

Dalam masalah ini, link komunikasi mempunyai sifat sebagai berikut :

Sebuah link dibangun diantara sepasang proses dimana kedua proses tersebut membagi mailbox.
Sebuah link mungkin dapat berasosiasi dengan lebih dari dua proses.
Diantara setiap pasang proses komunikasi, mungkin terdapat link yang berbeda-beda, dimana setiap link berhubungan pada satu mailbox.

Misalkan terdapat proses P1, P2 dan P3 yang semuanya share mailbox. Proses P1 mengirim pesan ke A, ketika P2 dan P3 masing-masing mengeksekusi sebuah kiriman dari A. Proses mana yang akan menerima pesan yang dikirim P1? Jawabannya tergantung dari jalur yang kita pilih :

Mengizinkan sebuah link berasosiasi dengan paling banyak 2 proses.
Mengizinkan paling banyak satu proses pada suatu waktu untuk mengeksekusi hasil kiriman (receive operation).
Mengizinkan sistem untuk memilih secara mutlak proses mana yang akan menerima pesan (apakah itu P2 atau P3 tetapi tidak keduanya, tidak akan menerima pesan). Sistem mungkin mengidentifikasi penerima kepada pengirim.

Mailbox mungkin dapat dimiliki oleh sebuah proses atau sistem operasi. Jika mailbox dimiliki oleh proses, maka kita mendefinisikan antara pemilik (yang hanya dapat menerima pesan melalui mailbox) dan pengguna dari mailbox (yang hanya dapat mengirim pesan ke mailbox).

Selama setiap mailbox mempunyai kepemilikan yang unik, maka tidak akan ada kebingungan tentang siapa yang harus menerima pesan dari mailbox. Ketika proses yang memiliki mailbox tersebut diterminasi, mailbox akan hilang. Semua proses yang mengirim pesan ke mailbox ini diberi pesan bahwa mailbox tersebut tidak lagi ada. Dengan kata lain, mempunyai mailbox sendiri yang independent, dan tidak melibatkan proses yang lain. Maka sistem operasi harus memiliki mekanisme yang mengizinkan proses untuk melakukan hal-hal dibawah ini:

Membuat mailbox baru.
Mengirim dan menerima pesan melalui mailbox.
Menghapus mailbox.

Proses yang membuat mailbox pertama kali secara default akan memiliki mailbox tersebut. Untuk pertama

Sora Ciel│

Pages

Rabu, 12 November 2014

tentang multithreading

Senin, 03 November 2014

PID

Minggu, 02 November 2014

Tentang Daemon dan IPC

IPC

Follower Blogger Community