sockfs 套接字文件系统

      套接字文件系统是一个用户不可见的, 高度简化的, 用于汇集网络套接字的内存文件系统,它没有块设备, 没有子目录, 没有文件缓冲,它借用虚拟文件系统的框架来使套接字与文件描述字具有相同的用户接口.当用户用socket(family,type,protocol)创建一个网络协议族为family, 类型为type,协议为protocol的套接字时, 系统就在套接字文件系统中为其创建了一个名称为其索引节点编号的套接字文件.

有关代码
--------

static struct net_proto_family *net_families[NPROTO];

 

套接字的不同协议族,用sock_register()安装

static DECLARE_FSTYPE(sock_fs_type, "sockfs", sockfs_read_super,

FS_NOMOUNT|FS_SINGLE);



; net/socket.c

void __init sock_init(void)

{

int i;



printk(KERN_INFO "Linux NET4.0 for Linux 2.4/n");

printk(KERN_INFO "Based upon Swansea University Computer Society NET3.039/n");



/*

* Initialize all address (protocol) families.

*/



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

net_families[ i ] = NULL;



/*

* Initialize sock SLAB cache.

*/



sk_init();



#ifdef SLAB_SKB

/*

* Initialize skbuff SLAB cache

*/

skb_init();

#endif



/*

* Wan router layer.

*/



#ifdef CONFIG_WAN_ROUTER

wanrouter_init();

#endif



/*

* Initialize the protocols module.

*/



register_filesystem(&sock_fs_type); 注册套接字文件系统

sock_mnt = kern_mount(&sock_fs_type); 安装套接字文件系

/* The real protocol initialization is performed when

*  do_initcalls is run. 

*/





/*

* The netlink device handler may be needed early.

*/



#ifdef  CONFIG_RTNETLINK

rtnetlink_init();

#endif

#ifdef CONFIG_NETLINK_DEV

init_netlink();

#endif

#ifdef CONFIG_NETFILTER

netfilter_init();

#endif

}



static struct super_block * sockfs_read_super(struct super_block *sb, void *data, int
silent)

{

struct inode *root = new_inode(sb); 创建套接字文件系统的根目录文件的索引结点

if (!root)

return NULL;

root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;

root->i_uid = root->i_gid = 0;

root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;

sb->s_blocksize = 1024;

sb->s_blocksize_bits = 10;

sb->s_magic = SOCKFS_MAGIC;

sb->s_op = &sockfs_ops;

sb->s_root = d_alloc(NULL, &(const struct qstr) { "socket:", 7, 0 });

; 创建名称为"socket:"的根目录项

if (!sb->s_root) {

iput(root);

return NULL;

}

sb->s_root->d_sb = sb;

sb->s_root->d_parent = sb->s_root;

d_instantiate(sb->s_root, root); 将根目录项指向根目录文件

return sb;

}

static struct super_operations sockfs_ops = {

statfs: sockfs_statfs,

};

static int sockfs_statfs(struct super_block *sb, struct statfs *buf)

{

buf->f_type = SOCKFS_MAGIC;

buf->f_bsize = 1024;

buf->f_namelen = 255;

return 0;

}

static struct file_operations socket_file_ops = { 用户的文件接口函数

llseek: sock_lseek,

read: sock_read,

write: sock_write,

poll: sock_poll,

ioctl: sock_ioctl,

mmap: sock_mmap,

open: sock_no_open, /* special open code to disallow open via /proc */

release: sock_close,

fasync: sock_fasync,

readv: sock_readv,

writev: sock_writev

};

static loff_t sock_lseek(struct file *file, loff_t offset, int whence)

{

return -ESPIPE;

}

extern __inline__ struct socket *socki_lookup(struct inode *inode)

{

return &inode->u.socket_i; 取inode结构中的套接字文件结构

}

int sock_recvmsg(struct socket *sock, struct msghdr *msg, int size, int flags)

{

struct scm_cookie scm; ? scm是不是指"套接字用户身份信息" ?



memset(&scm, 0, sizeof(scm));



size = sock->ops->recvmsg(sock, msg, size, flags, &scm); 调用协议簇报文接收函数

if (size >= 0)

scm_recv(sock, msg, &scm, flags); 是不是接收报文的用户身份信息?



return size;

}

static ssize_t sock_read(struct file *file, char *ubuf,

size_t size, loff_t *ppos)

{

struct socket *sock;

struct iovec iov; 报文收发向量

struct msghdr msg; 报文描述头

int flags;



if (ppos != &file->f_pos)

return -ESPIPE;

if (size==0) /* Match SYS5 behaviour */

return 0;



sock = socki_lookup(file->f_dentry->d_inode); 取inode中的套接字文件结构



msg.msg_name=NULL; 报文名称

msg.msg_namelen=0; 报文名称长度

msg.msg_iov=&iov;  报文收发向量指针

msg.msg_iovlen=1;  报文收发向量数量

msg.msg_control=NULL; 报文控制块

msg.msg_controllen=0; 报文控制块长度

iov.iov_base=ubuf; 收发向量数据区地址

iov.iov_len=size; 收发向量数据区长度

flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;



return sock_recvmsg(sock, &msg, size, flags);

}

