FUSE

      Fuse (file system in userspace) merupakan sebuah kerangka sistem berkas pada area pengguna. terdiri dari sebuah modul kernel , sebuah pustaka pada area pengguna, dan sebuah utilitas untuk melakukan proses mount (fusermount). Salah satu keistimewaan FUSE yang paling utama adalah diizikannya proses mount oleh pengguna biasa yang aman. hal ini memberikan kemungkinan baru untuk menggunakan file system.

      Untuk instalasi FUSE, Anda dapat mengikuti langkah-langkah berikut :

• Download fuse dari http://fuse.sourceforge.net/ pada bagian Download stable release
• Extract file yang sudah didownload.
• Lakukan instalasi fuse, buka terminal lebih dahulu kemudian lakukan perintah dibawah ini:

             1. Gunakan hak akses super user (sudo su)
             2. Ketikkan perintah ./configure
             3. Ketikkan perintah make
             4. Ketikkan perintah make install

• Fuse siap digunakan

Berikut adalah source code FUSE dalam bahasa C/C++

#ifdef linux

#define _XOPEN_SOURCE 500

#endif

#include <fuse.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

#include <dirent.h>

#include <errno.h>

#include <sys/statfs.h>

char *direction={"/home/demsy/mas_Adhipur"}; //folder sumber

static int xmp_getattr(const char *path, struct stat *stbuf)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,pathcdcd);

    int res;

    res = lstat(i, stbuf);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_readlink(const char *path, char *buf, size_t size)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = readlink(i, buf, size - 1);

    if(res == -1)

        return -errno;

    buf[res] = '\0';

    return 0;

}

static int xmp_getdir(const char *path, fuse_dirh_t h, fuse_dirfil_t filler)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    DIR *dp;

    struct dirent *de;

    int res = 0;

    dp = opendir(i);

    if(dp == NULL)

        return -errno;

    while((de = readdir(dp)) != NULL) {

        res = filler(h, de->d_name, de->d_type);

        if(res != 0)

            break;

    }

    closedir(dp);

    return res;

}

static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = mknod(i, mode, rdev);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_mkdir(const char *path, mode_t mode)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = mkdir(i, mode);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_unlink(const char *path)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = unlink(i);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_rmdir(const char *path)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = rmdir(i);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_symlink(const char *from, const char *to)

{

    int res;

    res = symlink(from, to);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_rename(const char *from, const char *to)

{

    int res;

    res = rename(from, to);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_link(const char *from, const char *to)

{

    int res;

    res = link(from, to);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_chmod(const char *path, mode_t mode)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = chmod(i, mode);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_chown(const char *path, uid_t uid, gid_t gid)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = lchown(i, uid, gid);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_truncate(const char *path, off_t size)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = truncate(i, size);

    if(res == -1)

        return -errno;

    return 0;

}

static int xmp_utime(const char *path, struct utimbuf *buf)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = utime(i, buf);

    if(res == -1)

    return -errno;

    return 0;

}

static int xmp_open(const char *path, int flags)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int res;

    res = open(i, flags);

    if(res == -1)

        return -errno;

    close(res);

    return 0;

}

static int xmp_read(const char *path, char *buf, size_t size, off_t offset)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int fd;

    int res;

    fd = open(i, O_RDONLY);

    if(fd == -1)

        return -errno;

    res = pread(fd, buf, size, offset);

    if(res == -1)

        res = -errno;

    close(fd);

    return res;

}

static int xmp_write(const char *path, const char *buf, size_t size,

                     off_t offset)

{

    char i[2000];

    strcpy(i,direction);

    strcat(i,path);

    int fd;

    int res;

    fd = open(i, O_WRONLY);

    if(fd == -1)

        return -errno;

    res = pwrite(fd, buf, size, offset);

    if(res == -1)

        res = -errno;

    close(fd);

    return res;

}

static int xmp_statfs(struct fuse_statfs *fst)

{

    struct statfs st;

    int rv = statfs("/",&st);

    if(!rv) {

    fst->block_size  = st.f_bsize;

    fst->blocks      = st.f_blocks;

    fst->blocks_free = st.f_bavail;

    fst->files       = st.f_files;

    fst->files_free  = st.f_ffree;

    fst->namelen     = st.f_namelen;

    }

    return rv;

}

static int xmp_release(const char *path, int flags)

