fuse多线程

高级开发(high-level)

 

多线程模式

       如果在多线程运行的情况下，如果处理请求的一个线程出现阻塞但整个系统中所有可用的线程数量超过10时，则系统就会自动关闭线程，如果可用线程为0,系统就会自动创建线程来处理请求，在系统中请求的线程不会由于请求的阻塞而导致线程阻塞后，无线程处理来自文件系统的请求。

 

在运行高级模式开发,通过命令行进行设置(默认开启多线程):

 

 -s disable multi-threaded operation

实现的部分代码如下：

 

 if (multithreaded)
         res = fuse_loop_mt(fuse);
     else
         res = fuse_loop(fuse);

而fuse_loop_mt又实际调用程序fuse_session_loop_mt:

在该程序中，使用的数据结构:

 

 //主要用于标识一个线程
 struct fuse_worker{
 struct fuse_worker *prev;
 struct fuse_worker *next;
 pthread_t thread_id;
 size_t bufsize;
 char* buf;
 struct fuse_mt *mt;
 }
 //用于将所有的线程进行串起来
 struct fuse_mt{
 pthread_mutex_t lock;
 int numworker;
 int numavail;
 struct fuse_session *se;
 struct fuse_chan *prevch;
 struct fuse_worker main;
 sem_t finish;
 int exit;
 int error;
 }

下面就是程序的主体:

 

 int fuse_session_loop_mt(struct fuse_session *se)
 {
        ….....
     //main函数中调用时，进行对主线程的初始化
           mt.se = se;
      mt.prevch = fuse_session_next_chan(se,NULL);
     mt.error = 0;
     mt.numworker=0;
     mt.numavail     =0;
     mt.main.thread_id = pthread_self();
     mt.main.prev = mt.main.next = &mt.main;
     //创建线程函数，并启动该线程
     pthread_mutex_lock(&mt.lock);
     //线程中调用fuse_do_work来进行读取设备/dev/fuse
     err = fuse_start_thread(&mt);
     pthread_mutex_unlock(&mt.lock);
     //接下来就是对启动的各个worker线程进行设置
     if(!err){
       //阻塞自己，直到用户的session退出，这个操作为初始化中最后一个
      while(!fuse_session_exited(se))
         sem_wait(&mt.finish);

      //由于session都退出了，直接要求每个用户的worker线程都退出
       for(w=mt.main.next;w!=&mt.main;w=w->next)
         pthread_cancel(w->thread_id);
      mt.exit=1;
      pthread_mutex_unlock(&mt->lock);

       //只留下一个主线程，其他线程都退出
      while(mt.main. &mt.main)
         fuse_join_worker(&mt,mt.main.next);
     }
 }

而fuse_do_worker部分实际的工作就是从设备/dev/fuse中读取请求，然后进行分发，具体代码如下：

 

 static void * fuse_do_work(void* data)
 {
     ….......
     while(!fuse_session_exited(mt->se))
     {
         …..
         pthread_setcancelstate(PTHREAD__CANCEL_ENABLE,NULL);
         //非阻塞读取请求
         res = fuse_chan_recv(&ch,w->buf,w->bufsize);
         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
         //错误处理
         if(res == -EINTR) continue;
         if(res<=0) {
             if(res<0) {
                 fuse_session_exit(mt->se);
                 mt->error = -1;
             }
             break;
         }
         ….......
         //forget请求码的含义是内核告诉文件系统不用将该inode节点进行缓存,文件系统不用回复
         if(((struct fuse_in_header *)w->buf)->opcode == FUSE_FORGET)
              isforget = 1;
         //线程马上就会去分发请求，可能会阻塞，自减
         if(!isforget) mt->numavail--;
         //读取请求的线程为0.需要进行重建
         if(mt->numavail==0)
          fuse_start_thread(mt);
         //请求分发
         pthread_mutex_unlock(&mt->lock);
         fuse_session_process(mt->se,w->buf,res,ch);
         pthread_mutex_lock(&mt->lock);
         //处理完成，重新变为可用
         if(!isforget) mt->numavail++;
         //读取请求线程最多为10,如果大于10,就请求退出,注意这里使用的是可用线程，而非所有线程
         if(mt->numavail>10){
             if(mt->exit){
              pthread_mutex_unlock(&mt->lock);
              return NULL;
             }
             list_del_workr(w);
             mt->numavail--;
             mt->numworker--;
             pthread_mutex_unlock(&mt->lock);
             …......
          }
         }
          pthread_mutex_unlock(&mt->lock);
     }
         sem_post(&mt->finish);
         pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
         pause();

         return NULL;
 }

实验分析

