File System dan Kamar yang Berantakan

2:08 AM Dika 0 Comments

FUSE! Iya, keren. Walaupun terdengar seperti ada yang akan bergabung dan membentuk sebuah kekuatan baru, namun kenyataannya tidak begitu. FUSE dalam konteks sistem operasi Linux merupakan sebuah file system. Filesystem in Userspace.

Apa sih File System itu?
Jadi simpelnya (semoga beneran simpel) begini, kalian tentu pernah buka windows explorer kan? Atau mungkin ada yang pernah membuka aplikasi penelusur file di sistem operasi lain? Nah jadi si windows explorer yang kalian lihat itu tentu ada yang namanya folder dan file, seolah-olah di komputer kamu ada beberapa tumpukan dokumen (file) yang dikumpulkan dalam sebuah laci (file). Kalau kamu butuh dokumennya, tinggal cari laci tempat dimana kamu menaruh dokumen tersebut. Namun tahu kah kalian? Kalau file dan folder yang kamu lihat itu hanyalah ilusi belaka? Kebetulan? Saya rasa tidak!


File dan folder yang kalian lihat di depan layar komputer itu sebenarnya hanyalah penampilan luar dari apa yang sebenarnya terjadi di dalam komputer kita. Kalau kamu adalah seseorang yang rapi, kamu pasti sangat telaten dalam mengelompokkan file dalam folder-folder tertentu, sehingga terlihat rapi. Namun tahukah kamu? Serapi apa pun kalian menata file dan folder di komputermu, sebenarnya dalam hardisk/flashdisk/CD tempat kalian menaruh file dan folder, posisi "asli"nya tetap lah "berantakan". Namun jangan khawatir, komputer tidak akan "lupa" posisi dimana dia menaruh data-data kalian. Hal ini karena adanya File System.


Ibaratnya sebuah kamar. Anggap sebuah ruangan kamar adalah harddisk pada komputer kita. Dan barang-barang di dalam kamar adalah file dan folder. Karena komputer tidak punya otak yang secemerlang manusia, komputer tidak lah bisa caranya merapikan kamarnya sendiri. Barang apapun yang masuk ke kamarnya, akan ditaruh berjejer begitu saja. Pokoknya asal muat, masukin aja. Alhasil kamarnya sudah dipenuhi berbagai macam barang yang sangat tidak teratur. Ada lemari di atas televisi, gunting di bawah tempat tidur, bahkan kolor tergantung di langit-langit. Nah kerennya, separah apapun si komputer menaruh barangnya, dia akan selalu ingat posisi barangnya saat dia membutuhkan. Dan juga seperti apapun bentuknya, misalnya lemari kotak atau segitiga atau lingkaran, komputer akan tetap mengenali benda itu sebagai lemari. Kenapa? Karena komputer punya sebuah catatan yang sangat lengkap tentang seluruh keberadaan barangnya, catatan itu adalah File System. Setiap ada barang baru masuk, akan dicatat di File System.

Oh gitu!


Yak, dan file system itu ada banyak macamnya. Apalagi file system untuk linux, banyak orang yang membuat file system untuk sistem operasi open-source itu. Salah satu yang populer adalah FUSE. Untuk informasi dan dokumentasi yang lengkap, teman-teman bisa mengunjungi website developernya langsung di http://fuse.sourceforge.net/.

Kenapa saya menyarankan FUSE?

• Librarynya lebih simpel
• Instalasi lebih simpel
• Aman
• Sangat efisien untuk pengguna
• Bahkan untuk pengguna tanpa kemampuan teknis yang tinggi
• Bisa dijalankan di Linux kernel 2.4.x dan 2.6.x
• Dan yang terpenting, stabil bos!

/*
    FUSE: Filesystem in Userspace
    Copyright (C) 2001  Miklos Szeredi (mszeredi@inf.bme.hu)
    This program can be distributed under the terms of the GNU GPL.
    See the file COPYING.
*/
#ifdef linux
/* For pread()/pwrite() */
#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>
static const char *dirpath = "/home/wira";
static int xmp_getattr(const char *path, struct stat *stbuf)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = lstat(fpath, stbuf);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_readlink(const char *path, char *buf, size_t size)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = readlink(fpath, 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)
{
    DIR *dp;
    struct dirent *de;
    int res = 0;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    dp = opendir(fpath);
    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)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = mknod(fpath, mode, rdev);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_mkdir(const char *path, mode_t mode)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = mkdir(fpath, mode);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_unlink(const char *path)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = unlink(fpath);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_rmdir(const char *path)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = rmdir(fpath);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_symlink(const char *from, const char *to)
{
    int res;
char fpath [1000], ffrom[1000],fto[1000];
sprintf(fto,"%s%s",dirpath,to);
sprintf(ffrom,"%s%s",dirpath,from);
    res = symlink(ffrom, fto);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_rename(const char *from, const char *to)
{
    int res;
char fpath [1000], ffrom[1000],fto[1000];
sprintf(fto,"%s%s",dirpath,to);
sprintf(ffrom,"%s%s",dirpath,from);
    res = rename(ffrom, fto);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_link(const char *from, const char *to)
{
    int res;
char fpath [1000], ffrom[1000],fto[1000];
sprintf(fto,"%s%s",dirpath,to);
sprintf(ffrom,"%s%s",dirpath,from);
    res = link(ffrom, fto);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_chmod(const char *path, mode_t mode)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = chmod(fpath, mode);
    if(res == -1)
        return -errno;
   
    return 0;
}
static int xmp_chown(const char *path, uid_t uid, gid_t gid)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = lchown(fpath, uid, gid);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_truncate(const char *path, off_t size)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);  
    res = truncate(fpath, size);
    if(res == -1)
        return -errno;
    return 0;
}
static int xmp_utime(const char *path, struct utimbuf *buf)
{
    int res;
   
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = utime(fpath, buf);
    if(res == -1)
        return -errno;
    return 0;
}

static int xmp_open(const char *path, int flags)
{
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    res = open(fpath, 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)
{
    int fd;
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    fd = open(fpath, 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)
{
    int fd;
    int res;
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    fd = open(fpath, 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_release(const char *path, int flags)
{
    /* Just a stub.  This method is optional and can safely be left
       unimplemented */
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    (void) fpath;
    (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 */
char fpath [1000];
sprintf(fpath,"%s%s",dirpath,path);
    (void) fpath;
    (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,
    .release = xmp_release,
    .fsync = xmp_fsync
   
};
int main(int argc, char *argv[])
{
    fuse_main(argc, argv, &xmp_oper);
    return 0;
}

Untuk variabel dirpath, kalian bisa ganti sesuka kalian. Sesuaikan dengan path pada linux kalian masing-masing ya. Setelah selesai dengan source code, save file dan compile dengan syntax gcc -Wall [nama file].c `pkg-config fuse --cflags --libs` -o [nama file].

Kemudian jalankan dengan perintah ./[nama file] /tmp/fuse

Apa yang terjadi? Maka seluruh isi dari direktori pada variabel dirpath di atas, akan dimuat ke folder /tmp/fuse. Untuk mengecek, kalian bisa masuk ke folder tmp (melalui root), kemudian buka folder fuse.


Sekian cuap-cuap saya kali ini. Semoga saya tidak tambah sotoy, dan semoga ilmunya bermanfaat.