korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2025-01-19 04:14:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

xfs: spilt xfs_dialloc() into 2 functions

Browse Source 
This patch explicitly separates free inode chunk allocation and
inode allocation into two individual high level operations.

Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Gao Xiang <hsiangkao@redhat.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
This commit is contained in:
Dave Chinner 2020-12-09 10:05:16 -08:00 committed by Darrick J. Wong
parent f3bf6e0f11
commit 8d822dc38a
3 changed files with 48 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
fs/xfs/libxfs/xfs_ialloc.c
View File

@ -1570,7 +1570,7 @@ xfs_dialloc_ag_update_inobt(
* The caller selected an AG for us, and made sure that free inodes are
* available.
*/
STATIC int
int
xfs_dialloc_ag(
struct xfs_trans *tp,
struct xfs_buf *agbp,
@ -1718,21 +1718,22 @@ xfs_dialloc_roll(
}
/*
* Allocate an inode on disk.
* Select and prepare an AG for inode allocation.
*
* Mode is used to tell whether the new inode will need space, and whether it
* is a directory.
* Mode is used to tell whether the new inode is a directory and hence where to
* locate it.
*
* Once we successfully pick an inode its number is returned and the on-disk
* data structures are updated. The inode itself is not read in, since doing so
* would break ordering constraints with xfs_reclaim.
* This function will ensure that the selected AG has free inodes available to
* allocate from. The selected AGI will be returned locked to the caller, and it
* will allocate more free inodes if required. If no free inodes are found or
* can be allocated, no AGI will be returned.
*/
int
xfs_dialloc(
xfs_dialloc_select_ag(
struct xfs_trans **tpp,
xfs_ino_t parent,
umode_t mode,
xfs_ino_t *inop)
struct xfs_buf **IO_agbp)
{
struct xfs_mount *mp = (*tpp)->t_mountp;
struct xfs_buf *agbp;
@ -1745,15 +1746,15 @@ xfs_dialloc(
struct xfs_ino_geometry *igeo = M_IGEO(mp);
bool okalloc = true;
*IO_agbp = NULL;
/*
* We do not have an agbp, so select an initial allocation
* group for inode allocation.
*/
start_agno = xfs_ialloc_ag_select(*tpp, parent, mode);
if (start_agno == NULLAGNUMBER) {
*inop = NULLFSINO;
if (start_agno == NULLAGNUMBER)
return 0;
}
/*
* If we have already hit the ceiling of inode blocks then clear
@ -1786,7 +1787,7 @@ xfs_dialloc(
if (!pag->pagi_init) {
error = xfs_ialloc_pagi_init(mp, *tpp, agno);
if (error)
goto out_error;
break;
}
/*
@ -1801,11 +1802,11 @@ xfs_dialloc(
*/
error = xfs_ialloc_read_agi(mp, *tpp, agno, &agbp);
if (error)
goto out_error;
break;
if (pag->pagi_freecount) {
xfs_perag_put(pag);
goto out_alloc;
goto found_ag;
}
if (!okalloc)
@ -1816,12 +1817,9 @@ xfs_dialloc(
if (error) {
xfs_trans_brelse(*tpp, agbp);
if (error != -ENOSPC)
goto out_error;
xfs_perag_put(pag);
*inop = NULLFSINO;
return 0;
if (error == -ENOSPC)
error = 0;
break;
}
if (ialloced) {
@ -1838,9 +1836,7 @@ xfs_dialloc(
xfs_buf_relse(agbp);
return error;
}
*inop = NULLFSINO;
goto out_alloc;
goto found_ag;
}
nextag_relse_buffer:
@ -1849,17 +1845,15 @@ nextag:
xfs_perag_put(pag);
if (++agno == mp->m_sb.sb_agcount)
agno = 0;
if (agno == start_agno) {
*inop = NULLFSINO;
if (agno == start_agno)
return noroom ? -ENOSPC : 0;
}
}
out_alloc:
return xfs_dialloc_ag(*tpp, agbp, parent, inop);
out_error:
xfs_perag_put(pag);
return error;
found_ag:
*IO_agbp = agbp;
return 0;
}
/*

20
fs/xfs/libxfs/xfs_ialloc.h
View File

@ -37,16 +37,26 @@ xfs_make_iptr(struct xfs_mount *mp, struct xfs_buf *b, int o)
* Mode is used to tell whether the new inode will need space, and whether
* it is a directory.
*
* Once we successfully pick an inode its number is returned and the
* on-disk data structures are updated. The inode itself is not read
* in, since doing so would break ordering constraints with xfs_reclaim.
* There are two phases to inode allocation: selecting an AG and ensuring
* that it contains free inodes, followed by allocating one of the free
* inodes. xfs_dialloc_select_ag() does the former and returns a locked AGI
* to the caller, ensuring that followup call to xfs_dialloc_ag() will
* have free inodes to allocate from. xfs_dialloc_ag() will return the inode
* number of the free inode we allocated.
*/
int /* error */
xfs_dialloc(
xfs_dialloc_select_ag(
struct xfs_trans **tpp, /* double pointer of transaction */
xfs_ino_t parent, /* parent inode (directory) */
umode_t mode, /* mode bits for new inode */
xfs_ino_t *inop); /* inode number allocated */
struct xfs_buf **IO_agbp);
int
xfs_dialloc_ag(
struct xfs_trans *tp,
struct xfs_buf *agbp,
xfs_ino_t parent,
xfs_ino_t *inop);
/*
* Free disk inode. Carefully avoids touching the incore inode, all

11
fs/xfs/xfs_inode.c
View File

@ -909,6 +909,7 @@ xfs_dir_ialloc(
prid_t prid,
struct xfs_inode **ipp)
{
struct xfs_buf *agibp;
xfs_ino_t parent_ino = dp ? dp->i_ino : 0;
xfs_ino_t ino;
int error;
@ -919,13 +920,19 @@ xfs_dir_ialloc(
* Call the space management code to pick the on-disk inode to be
* allocated.
*/
error = xfs_dialloc(tpp, parent_ino, mode, &ino);
error = xfs_dialloc_select_ag(tpp, parent_ino, mode, &agibp);
if (error)
return error;
if (ino == NULLFSINO)
if (!agibp)
return -ENOSPC;
/* Allocate an inode from the selected AG */
error = xfs_dialloc_ag(*tpp, agibp, parent_ino, &ino);
if (error)
return error;
ASSERT(ino != NULLFSINO);
return xfs_init_new_inode(*tpp, dp, ino, mode, nlink, rdev, prid, ipp);
}