进程所在的文件系统是根据什么确定的？

snow_insky

不知道你能否理解这句话，它标识的并不是文件系统是ext2还是ext3，它只是.....唉，不说了，地球人都明白！

snow_insky

还要说一下，我说"它有病啊"说的是那个进程有病啊，并没有人身攻击的意图，不要误会！！！！

难道幽默一下，也要招人非议，唉“做人难，难做人啊”

jeffshia

哦，那我再看看，呵呵 ！呵呵

jeffshia

task_struct ->struct fs *fs_struct->struct vfsmount * rootmnt, * pwdmnt, * altrootmnt-->
struct super_block *mnt_sb-->struct file_system_type *s_type-->const char *name.

不知道这样子能不能得到文件系统的名字啊？
要不要写个模块试试阿？

艾斯尼勒

"进程所在文件系统"一说欠考虑,进程是在执行中的程序.而众所周知,程序是在内存中执行呢...
内存好像只分段不分文件系统吧?

turbo99cn

那当前进程的根目录是怎么回事？

albcamus

原帖由 艾斯尼勒 于 2006-1-6 16:50 发表
"进程所在文件系统"一说欠考虑,进程是在执行中的程序.而众所周知,程序是在内存中执行呢...
内存好像只分段不分文件系统吧?

进程需要打开文件，需要对文件进行open、write， 这些open、write等方法， VFS层的函数执行完毕之后，需要调用该“被打开文件”所在的文件系统（例如ext3、vfat等）定义的方法──如果有的话。具体文件系统也可以不提供这些方法的实现，仅依靠VFS。

jeffshia

good explanation!

wheelz

每个进程有一个namespace(current->namespace)，
即进程所看到的文件系统树，
(different processes have different views of the filesystem)
在这个namespace下，进程可以改变根目录等属性，

进程的fs，应该从namespace来，
内核通过set_fs_root()把init进程的fs相关值设置为它的namespace->root，
见init_mount_tree()

这以后，通过clone()，子进程继承父进程的fs，
如果有必要，通过系统调用chroot()，改变fs结构的值。
请参考一下系统调用chroot()，以及内核的实现sys_chroot()

1. 
   
2. static void __init init_mount_tree(void)
   
3. {
   
4.         struct vfsmount *mnt;
   
5.         struct namespace *namespace;
   
6.         struct task_struct *g, *p;
   
7. 
   
8.         mnt = do_kern_mount("rootfs", 0, "rootfs", NULL);
   
9.         if (IS_ERR(mnt))
   
10.                 panic("Can't create rootfs");
    
11.         namespace = kmalloc(sizeof(*namespace), GFP_KERNEL);
    
12.         if (!namespace)
    
13.                 panic("Can't allocate initial namespace");
    
14.         atomic_set(&namespace->count, 1);
    
15.         INIT_LIST_HEAD(&namespace->list);
    
16.         init_rwsem(&namespace->sem);
    
17.         list_add(&mnt->mnt_list, &namespace->list);
    
18.         namespace->root = mnt;
    
19.         mnt->mnt_namespace = namespace;
    
20. 
    
21.         init_task.namespace = namespace;
    
22.         read_lock(&tasklist_lock);
    
23.         do_each_thread(g, p) {
    
24.                 get_namespace(namespace);
    
25.                 p->namespace = namespace;
    
26.         } while_each_thread(g, p);
    
27.         read_unlock(&tasklist_lock);
    
28. 
    
29.         set_fs_pwd(current->fs, namespace->root, namespace->root->mnt_root);
    
30.         set_fs_root(current->fs, namespace->root, namespace->root->mnt_root);
    
31. }
    
32. 
    
33. asmlinkage long sys_chroot(const char __user * filename)
    
34. {
    
35.         struct nameidata nd;
    
36.         int error;
    
37. 
    
38.         error = __user_walk(filename, LOOKUP_FOLLOW | LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd);
    
39.         if (error)
    
40.                 goto out;
    
41. 
    
42.         error = permission(nd.dentry->d_inode,MAY_EXEC,&nd);
    
43.         if (error)
    
44.                 goto dput_and_out;
    
45. 
    
46.         error = -EPERM;
    
47.         if (!capable(CAP_SYS_CHROOT))
    
48.                 goto dput_and_out;
    
49. 
    
50.         set_fs_root(current->fs, nd.mnt, nd.dentry);
    
51.         set_fs_altroot();
    
52.         error = 0;
    
53. dput_and_out:
    
54.         path_release(&nd);
    
55. out:
    
56.         return error;
    
57. }
    
58. 
    
59. /*
    
60. * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.
    
61. * It can block. Requires the big lock held.
    
62. */
    
63. void set_fs_root(struct fs_struct *fs, struct vfsmount *mnt,
    
64.                  struct dentry *dentry)
    
65. {
    
66.         struct dentry *old_root;
    
67.         struct vfsmount *old_rootmnt;
    
68.         write_lock(&fs->lock);
    
69.         old_root = fs->root;
    
70.         old_rootmnt = fs->rootmnt;
    
71.         fs->rootmnt = mntget(mnt);
    
72.         fs->root = dget(dentry);
    
73.         write_unlock(&fs->lock);
    
74.         if (old_root) {
    
75.                 dput(old_root);
    
76.                 mntput(old_rootmnt);
    
77.         }
    
78. }
    
79. 
    
80. void set_fs_altroot(void)
    
81. {
    
82.         char *emul = __emul_prefix();
    
83.         struct nameidata nd;
    
84.         struct vfsmount *mnt = NULL, *oldmnt;
    
85.         struct dentry *dentry = NULL, *olddentry;
    
86.         int err;
    
87. 
    
88.         if (!emul)
    
89.                 goto set_it;
    
90.         err = path_lookup(emul, LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_NOALT, &nd);
    
91.         if (!err) {
    
92.                 mnt = nd.mnt;
    
93.                 dentry = nd.dentry;
    
94.         }
    
95. set_it:
    
96.         write_lock(&current->fs->lock);
    
97.         oldmnt = current->fs->altrootmnt;
    
98.         olddentry = current->fs->altroot;
    
99.         current->fs->altrootmnt = mnt;
    
100.         current->fs->altroot = dentry;
     
101.         write_unlock(&current->fs->lock);
     
102.         if (olddentry) {
     
103.                 dput(olddentry);
     
104.                 mntput(oldmnt);
     
105.         }
     
106. }
     
107. 
     

复制代码

[ 本帖最后由 wheelz 于 2006-1-6 20:46 编辑 ]

艾斯尼勒

原帖由 albcamus 于 2006-1-6 17:01 发表


进程需要打开文件，需要对文件进行open、write， 这些open、write等方法， VFS层的函数执行完毕之后，需要调用该“被打开文件”所在的文件系统（例如ext3、vfat等）定义的方法──如果有的话。具体文件系统也 ...

原来是这个意思,我觉得若不是我误会楼主了就是楼主的说法还是欠妥呵呵
不过既然linux提供了vfs,那么底层到底什么fs对程序员来说应该当作透明的才对,关心它作什么?