sys_mount

SYSCALL_DEFINE5(mount,...), 最后扩展为
asmlinkage long sys_mount(char __user * dev_name, char __user * dir_name, char __user * type, unsigned long flags, void __user * data)

对应于mount命令， mount -t ext3 /dev/sdc1 /mnt/tmp1
dev_name： /dev/sdc1
dir_name: /mnt/tmp1
type: ext3

对于该情景，sys_mount最终要调用到mnt_set_mountpoint和commit_tree，将child mnt与parent mnt建立起联系。

#define __SYSCALL_DEFINEx(x, name, ...) \
        asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))

    #define SYSCALL_DEFINEx(x, sname, ...) \
        __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

 #define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)

SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
            char __user *, type, unsigned long, flags, void __user *, data)
    {
        int ret;
        char *kernel_type;
        char *kernel_dir;
        char *kernel_dev;
        unsigned long data_page;

        /* 用户态的type复制到内核态 */
        ret = copy_mount_string(type, &kernel_type);
        if (ret < 0)
            goto out_type;

        /* 用户态的dir_name复制到内核态 */
        kernel_dir = getname(dir_name);
        if (IS_ERR(kernel_dir)) {
            ret = PTR_ERR(kernel_dir);
            goto out_dir;
        }

     /* 用户态的dev_name复制到内核态 */

        ret = copy_mount_string(dev_name, &kernel_dev);
        if (ret < 0)
            goto out_dev;

        /* 用户态的data制到内核态 */
        ret = copy_mount_options(data, &data_page);
        if (ret < 0)
            goto out_data;

        ret = do_mount(kernel_dev, kernel_dir, kernel_type, flags,
            (void *) data_page);

        free_page(data_page);
    out_data:
        kfree(kernel_dev);
    out_dev:
        putname(kernel_dir);
    out_dir:
        kfree(kernel_type);
    out_type:
        return ret;
    }

long do_mount(char *dev_name, char *dir_name, char *type_page,
             unsigned long flags, void *data_page)
    {
        struct path path;
        int retval = 0;
        int mnt_flags = 0;

        /* Discard magic */
        if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
            flags &= ~MS_MGC_MSK;

        /* Basic sanity checks */

        if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE))
            return -EINVAL;

        if (data_page)
            ((char *)data_page)[PAGE_SIZE - 1] = 0;

        /* ... and get the mountpoint */
        /* dir_name是mount_point，kern_path函数查找dir_name对应的dentry和vfsmount结构
            kern_path实际上就是调用do_path_lookup函数
         */
        retval = kern_path(dir_name, LOOKUP_FOLLOW, &path);
        if (retval)
            return retval;

        retval = security_sb_mount(dev_name, &path,
                     type_page, flags, data_page);
        if (retval)
            goto dput_out;

        /* Default to relatime unless overriden */
        if (!(flags & MS_NOATIME))
            mnt_flags |= MNT_RELATIME;

        /* Separate the per-mountpoint flags */
        if (flags & MS_NOSUID)
            mnt_flags |= MNT_NOSUID;
        if (flags & MS_NODEV)
            mnt_flags |= MNT_NODEV;
        if (flags & MS_NOEXEC)
            mnt_flags |= MNT_NOEXEC;
        if (flags & MS_NOATIME)
            mnt_flags |= MNT_NOATIME;
        if (flags & MS_NODIRATIME)
            mnt_flags |= MNT_NODIRATIME;
        if (flags & MS_STRICTATIME)
            mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);
        if (flags & MS_RDONLY)
            mnt_flags |= MNT_READONLY;

        flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE | MS_BORN |
             MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |
             MS_STRICTATIME);
        /* 现在只关心正常的mount操作，即do_new_mount函数 */
        if (flags & MS_REMOUNT)
            retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,
                     data_page);
        else if (flags & MS_BIND)
            retval = do_loopback(&path, dev_name, flags & MS_REC);
        else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
            retval = do_change_type(&path, flags);
        else if (flags & MS_MOVE)
            retval = do_move_mount(&path, dev_name);
        else
            retval = do_new_mount(&path, type_page, flags, mnt_flags,
                     dev_name, data_page);
    dput_out:
        path_put(&path);
        return retval;
    }

/*
 * create a new mount for userspace and request it to be added into the
 * namespace's tree
 */
static int do_new_mount(struct path *path, char *type, int flags,
            int mnt_flags, char *name, void *data)
{
    struct vfsmount *mnt;

    if (!type)
        return -EINVAL;

    /* we need capabilities... */
    if (!capable(CAP_SYS_ADMIN))
        return -EPERM;

    lock_kernel();
    /* do_kern_mount的作用是读取设备的super block, 生成设备的root dentry， 生成一个vfsmount结构 */
    mnt = do_kern_mount(type, flags, name, data);
    unlock_kernel();
    if (IS_ERR(mnt))
        return PTR_ERR(mnt);
    /* do_add_mount作用是将刚刚为设备生成的mnt与mountpoint建立起联系 */
    return do_add_mount(mnt, path, mnt_flags, NULL);
}

/*
 * add a mount into a namespace's mount tree
 * - provide the option of adding the new mount to an expiration list
 */
