FUSE FUSE

Halo kawan kawan sekalian, kali ini saya akan membagikan pengetahuan tentang FUSE.

FUSE ( Filesystem in userspace ) adalah suatu mekanisme sistem operasi untuk meng-export filesistem yang bersifat virtual kedalam kernel Linux.

Fuse memiliki fungsi seperti
- Library API yang simpel
- Mudah diinstal
- Bisa dipakai oleh semua user baik root maupun bukan.
- Efisien dan stabil

Bagaimana cara kerjanya?
FUSE kernel modul dan FUSE library akan berkomunikasi dengan pendeskriptor spesial yang bisa didapatkan dengan  membuka /dev/fuse. File ini dapat dibuka berulang kali dan pendeskriptor akan dimasukkan ke mount syscall.

Langsung aja ya aku kasih kodingannya....

#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/ncc/Documents";

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_getdir(const char *path, fuse_dirh_t h, fuse_dirfil_t filler)
{
 char fpath[1000];
 if(strcmp(path,"/") == 0)
 {
  path=dirpath;
  sprintf(fpath,"%s",path);
 }
 else sprintf(fpath, "%s%s",dirpath,path);
 int res = 0;
 DIR *dp;
 struct dirent *de;
 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 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,
 //.readdir = hello_readdir
};

int main(int argc, char *argv[])
{
 return fuse_main(argc, argv, &xmp_oper);
}

Itu dia kodingannya. Kodingan diatas hanya sebuah cara untuk mengetes FUSE anda. Selamat mencoba!

Tentang Thread, Thblue, dan Kehidupan

Oke, thblue itu gak ada. Saya ngarang itu, maaf.

Kali ini akan dijelaskan sekali lagi oleh saya mengenai Thread. Apa itu Thread?
Jika Proses diidentifikasi dengan prosess id atau PID, maka Thread diidentifikasi dengan TID atau Thread ID. Jadi kalo  thread dan proses digabung, mungkin akan menjadi TIPI. Wow.


Thread adalah suatu bagian kecil dari proses yang dijadwalkan oleh operasi. Jadi dalam artian, pada setiap proses, bisa terdapat banyak thread, dan threadnya pun bermacam macam.
Dalam suatu proses, biasanya ada dua macam thread, yaitu:
a. Single Thread : Dalam satu proses hanya punya satu thread.
b. Multi Thread : Dalam satu proses punya dua atau lebih thread. Hal ini membuat proses lebih cepat menjalankan programnya nanti.

Nah....
Dalam linux, perintah untuk membuat suatu thread direpresentasikan dengan perintah "pthread_t".
Algoritma fungsinya sepertin ini --> int pthread_equal(pthread_t tid1, pthread_t tid2);
Lha dalam program anda sekalian,  jangan lupa di include pthread.h diatas atau sebagian perintah thread tidak akan berjalan.

Dalam kasus lain, ada kalanya suatu thread ingin mengetahui TID nya sendiri.
Nah, fungsi
pthread_t pthread_self(void)
bisa menyelesaikan kasus itu. Uda kayak detektif aja dia.

Langsung aja saya akan mencontohkan (mencopaskan sebenarnya) suatu kodingan bagaimana membuat thread yang simple.

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

pthread_t tid[2];

void* doSomeThing(void *arg)
{
    unsigned long i = 0;
    pthread_t id = pthread_self();

    if(pthread_equal(id,tid[0]))
    {
        printf("\n First thread processing\n");
    }
    else
    {
        printf("\n Second thread processing\n");
    }

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

    return NULL;
}

int main(void)
{
    int i = 0;
    int err;

    while(i < 2)
    {
        err = pthread_create(&(tid[i]), NULL, &doSomeThing, NULL);
        if (err != 0)
            printf("\ncan't create thread :[%s]", strerror(err));
        else
            printf("\n Thread created successfully\n");

        i++;
    }

    sleep(5);
    return 0;
}

Nah, yang pthread_create() itu fungsinya untuk membuat thread kan.
Di dalam fungsi doSomething, threadnya make pthread_self dan pthread_equal untuk mengidentifikasi dirinya apakah dia thread kesatu atau kesasar. Eh, kedua maksudnya.
Kalo loop yang didalam doSomething itu untuk membuat waktu memakan kerja?? (time consuming work apa artinya sih?).
Pokoknya untuk membuat fungsi itu berjalan agak lama sehingga seakan akan memutuhkan waktu sedikit, halah. Kalo loop dihilangkan biasanya tidak akan mengefek pada threadnya.

Nah itu dia. Tidak terasa waktu sudah berjalan agak lama. Cukup lelah saya menjelaskan panjang lebar tentang hal ini dan itu tentang Thread ini.
Ya cukup sekian artikel saya tentang thread, semoga berikutnya saya bisa menjelaskan hal lainnya lagi. Terimakasih.