Linux硬鏈接與軟連接實作對比-有解無憂

概述

linux系統中有一種比較特殊的檔案稱之為鏈接（link），通俗地說，鏈接就是從一個檔案指向另外一個檔案的路徑，linux中鏈接分為倆種，硬鏈接和軟鏈接，簡單來說，硬鏈接相當于源檔案和鏈接檔案在磁盤和記憶體中共享一個inode，因此，鏈接檔案和源檔案有不同的dentry，因此，這個特性決定了硬鏈接無法跨越檔案系統，而且我們無法為目錄創建硬鏈接，軟鏈接和硬鏈接不同，首先軟鏈接可以跨越檔案系統，其次，鏈接檔案和源檔案有著不同的inode和dentry，因此，兩個檔案的屬性和內容也截然不同，軟鏈接檔案的檔案內容是源檔案的檔案名，

在這里插入圖片描述

硬鏈接實作

看完前面的關于硬鏈接和軟鏈接的介紹以后，接下來我們仔細考究下linux內核中對硬鏈接和軟鏈接的實作，

使用strace工具，可以發現建立硬鏈接呼叫的函式是link()，該函式的內核入口為SYSCALL_DEFINE2()，其實就是sys_link()，我們就從這個入口開始一步步跟蹤實作原理，

SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname)
{
    return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
}

sys_link()其實呼叫了函式sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0)，

SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname,
int, newdfd, const char __user *, newname, int, flags)
{
    struct dentry *new_dentry;
    struct nameidata nd;
    struct path old_path;
    int error;
    char *to;

    if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
        return -EINVAL;
    error = user_path_at(olddfd, oldname,
		         flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
		        &old_path);
    if (error)
        return error;

    /* 查找目的鏈接名的父目錄的dentry */
    error = user_path_parent(newdfd, newname, &nd, &to);
    if (error)
        goto out;

    error = -EXDEV;
    /* 如果源和目的不是同一個檔案系統，則回傳錯誤 */	
    if (old_path.mnt != nd.path.mnt)
        goto out_release;

    /* 為鏈接檔案創建dentry結構 */
    new_dentry = lookup_create(&nd, 0);
    error = PTR_ERR(new_dentry);
    if (IS_ERR(new_dentry))
        goto out_unlock;
    error = mnt_want_write(nd.path.mnt);
    if (error)
        goto out_dput;
    error = security_path_link(old_path.dentry, &nd.path, new_dentry);
    if (error)
        goto out_drop_write;
    error = vfs_link(old_path.dentry, nd.path.dentry->d_inode, new_dentry);
    ...
    return error;
}

其實，我們仔細思考+上面的圖示可以明白，創建硬鏈接所做的事情主要包含：為鏈接檔案創建一個dentry，初始化（主要是指初始化其inode號）；將鏈接檔案的dentry寫入父目錄的資料塊中，因此，上面的代碼頁就顯得一目了然，代碼主要做的事情有：

合法性檢查，前面我們說硬鏈接不可跨越檔案系統，這是因為鏈接檔案和源檔案共用一個inode，而inode號在同一個檔案系統內才有意義；
獲取鏈接檔案父目錄的inode結構；
為鏈接檔案創建一個dentry結構；
等到一切準備作業就緒以后，初始化鏈接檔案dentry結構中的inode號，并添加到父目錄的資料塊中，

上述步驟中的1、2、3在上面的函式中均有對應，而步驟4的主要作業則是在vfs_link()中進行，其傳入的實參的意義也在代碼中作了較為詳細的說明，vfs_link()的實作如下：

int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
{
    struct inode *inode = old_dentry->d_inode;
    int error;

    if (!inode)
        return -ENOENT;

    /* 檢查是否有創建檔案目錄項權限 */
    error = may_create(dir, new_dentry);
    if (error)
        return error;

    if (dir->i_sb != inode->i_sb)
        return -EXDEV;

    if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
        return -EPERM;

    /* 呼叫具體檔案系統的link，如ext3_link() */
    if (!dir->i_op->link)
        return -EPERM;
    if (S_ISDIR(inode->i_mode))
        return -EPERM;

    error = security_inode_link(old_dentry, dir, new_dentry);
    if (error)
        return error;
    mutex_lock(&inode->i_mutex);
    error = dir->i_op->link(old_dentry, dir, new_dentry);
    mutex_unlock(&inode->i_mutex);
    if (!error)
        fsnotify_link(dir, inode, new_dentry);
     return error;
}

vfs_link()中主要完成一些引數檢查的任務，最終呼叫的是具體檔案系統的link實作，如ext3檔案系統的ext3_link()，

static int ext3_link (struct dentry * old_dentry,
		       struct inode * dir, struct dentry *dentry)
{
    handle_t *handle;
    struct inode *inode = old_dentry->d_inode;
    int err, retries = 0;

    /* 如果檔案上的鏈接數過多，回傳Too many links錯誤 */
    if (inode->i_nlink >= EXT3_LINK_MAX)
        return -EMLINK;

    dquot_initialize(dir);

    if (inode->i_nlink == 0)
        return -ENOENT;
retry:
    handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
					EXT3_INDEX_EXTRA_TRANS_BLOCKS);
    if (IS_ERR(handle))
        return PTR_ERR(handle);

    if (IS_DIRSYNC(dir))
        handle->h_sync = 1;

    inode->i_ctime = CURRENT_TIME_SEC;
    /* 將源檔案inode上的鏈接數 + 1 */
    inc_nlink(inode);
    atomic_inc(&inode->i_count);

    /* 將鏈接檔案的dentry寫入到其父目錄的資料塊中 */
    err = ext3_add_entry(handle, dentry, inode);
    if (!err) {
        ext3_mark_inode_dirty(handle, inode);
	d_instantiate(dentry, inode);
    } else {
	drop_nlink(inode);
	iput(inode);
    }
    ext3_journal_stop(handle);
    if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries))
        goto retry;
     return err;
}