{

     Just a stub.  This method is optional and can safely be left

       unimplemented

    (void) path;

    (void) flags;

    return 0;

}

static int xmp_fsync(const char *path, int isdatasync)

{

    Just a stub.  This method is optional and can safely be left

       unimplemented

    (void) path;

    (void) isdatasync;

    return 0;

}

static struct fuse_operations xmp_oper = {

    .getattr = xmp_getattr,

    .readlink = xmp_readlink,

    .getdir = xmp_getdir,

    .mknod = xmp_mknod,

    .mkdir = xmp_mkdir,

    .symlink = xmp_symlink,

    .unlink = xmp_unlink,

    .rmdir = xmp_rmdir,

    .rename = xmp_rename,

    .link = xmp_link,

    .chmod = xmp_chmod,

    .chown = xmp_chown,

    .truncate = xmp_truncate,

    .utime = xmp_utime,

    .open = xmp_open,

    .read = xmp_read,

    .write = xmp_write,

    .statfs = xmp_statfs,

    .release = xmp_release,

    .fsync = xmp_fsync

};

int main(int argc, char *argv[])

{

    fuse_main(argc, argv, &xmp_oper);

    return 0;

}

PENJELASAN FUNGSI

getattr: int (* getattr) (const char *, struct Stat *);

     Mirip dengan stat (). st_ino dan st_blksize diabaikan.  st_ino diabaikan kecuali opsi use_ino mount  diberikan.

readlink: int (* readlink) (const char *, char *, size_t);

     Membaca target link simbolik. 

getdir: int (* getdir) (const char *, fuse_dirh_t, fuse_dirfil_t);

     Membaca isi dari sebuah direktori. Operasi ini adalah opendir (), readdir (), ..., closedir () urut dalam satu panggilan.

mknod: int (* mknod) (const char *, mode_t, dev_t);

     Hal ini menciptakan node berkas. mknod () akan dipanggil untuk penciptaan semua node non-direktori, non-symlink.

mkdir: int (* mkdir) (const char *, mode_t);

rmdir: int (* rmdir) (const char *);

    Membuat dan menghapus direktori, masing-masing.

unlink: int (* unlink) (const char *);

rename: int (* rename) (const char *, const char *);

     Menghapus dan mengganti nama file.

symlink: int (* symlink) (const char *, const char *);

     Menciptakan link simbolik.

link: int (* link) (const char *, const char *);

     Menciptakan hard link ke file.

chmod: int (* chmod) (const char *, mode_t);

chown: int (* chown) (const char *, uid_t, gid_t);

truncate: int (* truncate) (const char *, off_t);

utime: int (* utime) (const char *, struct utimbuf *);

     Mengubah bit izin, pemilik kelompok, ukuran, dan waktu akses / modifikasi file.

open: int (* open) (const char *, struct fuse_file_info *);

     Operasi membuka file. 

read: int (* read) (const char *, char *, size_t, off_t, struct fuse_file_info *);

     Membaca data dari file yang terbuka. 

write: int (* write) (const char *, const char *, size_t, off_t, struct fuse_file_info *);

     Menulis data ke file yang dibuka.

statfs: int (* statfs) (const char *, statfs struct *);

     Mendapatkan statistik filesystem.

flush: int (* flush) (const char *, struct fuse_file_info *);

     Merupakan data flush-cached. Tidak sama dengan fsync () 

release: int (* release) (const char *, struct fuse_file_info *);

     Melepaskan file yang terbuka. release () dipanggil ketika tidak ada lagi referensi ke file yang terbuka 

fsync: int (* fsync) (const char *, int, struct fuse_file_info *);

     Mensinkronisasikan isi file. 

Read More

About Linux File System

     File system merupakan database khusus untuk penyimpanan, pengelolaan, manipulasi dan pengambilan data, agar mudah ditemukan dan diakses. File System memiliki dua bagian:

1. Kumpulan file yang masing-masingnya menyimpan data-data yang berhubungan.
2. Struktur direktori yang mengorganisasi dan menyediakan informasi mengenai seluruh file dalam sistem.

     File system merupakan interface yang menghubungkan sistem operasi dengan disk. Ketika program menginginkan pembacaan dari harddisk atau media penyimpanan lainnya, sistem operasi akan meminta file system untuk membuka file yang diminta tersebut. File system akan mencari lokasi dari file yang diinginkan. Setelah file itu ditemukan, file system akan membaca file tersebut kemudian mengirimkan informasinya kepada sistem operasi dan akhirnya bisa dibaca oleh kita.

     Berikut adalah file system yang ada di Linux