int do_add_mount(struct vfsmount *newmnt, struct path *path,
         int mnt_flags, struct list_head *fslist)
{
    int err;

    mnt_flags &= ~(MNT_SHARED | MNT_WRITE_HOLD | MNT_INTERNAL);

    down_write(&namespace_sem);

    /* 防止在等待信号量的过程中有人捷足先登，在mount_point上又mount了其他设备
       如果有其他设备抢先mount到了这个mountponit，那么对不起，我只能用它的root dentry作为新的mountponit了，
        所以这里调用follow_down，直到找到最新抢先mount的设备的root dentry */

    /* Something was mounted here while we slept */
    while (d_mountpoint(path->dentry) &&
           follow_down(path))
        ;
    err = -EINVAL;
    if (!(mnt_flags & MNT_SHRINKABLE) && !check_mnt(path->mnt))
        goto unlock;

     /* 防止同一个设备mount到同一个mountpoint */

    /* Refuse the same filesystem on the same mount point */
    err = -EBUSY;
    if (path->mnt->mnt_sb == newmnt->mnt_sb &&
        path->mnt->mnt_root == path->dentry)
        goto unlock;

    /* 设备的根节点不能是符号链接 */

    err = -EINVAL;
    if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode))
        goto unlock;
    /* graft_tree实现newmnt（也即是childmount）与parent mount建立联系 */
    newmnt->mnt_flags = mnt_flags;
    if ((err = graft_tree(newmnt, path)))
        goto unlock;

      /* do_new_mount传递过来的fslist为NULL */

    if (fslist) /* add to the specified expiration list */
        list_add_tail(&newmnt->mnt_expire, fslist);

    up_write(&namespace_sem);
    return 0;

unlock:
    up_write(&namespace_sem);
    mntput(newmnt);
    return err;
}

static int graft_tree(struct vfsmount *mnt, struct path *path)
{
    int err;
    /* 判断子文件系统是否可以挂载，有些文件系统如pipefs， 块设备文件系统是不可以挂载的 */
    if (mnt->mnt_sb->s_flags & MS_NOUSER)
        return -EINVAL;
    /* mountpoint应当是目录，设备的root dentry也需要是目录 */
    if (S_ISDIR(path->dentry->d_inode->i_mode) !=
          S_ISDIR(mnt->mnt_root->d_inode->i_mode))
        return -ENOTDIR;

...
    err = -ENOENT;
    /* 调用attach_recursive_mnt实现mount操作 */
    if (!d_unlinked(path->dentry))
        err = attach_recursive_mnt(mnt, path, NULL);
out_unlock:
    mutex_unlock(&path->dentry->d_inode->i_mutex);
    if (!err)
        security_sb_post_addmount(mnt, path);
    return err;
}

static int attach_recursive_mnt(struct vfsmount *source_mnt,
            struct path *path, struct path *parent_path)
{
    LIST_HEAD(tree_list);
    struct vfsmount *dest_mnt = path->mnt;
    struct dentry *dest_dentry = path->dentry;
    struct vfsmount *child, *p;
    int err;

    if (IS_MNT_SHARED(dest_mnt)) {
        err = invent_group_ids(source_mnt, true);
        if (err)
            goto out;
    }
    err = propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list);
    if (err)
        goto out_cleanup_ids;

    spin_lock(&vfsmount_lock);

    if (IS_MNT_SHARED(dest_mnt)) {
        for (p = source_mnt; p; p = next_mnt(p, source_mnt))
            set_mnt_shared(p);
    }
    /* graft_tree传递过来的parent_path==NULL */
    if (parent_path) {
        detach_mnt(source_mnt, parent_path);
        attach_mnt(source_mnt, path);
        touch_mnt_namespace(parent_path->mnt->mnt_ns);
    } else {
        /* 走这个分支 */
        mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
        commit_tree(source_mnt);
    }

    list_for_each_entry_safe(child, p, &tree_list, mnt_hash) {
        list_del_init(&child->mnt_hash);
        commit_tree(child);
    }
    spin_unlock(&vfsmount_lock);
    return 0;

 out_cleanup_ids:
    if (IS_MNT_SHARED(dest_mnt))
        cleanup_group_ids(source_mnt, NULL);
 out:
    return err;
}

mnt_set_mountpoint是关联parent mnt与child_mnt的关键函数，建立如下图1的关系

                                                            图1

void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
            struct vfsmount *child_mnt)
{
    child_mnt->mnt_parent = mntget(mnt);
    child_mnt->mnt_mountpoint = dget(dentry);
    dentry->d_mounted++;
}

commit_tree函数首先设置child mnt的命名空间，并将child mnt通过mnt_list链入命名空间的list.

/*
 * the caller must hold vfsmount_lock
 */
static void commit_tree(struct vfsmount *mnt)
{
    struct vfsmount *parent = mnt->mnt_parent;
    struct vfsmount *m;
    LIST_HEAD(head);
    struct mnt_namespace *n = parent->mnt_ns;

    BUG_ON(parent == mnt);

    list_add_tail(&head, &mnt->mnt_list);
    list_for_each_entry(m, &head, mnt_list)
        m->mnt_ns = n;    /*  child mount属于parent mount的命名空间 */

    /* list_spice将两个链表合并在一起，实际上是把child mnt通过mnt_list链入parent mnt所在name_space的list */
    list_splice(&head, n->list.prev);

    /* child mount加入mount_hashtable表，所在hash链由parent mnt的地址和mount point的name生成 */

    list_add_tail(&mnt->mnt_hash, mount_hashtable +
                hash(parent, mnt->mnt_mountpoint));
/* child mount通过mnt_child表，加入parent mnt的mnt_mounts开头的list尾部 */
    list_add_tail(&mnt->mnt_child, &parent->mnt_mounts);
    touch_mnt_namespace(n);
}