int sock_sendmsg(struct socket *sock, struct msghdr *msg, int size)

{

int err;

struct scm_cookie scm;



err = scm_send(sock, msg, &scm); 是不是发送用户身份信息?

if (err >= 0) {

err = sock->ops->sendmsg(sock, msg, size, &scm); 调用协议族的报文发送函数

scm_destroy(&scm);

}

return err;

}

static ssize_t sock_write(struct file *file, const char *ubuf,

  size_t size, loff_t *ppos)

{

struct socket *sock;

struct msghdr msg;

struct iovec iov;



if (ppos != &file->f_pos)

return -ESPIPE;

if(size==0) /* Match SYS5 behaviour */

return 0;



sock = socki_lookup(file->f_dentry->d_inode);



msg.msg_name=NULL;

msg.msg_namelen=0;

msg.msg_iov=&iov;

msg.msg_iovlen=1;

msg.msg_control=NULL;

msg.msg_controllen=0;

msg.msg_flags=!(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;

if (sock->type == SOCK_SEQPACKET) 如果套接字为顺序包类型

msg.msg_flags |= MSG_EOR; 报文的结束标记

iov.iov_base=(void *)ubuf;

iov.iov_len=size;



return sock_sendmsg(sock, &msg, size);

}

static unsigned int sock_poll(struct file *file, poll_table * wait)

{

struct socket *sock;



/*    征求套接字

* We can't return errors to poll, so it's either yes or no.

*/

sock = socki_lookup(file->f_dentry->d_inode);

return sock->ops->poll(file, sock, wait);

}

int sock_ioctl(struct inode *inode, struct file *file, unsigned int cmd,

   unsigned long arg)

{

struct socket *sock;

int err;



unlock_kernel();

sock = socki_lookup(inode);

err = sock->ops->ioctl(sock, cmd, arg);

lock_kernel();



return err;

}

static int sock_mmap(struct file * file, struct vm_area_struct * vma)

{

struct socket *sock = socki_lookup(file->f_dentry->d_inode);



return sock->ops->mmap(file, sock, vma);

}

static int sock_no_open(struct inode *irrelevant, struct file *dontcare)

{

return -ENXIO;

}

int sock_close(struct inode *inode, struct file *filp)

{

/*

* It was possible the inode is NULL we were

* closing an unfinished socket.

*/



if (!inode)

{

printk(KERN_DEBUG "sock_close: NULL inode/n");

return 0;

}

sock_fasync(-1, filp, 0);

sock_release(socki_lookup(inode));

return 0;

}

static int sock_fasync(int fd, struct file *filp, int on)

{

struct fasync_struct *fa, *fna=NULL, **prev;

struct socket *sock;

struct sock *sk;



if (on)

{

fna=(struct fasync_struct *)kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);

if(fna==NULL)

return -ENOMEM;

}





sock = socki_lookup(filp->f_dentry->d_inode);



if ((sk=sock->sk) == NULL)

return -EINVAL;



lock_sock(sk);



prev=&(sock->fasync_list);



for (fa=*prev; fa!=NULL; prev=&fa->fa_next,fa=*prev)

if (fa->fa_file==filp)

break;



if(on)

{

if(fa!=NULL)

{

write_lock_bh(&sk->callback_lock);

fa->fa_fd=fd;

write_unlock_bh(&sk->callback_lock);



kfree(fna);

goto out;

}

fna->fa_file=filp;

fna->fa_fd=fd;

fna->magic=FASYNC_MAGIC;

fna->fa_next=sock->fasync_list;

write_lock_bh(&sk->callback_lock);

sock->fasync_list=fna;

write_unlock_bh(&sk->callback_lock);

}

else

{

if (fa!=NULL)

{

write_lock_bh(&sk->callback_lock);

*prev=fa->fa_next;

write_unlock_bh(&sk->callback_lock);

kfree(fa);

}

}



out:

release_sock(sock->sk);

return 0;

}



static ssize_t sock_readv(struct file *file, const struct iovec *vector,

  unsigned long count, loff_t *ppos)

{

size_t tot_len = 0;

int i;

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

                tot_len += vector[ i ].iov_len;

return sock_readv_writev(VERIFY_WRITE, file->f_dentry->d_inode,

file, vector, count, tot_len);

}



static ssize_t sock_writev(struct file *file, const struct iovec *vector,

   unsigned long count, loff_t *ppos)

{

size_t tot_len = 0;

int i;

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

                tot_len += vector[ i ].iov_len;

return sock_readv_writev(VERIFY_READ, file->f_dentry->d_inode,

file, vector, count, tot_len);

}

int sock_readv_writev(int type, struct inode * inode, struct file * file,

      const struct iovec * iov, long count, long size) 收发报文向量