1. Ext2 – Second Extended File System 2

• Deskripsi dan Tujuan:

               Ext2 pertama kali dikembangkan dan diintegrasikan pada kernel Linux, dan sekarang ini                 sedang dikembangkan juga penggunaannya pada sistem operasi lainnya.

              Tujuannya adalah untuk membuat suatu file system yang powerful, yang dapat                                 mengimplementasikan file-file semantik dari UNIX dan mempunyai pelayanan advance                       features.

• Kemampuan:

1. File system Ext2 mampu menyokong beberapa tipe file yang standar dari UNIX, seperti regular file, directories, device special files, dan symbolic links.
2. Ext2 mampu mengatur file-file system yang dibuat dalam partisi yang besar.
3. File system Ext2 mampu menghasilkan nama-nama file yang panjang. Maximum 255 karakter.
4. Ext2 memerlukan beberapa blok untuk super user (root).

      2. Ext3 – Third Extended File System

• Deskripsi dan Tujuan:

              Ext3 merupakan suatu journalled file system, journalled file system didesain untuk                          membantu melindungi data yang ada di dalamnya. Dengan adanya journalled filesystem, maka            kita tidak perlu lagi untuk melakukan pengecekan kekonsistensian data, yang akan memakan              waktu sangat lama bagi harddisk yang berkapasitas besar.

              Ext3 adalah suatu filesystem yang dikembangkan untuk digunakan pada sistem operasi                   Linux. Ext3 merupakan hasil perbaikan dari Ext2 ke dalam bentuk Ext2 yang lebih baik dengan          menambahkan berbagai macam keunggulan.

• Kelebihan:

1. Ext3 tidak mendukung proses pengecekan file system, bahkan ketika system yang belum dibersihkan mengalami “shutdown”, kecuali pada beberapa kesalahan hardware yang sangat jarang.
2. Hal seperti ini terjadi karena data ditulis atau disimpan ke dalam disk dalam suatu cara sehingga file system-nya selalu konsisten.
3. Waktu yang diperlukan untuk me-recover Ext3 file system setelah system yang belum dibersihkan dimatikan
4. Tidak tergantung dari ukuran file system atau jumlah file; tetapi tergantung kepada ukuran “jurnal” yang digunakan untuk memelihara konsistensi. Jurnal dengan ukuran awal (default)
5. Membutuhkan sekitar 1 sekon untuk recover (tergantung dari kecepatan hardware).

     3. Ext4 – Fourth Extended File System

• Deskripsi dan Tujuan

              Ext4 dirilis secara komplit dan stabil berawal dari kernel 2.6.28 jadi apabila distro anda yang          secara default memiliki versi kernel tersebuat atau di atas nya otomatis system anda sudah                  support Ext4 (dengan catatan sudah di include kedalam kernelnya) selain itu versi e2fsprogs                harus mengunakan versi 1.41.5 atau lebih.

• Kelebihan:

1. Telah dinyatakan stabil dan didukung sejak kernel linux 2.6.28.
2. Didesign untuk memberikan performance yang lebih baik dan peningkatan kemampuan.
3. Dapat meningkatkan daya tampung maksimal filesystem ke 1 Exa Byte (1,048,576 Tera Byte), dengan ukuran maksimum filesystem dengan 16 TB untuk maksimum file size nya, Fast fsck, Journal checksumming, Defragmentation support.
4. Mengurangi waktu yang diperlukan untuk melakukan pengecekan hardisk (fsck yang mana pada Filesystem Ext3, setiap 20­30 kali mount).
5. Berdasarkan test benchmark yang dilakukan oleh beberapa benchmarker, Filesystem Ext4 memiliki keunggulan performance yang significant dalam menulis dan membaca file berukuran besar.
6. Filesystem Ext4 menyisihkan filesystem lain seperti xfs, jfs, Reiserfs dan Ext3. Dalam kasus Ubuntu 9.04, filesystem Ext4 di curigai sebagai faktor utama yang mempercepat waktu boot Ubuntu 9.04. Filesystem Ext4 juga meningkatkan umur hidup media flash seperti SSD. Karena filesystem Ext4 tidak melakukan penulisan data layaknya Filesystem Ext3 yang menulis beberapa kali.

      4. JFS
  
                          JFS adalah IBM Journal FileSystem- Merupakan filesystem pertama yang menawarkan                    journaling. JFS sudah bertahun-tahun digunakan dalam IBM AIX ® OS sebelum digunakan ke            GNU / Linux. JFS saat ini menggunakan sumber daya CPU paling sedikit dibandingkan                      filesystem GNU / Linux yang lain. Sangat cepat di format, mounting dan fsck, dan memiliki                kinerja sangat baik, terutama berkaitan dengan deadline I / O scheduler. (Lihat JFS.) Tidak                  didukung seluas ext atau ReiserFS, tapi sangat matang dan stabil.