在ext3_link()中完成鏈接的具體作業，拋開一些與日志相關的內容，我們可以看到主要呼叫了ext3_add_entry()來將鏈接檔案的dentry添加到父目錄的資料塊中，與此同時也會將源檔案的inode號記錄在鏈接檔案dentry中，這樣便達到了源檔案和鏈接檔案有著不同的dentry結構，卻共享inode的目的，

軟鏈接實作

使用strace工具，可以發現建立硬鏈接呼叫的函式是symlink()，該函式的內核入口為SYSCALL_DEFINE2(symlink,...)，其實就是sys_symlink()，我們就從這個入口開始一步步跟蹤內部實作原理，

SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newname)
{
    return sys_symlinkat(oldname, AT_FDCWD, newname);
}

sys_symlink()呼叫了函式sys_symlinkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0)，

SYSCALL_DEFINE3(symlinkat, const char __user *, oldname,
 int, newdfd, const char __user *, newname)
{
    ......
    from = getname(oldname);
    if (IS_ERR(from))
        return PTR_ERR(from);

    /* 查找軟鏈接父目錄結構，存于nd之中 */
    error = user_path_parent(newdfd, newname, &nd, &to);
    if (error)
        goto out_putname;

    /* 在上面查找的父目錄下創建軟連接dentry，作為回傳值 */
    dentry = lookup_create(&nd, 0);
    error = PTR_ERR(dentry);
    if (IS_ERR(dentry))
        goto out_unlock;

    error = mnt_want_write(nd.path.mnt);
    if (error)
        goto out_dput;
    error = security_path_symlink(&nd.path, dentry, from);
    if (error)
        goto out_drop_write;
 
    /* d_inode:鏈接檔案父目錄inode結構
     * dentry:鏈接檔案的dentry結構
     * from:源檔案名
     */
    error = vfs_symlink(nd.path.dentry->d_inode, dentry, from);
    ......
    return error;
}

通過代碼可以看到，其基本的函式呼叫流程和sys_linkat一模一樣，只是最后呼叫的是vfs_symlinkat，而且，引數的意義稍有不同，可參見代碼注釋：

/* 建立軟鏈接
 * @dir:軟連接父目錄inode
 * @dentry:軟連接的dentry
 * @oldname:源檔案或目錄的名字
 */
int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname)
{
    int error = may_create(dir, dentry);
    if (error)
        return error;

    if (!dir->i_op->symlink)
        return -EPERM;

    error = security_inode_symlink(dir, dentry, oldname);
    if (error)
        return error;

    error = dir->i_op->symlink(dir, dentry, oldname);
    if (!error)
	fsnotify_create(dir, dentry);

    return error;
}

最侄訓是呼叫了具體檔案系統的symlink函式，如ext3_symlink()，

//ext3建立軟連接函式
//@dir:軟連接的父目錄的inode
//@dentry:軟連接的dentry結構
//@symname:源檔案名稱
static int ext3_symlink (struct inode * dir,
		struct dentry *dentry, const char * symname)
{
    handle_t *handle;
    struct inode * inode;
    int l, err, retries = 0;
 
    l = strlen(symname)+1;
    if (l > dir->i_sb->s_blocksize)
        return -ENAMETOOLONG;
    dquot_initialize(dir);

retry:
    handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) +
					EXT3_INDEX_EXTRA_TRANS_BLOCKS + 5 +
					EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb));

    if (IS_ERR(handle))
        return PTR_ERR(handle);

    if (IS_DIRSYNC(dir))
	handle->h_sync = 1;

    // 為軟連接創建一個新的inode結構
    inode = ext3_new_inode (handle, dir, S_IFLNK|S_IRWXUGO);
    err = PTR_ERR(inode);
    if (IS_ERR(inode))
        goto out_stop;

    if (l > sizeof (EXT3_I(inode)->i_data)) {
	inode->i_op = &ext3_symlink_inode_operations;
	ext3_set_aops(inode);
	err = __page_symlink(inode, symname, l, 1);
        if (err) {
	  ......
	}
    } else {
        /* 如果源檔案名稱不夠長
         * 可直接將其保存在inode的i_data中
         */
	inode->i_op = &ext3_fast_symlink_inode_operations;
        memcpy((char*)&EXT3_I(inode)->i_data,symname,l);
        inode->i_size = l-1;
    }
    EXT3_I(inode)->i_disksize = inode->i_size;
    /* 將鏈接檔案的inode和dentry關聯并
     * 與其父目錄建立關聯
     */
    err = ext3_add_nondir(handle, dentry, inode);

out_stop:
    .....
}

分析ext3_symlink的實作，拋開日志等模塊不談，有以下幾個關鍵步驟：

代碼中會為鏈接檔案創建一個inode結構，這在函式ext3_new_inode()中實作，這也是硬鏈接和軟鏈接的最大不同；
鏈接檔案的檔案內容是源檔案的檔案名，而且，如果檔案名不是很長（小于60位元組），會將檔案名直接保存在inode中，無需為其分配資料塊；
最后會將鏈接檔案的inode與dentry建立關聯，并將鏈接檔案的dentry寫入到父目錄的資料塊中，呼叫的是函式ext3_add_nondir()，

Linux、C/C++技術交流群:【960994558】整理了一些個人覺得比較好的學習書籍、大廠面試題、和熱門技術教學視頻資料共享在里面（包括C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK等等.），有需要的可以自行添加哦！~ 在這里插入圖片描述

在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/253514.html

標籤：其他

上一篇：【Maven】學習筆記：自動化構建工具Maven

下一篇：Linux行程詳解