{

struct msghdr msg;

struct socket *sock;



sock = socki_lookup(inode);



msg.msg_name = NULL;

msg.msg_namelen = 0;

msg.msg_control = NULL;

msg.msg_controllen = 0;

msg.msg_iov = (struct iovec *) iov;

msg.msg_iovlen = count;

msg.msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;



/* read() does a VERIFY_WRITE */

if (type == VERIFY_WRITE)

return sock_recvmsg(sock, &msg, size, msg.msg_flags);



if (sock->type == SOCK_SEQPACKET)

msg.msg_flags |= MSG_EOR;



return sock_sendmsg(sock, &msg, size);

}





asmlinkage long sys_socket(int family, int type, int protocol)

{

int retval;

struct socket *sock;



retval = sock_create(family, type, protocol, &sock); 创建套接字结构

if (retval < 0)

goto out;



retval = sock_map_fd(sock); 将套接字结构映射成套接字

if (retval < 0)

goto out_release;



out:

/* It may be already another descriptor 8) Not kernel problem. */

return retval;



out_release:

sock_release(sock);

return retval;

}

int sock_create(int family, int type, int protocol, struct socket **res)

{

int i;

struct socket *sock;



/*

* Check protocol is in range

*/

if(family<0 || family>=NPROTO)

return -EAFNOSUPPORT;



/* Compatibility.



   This uglymoron is moved from INET layer to here to avoid

   deadlock in module load.

*/

if (family == PF_INET && type == SOCK_PACKET) {

static int warned;

if (!warned) {

warned = 1;

printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)/n", current->comm);

}

family = PF_PACKET;

}



#if defined(CONFIG_KMOD) && defined(CONFIG_NET)

/* Attempt to load a protocol module if the find failed.

*

* 12/09/1996 Marcin: But! this makes REALLY only sense, if the user

* requested real, full-featured networking support upon configuration.

* Otherwise module support will break!

*/

if (net_families[family]==NULL)

{

char module_name[30];

sprintf(module_name,"net-pf-%d",family);

request_module(module_name);

}

#endif



net_family_read_lock();

if (net_families[family] == NULL) {

i = -EAFNOSUPPORT;

goto out;

}



/*

* Allocate the socket and allow the family to set things up. if

* the protocol is 0, the family is instructed to select an appropriate

* default.

*/



if (!(sock = sock_alloc())) 分配套接字结构

{

printk(KERN_WARNING "socket: no more sockets/n");

i = -ENFILE; /* Not exactly a match, but its the

   closest posix thing */

goto out;

}



sock->type  = type; 套接字类型



if ((i = net_families[family]->create(sock, protocol)) < 0) 初始化套接字结构

{

sock_release(sock);

goto out;

}



*res = sock;



out:

net_family_read_unlock();

return i;

}

struct socket *sock_alloc(void)

{

struct inode * inode;

struct socket * sock;



inode = get_empty_inode();

if (!inode)

return NULL;



inode->i_sb = sock_mnt->mnt_sb; 取套接字文件系统的超级块

sock = socki_lookup(inode);



inode->i_mode = S_IFSOCK|S_IRWXUGO; 套接字文件类型

inode->i_sock = 1;

inode->i_uid = current->fsuid;

inode->i_gid = current->fsgid;



sock->inode = inode;

init_waitqueue_head(&sock->wait);

sock->fasync_list = NULL;

sock->state = SS_UNCONNECTED;

sock->flags = 0;

sock->ops = NULL; 协议族函数表

sock->sk = NULL; 套接字传输控制块

sock->file = NULL;



sockets_in_use[smp_processor_id()].counter++;

return sock;

}

static int sock_map_fd(struct socket *sock)

{

int fd;

struct qstr this;

char name[32];



/*

* Find a file descriptor suitable for return to the user.

*/



fd = get_unused_fd();

if (fd >= 0) {

struct file *file = get_empty_filp();



if (!file) {

put_unused_fd(fd);

fd = -ENFILE;

goto out;

}



sprintf(name, "[%lu]", sock->inode->i_ino);

this.name = name;

this.len = strlen(name);

this.hash = sock->inode->i_ino;



file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);

; 在根目录下创建以索引结点的编号为名称的目录项

if (!file->f_dentry) {

put_filp(file);

put_unused_fd(fd);

fd = -ENOMEM;

goto out;

}

file->f_dentry->d_op = &sockfs_dentry_operations; 安装套接字文件目录项的操作表

d_add(file->f_dentry, sock->inode); 使目录项指向文件

file->f_vfsmnt = mntget(sock_mnt); 增加对套接字文件系统的引用计数



sock->file = file;

file->f_op = sock->inode->i_fop = &socket_file_ops; 安装套接字文件操作表

file->f_mode = 3;

file->f_flags = O_RDWR;

file->f_pos = 0;

fd_install(fd, file);

}



out:

return fd;

}

static struct dentry_operations sockfs_dentry_operations = {

d_delete: sockfs_delete_dentry,

};

static int sockfs_delete_dentry(struct dentry *dentry)

{

return 1; 删除成功

}

原文地址：http://www.linuxforum.net/forum/showflat.php?Cat=&Board=linuxK&Number=111540&page=154&view=collapsed&sb=5&o=all