colding forever

#define MYMAXPATH 512

#include <rx/rx.h>

#include </rx_null.h >

#define SAMPLE_SERVER_PORT 5000

#define SAMPLE_SERVICE_PORT 0

/* i.e. user server's port */

#define SAMPLE_SERVICE_ID 4 /* Maximum number of requests that will be handled by this

                                service simultaneously */

/* This number will also be guaranteed to execute in parallel if no services' requests

   are being processed */

#define SAMPLE_MAX 2 /* Minimum number of requests that are guaranteed to be handled

                         immediately */

#define SAMPLE_MIN 1 /* Index of the "null" security class in the sample service. This

                         must be 0 (there are N classes, numbered from 0. In this case,

                         N is 1) */

#define SAMPLE_NULL 0 /********************** fuse4_file_info taken from fuse.h the

                        rxgen does not understands fuse.h  mystat taken from man 2

                        mystat these are required again rxgen does not understand the

                        struct paras and will bump.. **********************/

struct my_file_info { /** Open flags. Available in open() and release() */

                     int flags; /** File handle. May be filled in by filesystem in

                                    open(). Available in all other file operations */

                     unsigned int fh; /** In case of a write operation indicates if

                                          this was caused by a writepage */

                     int writepage;

                    };

struct mystatfs {

                    afs_uint32 f_type; /* type of filesystem (see below) */

                    afs_uint32 f_bsize; /* optimal transfer block size */

                    afs_uint32 f_blocks; /* total data blocks in file system */

                    afs_uint32 f_bfree; /* free blocks in fs */

                    afs_uint32 f_bavail; /* free blocks avail to non-superuser */

                    afs_uint32 f_files; /* total file nodes in file system */

                    afs_uint32 f_ffree; /* free file nodes in fs */

                    afs_uint32 f_fsid1; /* file system id */

                    afs_uint32 f_fsid2; /* file system id */

                    afs_uint32 f_namelen; /* maximum length of filenames */

                    afs_uint32 f_spare[6]; /* spare for later */

                };

struct mystat {

                    afs_uint32 st_dev; /* device */

                    afs_uint32 st_ino; /* inode */

                    afs_uint32 st_mode; /* protection */

                    afs_uint32 st_nlink; /* number of hard links */

                    afs_uint32 st_uid; /* user ID of owner */

                    afs_uint32 st_gid;/* group ID of owner */

                    afs_uint32 st_rdev; /* device type (if inode device) */

                    afs_uint32 st_size; /* total size, in bytes */

                    afs_uint32 st_blksize; /* blocksize for filesystem I/O */

                    afs_uint32 st_blocks; /* number of blocks allocated */

                    afs_uint32 st_atim; /* time of last access */

                    afs_uint32 st_mtim; /* time of last modification */

                    afs_uint32 st_ctim; /* time of last change */

                };

struct my_dirhandle{

                    afs_uint32 type;

                    afs_uint32 inode;

                    char name[MYMAXPATH];

                };

typedef my_dirhandle bulkmydirhandles<>;

 /*********************phase 1 functions *********************************************/

rxc_getattr(IN string mypath<MYMAXPATH>, IN int dummy) split = 1;

rxc_getdirWrapper(IN string path<MYMAXPATH>, OUT bulkmydirhandles *handles) = 2;

rxc_read(IN string path<MYMAXPATH>;, IN afs_uint32 size, IN afs_uint32 offset,

         IN struct my_file_info *fi) split = 3;

rxc_open(IN string path<MYMAXPATH>, IN int flags, OUT u_int *hd) = 4;

rxc_write(IN string path<MYMAXPATH>,IN afs_uint32 size, IN afs_uint32 offset,

          IN struct my_file_info *fi) split = 5;

rxc_chmod(IN string path<MYMAXPATH>, IN afs_uint32 mode) = 6;

rxc_chown(IN string path<MYMAXPATH>, IN afs_uint32 uid, IN afs_uint32 gid) = 7;

rxc_utime(IN string path<MYMAXPATH>, IN afs_uint32 at,IN afs_uint32 mt) = 8;

rxc_mknod(IN string path<MYMAXPATH>, afs_uint32 mode, afs_uint32 rdev) = 9 ;

rxc_mkdir(IN string path<MYMAXPATH>, IN afs_uint32 mode) = 10;

rxc_unlink(IN string path<MYMAXPATH>) = 11 ;

rxc_rmdir(IN string path<MYMAXPATH>) = 12;

rxc_rename(IN string from<MYMAXPATH>, IN string to<MYMAXPATH>) = 13;

rxc_truncate(IN string path<MYMAXPATH>, IN afs_uint32 size) = 14;

rxc_release(IN string path<MYMAXPATH>, IN struct my_file_info *fi) = 15;

rxc_readlink(IN string path<MYMAXPATH>, IN afs_uint32 size,OUT string

             data<MYMAXPATH>) = 16;

rxc_symlink(IN string from<MYMAXPATH>, IN string to<MYMAXPATH>) = 17;

rxc_link(IN string from<MYMAXPATH>, IN string to<MYMAXPATH>) = 18;

rxc_statfs(IN string path<MYMAXPATH>, OUT struct mystatfs *stbuf) = 19;

rxc_fsync(IN string path <MYMAXPAT>, IN int isdatasync, IN struct my_file_info

          *fi) = 20 ;

rxc_flush(IN string path <MYMAXPATH>, IN struct my_file_info *fi) = 21 ;