使用系统自带的例子，在测试的文件系统hello.c中，阻塞文件系统中的getattr请求(通过睡眠实现)，其它请求正常使用，测试代码如下：

 

 static int hello_getattr(const char *path, struct stat *stbuf)
 {
         int res = 0;

         memset(stbuf, 0, sizeof(struct stat));
         if (strcmp(path, "/") == 0) {
                 stbuf->st_mode = S_IFDIR | 0755;
                 stbuf->st_nlink = 2;
         } else if (strcmp(path, hello_path) == 0) {
                 stbuf->st_mode = S_IFREG | 0444;
                 stbuf->st_nlink = 1;
                 stbuf->st_size = strlen(hello_str);
         } else
                 res = -ENOENT;

 // sem_wait(&finish);
        //这个测试的代码
         sleep(120);
         return res;
 }

而其它请求正常进行，进行测试的代码如下：

 

 #include <unistd.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>

 void main()
 {
  int fd,i;
  i=0;
  while(i<10)
  {
   if(0==fork())
   {
      execve("./test.sh",NULL,NULL);
   }
   i++;
  }
  sleep(30);
  printf("send open request");
  while(i<100)
  {
  if((fd=open("/tmp/sshfs",O_RDONLY))<0)
  {
     fprintf(stderr,"open file error!\n");
     exit(-1);
  }
  else printf("open file fd:%d\n",fd);
   i++;
  }
 }

./test.sh的代码就是：ls -l /tmp/sshfs

运行结果如下：

 

 send open requestopen file fd:3
 open file fd:4
 open file fd:5
 open file fd:6
 open file fd:7
 open file fd:8
 open file fd:9
 …....................

查看系统进程:

 

 18506 pts/13 00:00:00 a.out
 18507 pts/13 00:00:00 test.sh
 18508 pts/13 00:00:00 test.sh
 18509 pts/13 00:00:00 test.sh
 18510 pts/13 00:00:00 test.sh
 18511 pts/13 00:00:00 test.sh
 18512 pts/13 00:00:00 test.sh
 18513 pts/13 00:00:00 test.sh
 18514 pts/13 00:00:00 test.sh
 18515 pts/13 00:00:00 test.sh
 18516 pts/13 00:00:00 test.sh

在实验，如果加大请求的次数，挂载的文件系统hello1的线程数量就会增加：

 

 UID PID PPID LWP C NLWP STIME TTY STAT TIME CMD
 ndsl 1968 1 1968 0 13 19:54 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 1969 0 13 19:54 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 1970 0 13 19:54 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2000 0 13 19:55 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2008 0 13 19:55 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2010 0 13 19:55 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2012 0 13 19:55 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2013 0 13 19:55 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2014 0 13 19:55 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2070 0 13 20:00 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2096 0 13 20:01 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2177 0 13 20:04 ? Ssl 0:00 ./hello1 /tmp/sshf
 ndsl 1968 1 2181 0 13 20:04 ? Ssl 0:00 ./hello1 /tmp/sshf

总的请求只有12个，加上一个主线程，则总的线程就13个，将请求线程加至100个时，hello1的线程数据急剧上升，112个(100个阻塞式的ls请求，100个非阻塞open请求),只要线程阻塞就会创建一个新线程。实际计算应该为100个，可能是之前创建的10个线程还没有被主线程进行终止掉。这样就出现了一个很大的缺点：对来自上层的请求，没有进行缓存，而是直接创建一个线程进行处理，会耗费大量的时间，性能就会出现下降。

 

 

 

单线程情况

而在单线程的模式中，则调用

 

 int fuse_loop(struct fuse *f)
 {
     if(f)
     return fuse_session_loop(f->se);
     else
     return -1;
 }
  fuse_session_loop函数原型如下：
 int fuse_session_loop(struct fuse_session *se)
 {
      …......
      while(!fuse_session_exit(se)) {
     struct fuse_chan *tmpch = ch;
        //直接读取请求
     res = fuse_chan_recv(&tmpch,buf,bufsize);
     if(res==-EINTR) continue;
     if(res<=0) break;
     //处理完成后，才读取下一个请求，性能跟不上
     fuse_session_process(se,buf,res,tmpch);
 }
     free(buf);
     fuse_session_reset(se);
     return res<0?-1;0;
 }

低级模式(low_level)

直接在挂载文件系统中的main进行调用fuse_session_loop:

 

 int main(int argc,char* argv[])
 {
     …......
     if(fuse_parse_cmdline(&args,&mountpoint,NULL,NULL)!=-1&&
     (ch=fuse_mount(mountpoint,&args))!=NULL) {
         …....
         //session_loop退出，就是session终止
         err = fuse_session_loop(se);
         fuse_remove_signal_handlers(se);
         fuse_session_remove_chan(ch);
         ….......
     }
 }