mount命令是大家在平時使用linux的時候經常使用的一個命令，相信很多人都很熟悉這個命令，它的作用是把一個裝置掛載到根檔案系統的某一個目錄上邊去，但是有沒有人對他的內部實現有過一些瞭解的呢，我今天就像從linux的原始碼剖析，一層一層的剝開它實現的奧祕。
首先mount是一個系統呼叫，在使用者空間使用mount函式以後，會呼叫軟中斷，進入核心空間。然後根據傳入的引數，呼叫對應的中端門，隨後進入sys_mount函式，這個函式定義在fs/namespace.c裡，定義如下

/*傳入的dev_name是mount的裝置名，dir_name是掛載點，type是檔案系統型別，flags是標記，data是私有資料*/
asmlinkage long sys_mount(char __user * dev_name, char __user * dir_name,
			  char __user * type, unsigned long flags,
			  void __user * data)
{
	int retval;
	unsigned long data_page;
	unsigned long type_page;
	unsigned long dev_page;
	char *dir_page;
	/*type是字串的檔案系統名字，比如"ext4"這樣的字串，這個函式就是把掛載的選項字串複製到核心裡的一塊地方*/
	retval = copy_mount_options(type, &type_page);
	if (retval < 0)
		return retval;
	/*把使用者空間傳來的dir_name引數複製到核心的一塊記憶體裡邊*/
	dir_page = getname(dir_name);
	retval = PTR_ERR(dir_page);
	if (IS_ERR(dir_page))
		goto out1;
	/*把dev_name複製到核心的一個空閒頁上*/
	retval = copy_mount_options(dev_name, &dev_page);
	if (retval < 0)
		goto out2;
	/*把data資料複製到核心的一個空閒頁上*/
	retval = copy_mount_options(data, &data_page);
	if (retval < 0)
		goto out3;
	/*鎖住核心，防止其他程序搶佔*/
	lock_kernel();
	/*進入mount的主要工作*/
	retval = do_mount((char *)dev_page, dir_page, (char *)type_page,
			  flags, (void *)data_page);
	/*釋放鎖，並釋放記憶體*/
	unlock_kernel();
	free_page(data_page);


out3:
	free_page(dev_page);
out2:
	putname(dir_page);
out1:
	free_page(type_page);
	return retval;
}
 

然後進入do_mount函式，這個函式也定義在fs/namespace.c裡，定義如下

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


	/* 不用的magic就拋棄 */
	if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
		flags &= ~MS_MGC_MSK;
	/*引數檢查*/
	if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE))
		return -EINVAL;
	if (dev_name && !memchr(dev_name, 0, PAGE_SIZE))
		return -EINVAL;
	/* 把頁的最後一個位元組置為零 */
	if (data_page)
		((char *)data_page)[PAGE_SIZE - 1] = 0;


	/* 把傳入的flags分解到mnt_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_RELATIME)
		mnt_flags |= MNT_RELATIME;


	flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE |
		   MS_NOATIME | MS_NODIRATIME | MS_RELATIME);


	/* 從引數中尋找到掛載點，並且檢查這個目錄是否存在合法 */
	retval = path_lookup(dir_name, LOOKUP_FOLLOW, &nd);
	if (retval)
		return retval;
	/* 安全操作 */
	retval = security_sb_mount(dev_name, &nd, type_page, flags, data_page);
	if (retval)
		goto dput_out;
	/* 如果不是第一次掛載的話，就執行do_remount */
	if (flags & MS_REMOUNT)
		retval = do_remount(&nd, flags & ~MS_REMOUNT, mnt_flags,
				    data_page);
	else if (flags & MS_BIND)/*  */
		retval = do_loopback(&nd, dev_name, flags & MS_REC);
	else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
		retval = do_change_type(&nd, flags);
	else if (flags & MS_MOVE)/* 移動目錄 */
		retval = do_move_mount(&nd, dev_name);
	else/* 第一次掛載 */
		retval = do_new_mount(&nd, type_page, flags, mnt_flags,
				      dev_name, data_page);
dput_out:
	path_release(&nd);
	return retval;
}
 

我們主要分析下第一次掛載的過程，其他的都類似，第一次掛載做了很多的事情，do_new_mount函式也定義在fs/namespace.c裡，定義如下

static int do_new_mount(struct nameidata *nd, char *type, int flags,
			int mnt_flags, char *name, void *data)
{
	/* vfsmount結構體是掛載最重要的結構體 */
	struct vfsmount *mnt;
	/* 引數檢查 */
	if (!type || !memchr(type, 0, PAGE_SIZE))
		return -EINVAL;


	/* 如果沒有許可權，就結束函式 */
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	/* 為第一次掛載建立dentry，root的inode，如果已經存在的話，就返回已經存在的 */
	mnt = do_kern_mount(type, flags, name, data);
	if (IS_ERR(mnt))
		return PTR_ERR(mnt);
	/* 執行掛載到具體的掛載點 */
	return do_add_mount(mnt, nd, mnt_flags, NULL);
}
 