Read More

Shared Memory

     Shared memory adalah memori yang dapat diakses secara bersamaan oleh beberapa program  dengan maksud untuk menyediakan komunikasi di antara mereka atau menghindari salinan yang berlebihan. Tergantung pada konteks, program dapat berjalan pada satu prosesor atau beberapa prosesor yang terpisah.     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.

     Ada 2 cara untuk menggunakan shared memory, yaitu :

• Menggunakan mmap()
• Menggunakan shmget() -> lebih populer

Langkah - langkah membuat shared memory :

1. Membuat segment di memory dengan shmget() 
2. Mendaftarkan (attach) segment ke data space dari proses dengan shmat() 
3. Tulis/Baca dari memori 
4. Detach segment dari data space dari proses dengan shmdt()

Penjelasan fungsi :

1. shmget();

          System call untuk membuat suatu segmen shared memory

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg); 

          shmflg bisa diisi dengan : IPC_CREATE, IPC_EXCL, permission

2. shmat();

           System call untuk mendaftarkan segment shared memory ke dalam data space dari suatu proses

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg); 

Parameter :
shmid → ID dari shared memory
shmaddr → Lokasi shared memory di main memory
jika NULL akan dicarikan lokasi pada memory yang ingin ditempati 

Return :
Pointer ke lokasi shared memory

3. shmdt();

            System call untuk melepaskan shared memory segment dari data space dari proses.

#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr); 

Parameter :
shmaddr → pointer ke lokasi shared memory 

Return :
0 → sukses
(void *) -1 → error

4. shmctl();

           System call untuk mengetahui atau merubah informasi yang berkaitan dgn suatu shared memory

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

Argument cmd bisa berisi : 

IPC_STAT : mengambil informasi ttg shared memory segment
IPC_SET : mengubah informasi ttg shared memory segment
IPC_RMID : menandai suatu segment untuk dibuang ketika semua process yang menggunakannya sudah melepasnya
SHM_LOCK : Lock suatu segment, membuatnya tidak bisa di-swap
SHM_UNLOCK : Unlock suatu segment

Program Tambahan untuk IPC

     Ada 2 program tambahan yang berguna untuk melihat apa yang terjadi pada IPC yang dibuat :

1. ipcs
   Menyediakan informasi yang berkaitan dengan IPC yang sedang digunakan (message queue, shared memory, semaphore)
2. ipcrm
   Menghapus IPC tertentu (message queue, shared memory, semaphore)

Read More

Deadlock

     Deadlock adalah keadaan di mana dua atau lebih proses tidak dapat berjalan karena saling menunggu resources dari yang lainnya.

     Deadlock mungkin terjadi karena :

• Mutual Exclusion : Hanya satu proses yang dapat menggunakan sumber daya pada satu kali waktu.
• Hold-and-wait : Suatu proses dapat menahan sumber daya yang dialokasikan sambil menunggu sumber daya lainnya dapat dipakai.
• No preemption : Tidak ada sumber daya yang dapat dilepaskan dari proses yang sedang menggunakannya.

     Sedangkan penyebab deadlock adalah :

1. Circular wait 

          Circular wait adalah situasi di mana dua atau lebih proses saling menunggu hasil output dari masing - masing proses. Misal P1 menunggu data dari P2 sedangkan P2 juga menunggu data dari P1. Maka dari itu semua proses tidak bisa berjalan.

Pencegahan Deadlock

• Pada Mutual Exclusion  

          Exclusive access hanya untuk write saja, proses-proses lain tetap bisa read

• Pada Hold and Wait 

          Semua resource yang dibutuhkan diminta sejak awal

• Pada No Preemption 

          Proses melepaskan resource dan nanti memintanya kembali

• Pada Circular Wait 

          Membuat urutan pengaksesan resource

Read More