int afsfuse_readlink(const char *path, char *buf, size_t size){

    rx_connection *local& int ret& char *buffer = malloc (512)&

    memset(buffer,0,512)& memset(buf,0,size)& local = getconnection()&

    ret = rxc_rxc_readlink(local,path,512,&buffer) // rpc call

         relconnection(local)&

         strncpy(buf,buffer,512-1)&

        //<- demarshall the parametrs

        return ret&

    }

int rxc_rxc_readlink( struct rx_call *call, char * path, afs_uint32 size, char**data)

    { int ret& char lbuff[512] ={0}&

    translatePath(path,lbuff)& //<- make filesystem call

     *data = malloc(512)&

     res = readlink(lbuff, *data, 512-1)&

     if(res == -1) return -errno& (*data)[res] = '\0'& return 0&

    }

SRCDIR=./ LIBRX=${SRCDIR}lib/librx.a

LIBS=${LIBRX} ${SRCDIR}lib/liblwp.a

#CC = g++

CFLAGS=-g -I. -I${SRCDIR}include -I${SRCDIR}include/fuse/ -DDEBUG ${XCFLAGS}

    -D_FILE_OFFSET_BITS=64 -DFUSE_USE_VERSION=22

afsfuse_client: afsfuse_client.o afsfuse.xdr.o ${LIBS} bulk_io.o afsfuse.cs.o

    ${CC} ${CFLAGS} -o afsfuse_client afsfuse_client.o ${SRCDIR}lib/fuse/fuse.o

    ${SRCDIR}lib/fuse/mount.o ${SRCDIR}lib/fuse/helper.o

    ${SRCDIR}lib/fuse/fuse_mt.o bulk_io.o afsfuse.cs.o afsfuse.xdr.o ${LIBS}

afsfuse_server: afsfuse_server.o afsfuse.xdr.o afsfuse.ss.o bulk_io.o ${LIBS}

    ${CC} ${CFLAGS} -o afsfuse_server afsfuse_server.o bulk_io.o afsfuse.ss.o

    afsfuse.xdr.o ${LIBS}

#afsfuse_client.o: afsfuse.h

#afsfuse_server.o: afsfuse.h

bulk_io.o: ${CC} -c -g -I${SRCDIR}include bulk_io.c afsfuse.cs.c afsfuse.ss.c

    afsfuse.er.c afsfuse.h afsfuse.xdr.c: afsfuse.xg rxgen afsfuse.xg

afsfuse.xdr.o: afsfuse.xdr.c ${CC} -c -g -I{SRCDIR}include afsfuse.xdr.c

all: afsfuse_server afsfuse_client

clean: rm *.o rm afsfuse_client rm afsfuse_server

Description

Name

Size

Download method

AFSFuse filesystem sample code

l-fuse.zip

9KB

HTTP

用FUSE开发自己的文件系统

不需要内核编程知识

Level: Introductory

Sumit Singh (sumising@in.ibm.com), Software Engineer, IBM

28 Feb 2006

用Filesystem in Userspace (FUSE), 你能开发一个用户空间的文件系统框架，而不需要了解文件系统地内部或者学习内核模块编程的相关知识. 按照本文的例子, 一步一步的指导你去安装, 定制, 和使能FUSE 和 AFS文件系统, 因此你能在Linux®的用户空间创建一个你自己的拥有完全机能的文件系统.

一个文件系统是一种存储和管理计算机文件和目录以及他们包含的数据的有效方法, 而且还能让你很容易得去找道河访问它们.如果你使用过计算机, 你应该用过不止一种文件系统. 一个文件系统能提供一些扩展能力. 它能在一个基本的文件系统上写一个包装器去管理它的数据，并且还能够体统一个加强的，功能丰富的文件系统 (例如cvsfs-fuse, 就是一个给CVS提供了一个文件系统接口, 还有Wayback 文件系统, 就是为了保存老的拷贝数据提供了一个备份机制).

在用户空间文件系统没有出现之前, 文件系统开发是内核开发者的一个工作. 创建一个文件系统则需要了解内核编程和内核技术的相关知识 (就像 vfs). 并且调试的时候还需要C 和 C++ 专门技术. 然而其他的开发者需要操控一个文件系统 —— 只是加入一些个人的特征(例如增加历史纪录或者正向缓存forward-caching) 和改进.

FUSE简介

FUSE让你开发一个拥有简单API库的全功能文件系统, 并能让非特权用户访问, 而且提供了一个安全实现. 另外, 更妙的是, FUSE有一个经过验证的可跟踪的稳定版.

使用 FUSE, 你能开发一个连接到FUSE 库的文件系统就像一个可执行的二进制程序一样 -- 也就是说, 这个文件系统框架不要求你去学习额外的文件系统内部和内核模块的编程知识.

当FUSE真正成为一个文件系统之前, 用户空间的文件系统并不是一个新的设计. 下面有些关于商业和学术上实现的用户空间的文件系统的例子:

• LUFS是一个混血的用户空间文件系统构架，它为所有应用程序提供了数量不定的文件系统. 它分成内核模块和用户空间的后台程序两部分. 基本上它把大多数VFS层的调用委派给专门来处理这些的后台进程.
• UserFS 允许用户进程作为一个正常的文件系统被挂载. 以这个proof-of-concept为原型开发了ftpfs, 一个允许匿名FTP的文件系统.
• Ufo 工程是一个Solaris的全局文件系统，它允许用户把远程文件当作本地文件来使用.
• OpenAFS是一个Andrew FileSystem的开源版本.
• CIFS一个普通的网际文件系统.

不像这些商业和学术例子, FUSE把文件系统设计的功能带到Linux. 因为FUSE 一个可执行的程序(而不是说, 作为LUFS 使用的一个共享对象), 它让调试和开发变得容易起来. FUSE能工作在内核(2.4.x 和