然後分析do_add_mount函式，這個函式也定義在fs/namespace.c裡，定義如下

int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd,
		 int mnt_flags, struct list_head *fslist)
{/* 所有的引數都被放在了nameidata裡 */
	int err;
	/* 鎖住核心的訊號量，保持唯一性訪問 */
	down_write(&namespace_sem);
	/* 看看目錄掛載點是不是已經被掛載了，如果被掛載了，就再次尋找dentry和mount結構體 */
	while (d_mountpoint(nd->dentry) && follow_down(&nd->mnt, &nd->dentry))
		;
	err = -EINVAL;
	/* 如果真的已經被掛載，就返回錯誤 */
	if (!check_mnt(nd->mnt))
		goto unlock;


	/* 如果在一個掛載點是同一個檔案系統的話就返回錯誤 */
	err = -EBUSY;
	if (nd->mnt->mnt_sb == newmnt->mnt_sb &&
	    nd->mnt->mnt_root == nd->dentry)
		goto unlock;
	/* 如果根的inode是軟連線，就返回錯誤 */
	err = -EINVAL;
	if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode))
		goto unlock;
	/*  把要掛載的dentry和掛載點的dentry結合，主要的工作函式*/
	newmnt->mnt_flags = mnt_flags;
	if ((err = graft_tree(newmnt, nd)))
		goto unlock;
	/* 記錄在檔案系統連結串列上 */
	if (fslist) {
		/* add to the specified expiration list */
		spin_lock(&vfsmount_lock);
		list_add_tail(&newmnt->mnt_expire, fslist);
		spin_unlock(&vfsmount_lock);
	}
	up_write(&namespace_sem);
	return 0;


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

主要的工作是在graft_tree函式內部實現的，我們就進入graft_tree看一下，graft_tree函式定義在fs/namespace.c裡，定義如下

static int graft_tree(struct vfsmount *mnt, struct nameidata *nd)
{
	/*檢查超級塊可不可以掛載*/
	int err;
	if (mnt->mnt_sb->s_flags & MS_NOUSER)
		return -EINVAL;
	/*檢查兩個檔案系統是不是一致的*/
	if (S_ISDIR(nd->dentry->d_inode->i_mode) !=
	      S_ISDIR(mnt->mnt_root->d_inode->i_mode))
		return -ENOTDIR;


	err = -ENOENT;
	mutex_lock(&nd->dentry->d_inode->i_mutex);
	/*dead，死的也不行*/
	if (IS_DEADDIR(nd->dentry->d_inode))
		goto out_unlock;
	/*安全操作*/
	err = security_sb_check_sb(mnt, nd);
	if (err)
		goto out_unlock;
	/*如果掛載點是根目錄或者在快取裡邊*/
	err = -ENOENT;
	if (IS_ROOT(nd->dentry) || !d_unhashed(nd->dentry))
		/*掛載操作*/
		err = attach_recursive_mnt(mnt, nd, NULL);
out_unlock:
	mutex_unlock(&nd->dentry->d_inode->i_mutex);
	if (!err)
		security_sb_post_addmount(mnt, nd);
	return err;
}

主要的工作是在attach_recursive_mnt函式內部實現的，attach_recursive_mnt函式定義在fs/namespace.c裡，定義如下

static int attach_recursive_mnt(struct vfsmount *source_mnt,
			struct nameidata *nd, struct nameidata *parent_nd)
{
	LIST_HEAD(tree_list);
	struct vfsmount *dest_mnt = nd->mnt;
	struct dentry *dest_dentry = nd->dentry;
	struct vfsmount *child, *p;
	/*引數檢查，是不是合理的，比如要掛載點在目的點的下邊*/
	if (propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list))
		return -EINVAL;
	/*是否可分享*/
	if (IS_MNT_SHARED(dest_mnt)) {
		for (p = source_mnt; p; p = next_mnt(p, source_mnt))
			set_mnt_shared(p);
	}
	/*鎖住vfsmount結構體，我們穿入的parent_nd是NULL所以執行else的*/
	spin_lock(&vfsmount_lock);
	if (parent_nd) {
		detach_mnt(source_mnt, parent_nd);
		attach_mnt(source_mnt, nd);
		touch_mnt_namespace(current->nsproxy->mnt_ns);
	} else {
		/*dest_dentry的d_mounted++，標記已經掛載，source_mnt結構體填充*/
		mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
		/*把新的vfsmount提交到全域性hash表*/
		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;
}