| Message ID | 20230118224505.1964941-43-david@fromorbit.com (mailing list archive) |
|---|---|
| State | Superseded, archived |
| Headers | show |
| Series | xfs: per-ag centric allocation alogrithms | expand |
On Thu, Jan 19, 2023 at 09:45:05AM +1100, Dave Chinner wrote: > From: Dave Chinner <dchinner@redhat.com> > > Now that the filestreams allocator is largely rewritten, > restructure the main entry point and pick function to seperate out > the different operations cleanly. The MRU lookup function should not > handle the start AG selection on MRU lookup failure, and nor should > the pick function handle building the association that is inserted > into the MRU. > > This leaves the filestreams allocator fairly clean and easy to > understand, returning to the caller with an active perag reference > and a target block to allocate at. > > Signed-off-by: Dave Chinner <dchinner@redhat.com> > --- > fs/xfs/xfs_filestream.c | 247 +++++++++++++++++++++------------------- > fs/xfs/xfs_trace.h | 9 +- > 2 files changed, 132 insertions(+), 124 deletions(-) > > diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c > index 523a3b8b5754..0a1d316ebdba 100644 > --- a/fs/xfs/xfs_filestream.c > +++ b/fs/xfs/xfs_filestream.c > @@ -48,19 +48,19 @@ xfs_fstrm_free_func( > } > > /* > - * Scan the AGs starting at startag looking for an AG that isn't in use and has > - * at least minlen blocks free. > + * Scan the AGs starting at start_agno looking for an AG that isn't in use and > + * has at least minlen blocks free. If no AG is found to match the allocation > + * requirements, pick the AG with the most free space in it. > */ > static int > xfs_filestream_pick_ag( > struct xfs_alloc_arg *args, > - struct xfs_inode *ip, > + xfs_ino_t pino, > xfs_agnumber_t start_agno, > int flags, > xfs_extlen_t *longest) > { > - struct xfs_mount *mp = ip->i_mount; > - struct xfs_fstrm_item *item; > + struct xfs_mount *mp = args->mp; > struct xfs_perag *pag; > struct xfs_perag *max_pag = NULL; > xfs_extlen_t minlen = *longest; > @@ -68,8 +68,6 @@ xfs_filestream_pick_ag( > xfs_agnumber_t agno; > int err, trylock; Who consumes trylock? Is this supposed to get passed through to xfs_bmap_longest_free_extent, or is the goal here merely to run the for_each_perag_wrap loop twice before going for the most free or any old perag? --D > - ASSERT(S_ISDIR(VFS_I(ip)->i_mode)); > - > /* 2% of an AG's blocks must be free for it to be chosen. */ > minfree = mp->m_sb.sb_agblocks / 50; > > @@ -78,7 +76,7 @@ xfs_filestream_pick_ag( > > restart: > for_each_perag_wrap(mp, start_agno, agno, pag) { > - trace_xfs_filestream_scan(pag, ip->i_ino); > + trace_xfs_filestream_scan(pag, pino); > *longest = 0; > err = xfs_bmap_longest_free_extent(pag, NULL, longest); > if (err) { > @@ -148,9 +146,9 @@ xfs_filestream_pick_ag( > * grab. > */ > if (!max_pag) { > - for_each_perag_wrap(mp, start_agno, agno, pag) > + for_each_perag_wrap(args->mp, 0, start_agno, args->pag) > break; > - atomic_inc(&pag->pagf_fstrms); > + atomic_inc(&args->pag->pagf_fstrms); > *longest = 0; > } else { > pag = max_pag; > @@ -161,44 +159,10 @@ xfs_filestream_pick_ag( > xfs_perag_rele(max_pag); > } > > - trace_xfs_filestream_pick(ip, pag, free); > - > - err = -ENOMEM; > - item = kmem_alloc(sizeof(*item), KM_MAYFAIL); > - if (!item) > - goto out_put_ag; > - > - > - /* > - * We are going to use this perag now, so take another ref to it for the > - * allocation context returned to the caller. If we raced to create and > - * insert the filestreams item into the MRU (-EEXIST), then we still > - * keep this reference but free the item reference we gained above. On > - * any other failure, we have to drop both. > - */ > - atomic_inc(&pag->pag_active_ref); > - item->pag = pag; > + trace_xfs_filestream_pick(pag, pino, free); > args->pag = pag; > - > - err = xfs_mru_cache_insert(mp->m_filestream, ip->i_ino, &item->mru); > - if (err) { > - if (err == -EEXIST) { > - err = 0; > - } else { > - xfs_perag_rele(args->pag); > - args->pag = NULL; > - } > - goto out_free_item; > - } > - > return 0; > > -out_free_item: > - kmem_free(item); > -out_put_ag: > - atomic_dec(&pag->pagf_fstrms); > - xfs_perag_rele(pag); > - return err; > } > > static struct xfs_inode * > @@ -227,29 +191,29 @@ xfs_filestream_get_parent( > > /* > * Lookup the mru cache for an existing association. If one exists and we can > - * use it, return with the agno and blen indicating that the allocation will > - * proceed with that association. > + * use it, return with an active perag reference indicating that the allocation > + * will proceed with that association. > * > * If we have no association, or we cannot use the current one and have to > - * destroy it, return with blen = 0 and agno pointing at the next agno to try. > + * destroy it, return with longest = 0 to tell the caller to create a new > + * association. > */ > -int > -xfs_filestream_select_ag_mru( > +static int > +xfs_filestream_lookup_association( > struct xfs_bmalloca *ap, > struct xfs_alloc_arg *args, > - struct xfs_inode *pip, > - xfs_agnumber_t *agno, > - xfs_extlen_t *blen) > + xfs_ino_t pino, > + xfs_extlen_t *longest) > { > - struct xfs_mount *mp = ap->ip->i_mount; > + struct xfs_mount *mp = args->mp; > struct xfs_perag *pag; > struct xfs_mru_cache_elem *mru; > - int error; > + int error = 0; > > - mru = xfs_mru_cache_lookup(mp->m_filestream, pip->i_ino); > + *longest = 0; > + mru = xfs_mru_cache_lookup(mp->m_filestream, pino); > if (!mru) > - goto out_default_agno; > - > + return 0; > /* > * Grab the pag and take an extra active reference for the caller whilst > * the mru item cannot go away. This means we'll pin the perag with > @@ -265,103 +229,148 @@ xfs_filestream_select_ag_mru( > ap->blkno = XFS_AGB_TO_FSB(args->mp, pag->pag_agno, 0); > xfs_bmap_adjacent(ap); > > - error = xfs_bmap_longest_free_extent(pag, args->tp, blen); > - if (error) { > - /* We aren't going to use this perag */ > - xfs_perag_rele(pag); > - if (error != -EAGAIN) > - return error; > - *blen = 0; > - } > - > /* > - * We are done if there's still enough contiguous free space to succeed. > * If there is very little free space before we start a filestreams > - * allocation, we're almost guaranteed to fail to find a better AG with > - * larger free space available so we don't even try. > + * allocation, we're almost guaranteed to fail to find a large enough > + * free space available so just use the cached AG. > */ > - *agno = pag->pag_agno; > - if (*blen >= args->maxlen || (ap->tp->t_flags & XFS_TRANS_LOWMODE)) { > - args->pag = pag; > - return 0; > + if (ap->tp->t_flags & XFS_TRANS_LOWMODE) { > + *longest = 1; > + goto out_done; > } > > + error = xfs_bmap_longest_free_extent(pag, args->tp, longest); > + if (error == -EAGAIN) > + error = 0; > + if (error || *longest < args->maxlen) { > + /* We aren't going to use this perag */ > + *longest = 0; > + xfs_perag_rele(pag); > + return error; > + } > + > +out_done: > + args->pag = pag; > + return 0; > +} > + > +static int > +xfs_filestream_create_association( > + struct xfs_bmalloca *ap, > + struct xfs_alloc_arg *args, > + xfs_ino_t pino, > + xfs_extlen_t *longest) > +{ > + struct xfs_mount *mp = args->mp; > + struct xfs_mru_cache_elem *mru; > + struct xfs_fstrm_item *item; > + xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, pino); > + int flags = 0; > + int error; > + > /* Changing parent AG association now, so remove the existing one. */ > - xfs_perag_rele(pag); > - mru = xfs_mru_cache_remove(mp->m_filestream, pip->i_ino); > + mru = xfs_mru_cache_remove(mp->m_filestream, pino); > if (mru) { > struct xfs_fstrm_item *item = > container_of(mru, struct xfs_fstrm_item, mru); > - *agno = (item->pag->pag_agno + 1) % mp->m_sb.sb_agcount; > - xfs_fstrm_free_func(mp, mru); > - return 0; > - } > > -out_default_agno: > - if (xfs_is_inode32(mp)) { > + agno = (item->pag->pag_agno + 1) % mp->m_sb.sb_agcount; > + xfs_fstrm_free_func(mp, mru); > + } else if (xfs_is_inode32(mp)) { > xfs_agnumber_t rotorstep = xfs_rotorstep; > - *agno = (mp->m_agfrotor / rotorstep) % > - mp->m_sb.sb_agcount; > + > + agno = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount; > mp->m_agfrotor = (mp->m_agfrotor + 1) % > (mp->m_sb.sb_agcount * rotorstep); > - return 0; > } > - *agno = XFS_INO_TO_AGNO(mp, pip->i_ino); > + > + ap->blkno = XFS_AGB_TO_FSB(args->mp, agno, 0); > + xfs_bmap_adjacent(ap); > + > + if (ap->datatype & XFS_ALLOC_USERDATA) > + flags |= XFS_PICK_USERDATA; > + if (ap->tp->t_flags & XFS_TRANS_LOWMODE) > + flags |= XFS_PICK_LOWSPACE; > + > + *longest = ap->length; > + error = xfs_filestream_pick_ag(args, pino, agno, flags, longest); > + if (error) > + return error; > + > + /* > + * We are going to use this perag now, so create an assoication for it. > + * xfs_filestream_pick_ag() has already bumped the perag fstrms counter > + * for us, so all we need to do here is take another active reference to > + * the perag for the cached association. > + * > + * If we fail to store the association, we need to drop the fstrms > + * counter as well as drop the perag reference we take here for the > + * item. We do not need to return an error for this failure - as long as > + * we return a referenced AG, the allocation can still go ahead just > + * fine. > + */ > + item = kmem_alloc(sizeof(*item), KM_MAYFAIL); > + if (!item) > + goto out_put_fstrms; > + > + atomic_inc(&args->pag->pag_active_ref); > + item->pag = args->pag; > + error = xfs_mru_cache_insert(mp->m_filestream, pino, &item->mru); > + if (error) > + goto out_free_item; > return 0; > > +out_free_item: > + xfs_perag_rele(item->pag); > + kmem_free(item); > +out_put_fstrms: > + atomic_dec(&args->pag->pagf_fstrms); > + return 0; > } > > /* > * Search for an allocation group with a single extent large enough for > - * the request. If one isn't found, then adjust the minimum allocation > - * size to the largest space found. > + * the request. First we look for an existing association and use that if it > + * is found. Otherwise, we create a new association by selecting an AG that fits > + * the allocation criteria. > + * > + * We return with a referenced perag in args->pag to indicate which AG we are > + * allocating into or an error with no references held. > */ > int > xfs_filestream_select_ag( > struct xfs_bmalloca *ap, > struct xfs_alloc_arg *args, > - xfs_extlen_t *blen) > + xfs_extlen_t *longest) > { > - struct xfs_mount *mp = ap->ip->i_mount; > - struct xfs_inode *pip = NULL; > - xfs_agnumber_t agno; > - int flags = 0; > + struct xfs_mount *mp = args->mp; > + struct xfs_inode *pip; > + xfs_ino_t ino = 0; > int error = 0; > > + *longest = 0; > args->total = ap->total; > - *blen = 0; > - > pip = xfs_filestream_get_parent(ap->ip); > - if (!pip) { > - ap->blkno = XFS_AGB_TO_FSB(mp, 0, 0); > - return 0; > + if (pip) { > + ino = pip->i_ino; > + error = xfs_filestream_lookup_association(ap, args, ino, > + longest); > + xfs_irele(pip); > + if (error) > + return error; > + if (*longest >= args->maxlen) > + goto out_select; > + if (ap->tp->t_flags & XFS_TRANS_LOWMODE) > + goto out_select; > } > > - error = xfs_filestream_select_ag_mru(ap, args, pip, &agno, blen); > + error = xfs_filestream_create_association(ap, args, ino, longest); > if (error) > - goto out_rele; > - if (*blen >= args->maxlen) > - goto out_select; > - if (ap->tp->t_flags & XFS_TRANS_LOWMODE) > - goto out_select; > - > - ap->blkno = XFS_AGB_TO_FSB(args->mp, agno, 0); > - xfs_bmap_adjacent(ap); > - *blen = ap->length; > - if (ap->datatype & XFS_ALLOC_USERDATA) > - flags |= XFS_PICK_USERDATA; > - if (ap->tp->t_flags & XFS_TRANS_LOWMODE) > - flags |= XFS_PICK_LOWSPACE; > + return error; > > - error = xfs_filestream_pick_ag(args, pip, agno, flags, blen); > - if (error) > - goto out_rele; > out_select: > ap->blkno = XFS_AGB_TO_FSB(mp, args->pag->pag_agno, 0); > -out_rele: > - xfs_irele(pip); > - return error; > - > + return 0; > } > > void > diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h > index b5f7d225d5b4..1d3569c0d2fe 100644 > --- a/fs/xfs/xfs_trace.h > +++ b/fs/xfs/xfs_trace.h > @@ -668,9 +668,8 @@ DEFINE_FILESTREAM_EVENT(xfs_filestream_lookup); > DEFINE_FILESTREAM_EVENT(xfs_filestream_scan); > > TRACE_EVENT(xfs_filestream_pick, > - TP_PROTO(struct xfs_inode *ip, struct xfs_perag *pag, > - xfs_extlen_t free), > - TP_ARGS(ip, pag, free), > + TP_PROTO(struct xfs_perag *pag, xfs_ino_t ino, xfs_extlen_t free), > + TP_ARGS(pag, ino, free), > TP_STRUCT__entry( > __field(dev_t, dev) > __field(xfs_ino_t, ino) > @@ -679,8 +678,8 @@ TRACE_EVENT(xfs_filestream_pick, > __field(xfs_extlen_t, free) > ), > TP_fast_assign( > - __entry->dev = VFS_I(ip)->i_sb->s_dev; > - __entry->ino = ip->i_ino; > + __entry->dev = pag->pag_mount->m_super->s_dev; > + __entry->ino = ino; > if (pag) { > __entry->agno = pag->pag_agno; > __entry->streams = atomic_read(&pag->pagf_fstrms); > -- > 2.39.0 >
On Wed, Feb 01, 2023 at 04:08:48PM -0800, Darrick J. Wong wrote: > On Thu, Jan 19, 2023 at 09:45:05AM +1100, Dave Chinner wrote: > > From: Dave Chinner <dchinner@redhat.com> > > > > Now that the filestreams allocator is largely rewritten, > > restructure the main entry point and pick function to seperate out > > the different operations cleanly. The MRU lookup function should not > > handle the start AG selection on MRU lookup failure, and nor should > > the pick function handle building the association that is inserted > > into the MRU. > > > > This leaves the filestreams allocator fairly clean and easy to > > understand, returning to the caller with an active perag reference > > and a target block to allocate at. > > > > Signed-off-by: Dave Chinner <dchinner@redhat.com> > > --- > > fs/xfs/xfs_filestream.c | 247 +++++++++++++++++++++------------------- > > fs/xfs/xfs_trace.h | 9 +- > > 2 files changed, 132 insertions(+), 124 deletions(-) > > > > diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c > > index 523a3b8b5754..0a1d316ebdba 100644 > > --- a/fs/xfs/xfs_filestream.c > > +++ b/fs/xfs/xfs_filestream.c > > @@ -48,19 +48,19 @@ xfs_fstrm_free_func( > > } > > > > /* > > - * Scan the AGs starting at startag looking for an AG that isn't in use and has > > - * at least minlen blocks free. > > + * Scan the AGs starting at start_agno looking for an AG that isn't in use and > > + * has at least minlen blocks free. If no AG is found to match the allocation > > + * requirements, pick the AG with the most free space in it. > > */ > > static int > > xfs_filestream_pick_ag( > > struct xfs_alloc_arg *args, > > - struct xfs_inode *ip, > > + xfs_ino_t pino, > > xfs_agnumber_t start_agno, > > int flags, > > xfs_extlen_t *longest) > > { > > - struct xfs_mount *mp = ip->i_mount; > > - struct xfs_fstrm_item *item; > > + struct xfs_mount *mp = args->mp; > > struct xfs_perag *pag; > > struct xfs_perag *max_pag = NULL; > > xfs_extlen_t minlen = *longest; > > @@ -68,8 +68,6 @@ xfs_filestream_pick_ag( > > xfs_agnumber_t agno; > > int err, trylock; > > Who consumes trylock? Is this supposed to get passed through to > xfs_bmap_longest_free_extent, or is the goal here merely to run the > for_each_perag_wrap loop twice before going for the most free or any old > perag? It was originally used in this loop for directing the AGF locking, but it looks like I removed all the cases where we we directly read and lock AGFs in this loop. Hence it's now only used to run the loop a second time. I'll change it to a boolean flag instead. -Dave.
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c index 523a3b8b5754..0a1d316ebdba 100644 --- a/fs/xfs/xfs_filestream.c +++ b/fs/xfs/xfs_filestream.c @@ -48,19 +48,19 @@ xfs_fstrm_free_func( } /* - * Scan the AGs starting at startag looking for an AG that isn't in use and has - * at least minlen blocks free. + * Scan the AGs starting at start_agno looking for an AG that isn't in use and + * has at least minlen blocks free. If no AG is found to match the allocation + * requirements, pick the AG with the most free space in it. */ static int xfs_filestream_pick_ag( struct xfs_alloc_arg *args, - struct xfs_inode *ip, + xfs_ino_t pino, xfs_agnumber_t start_agno, int flags, xfs_extlen_t *longest) { - struct xfs_mount *mp = ip->i_mount; - struct xfs_fstrm_item *item; + struct xfs_mount *mp = args->mp; struct xfs_perag *pag; struct xfs_perag *max_pag = NULL; xfs_extlen_t minlen = *longest; @@ -68,8 +68,6 @@ xfs_filestream_pick_ag( xfs_agnumber_t agno; int err, trylock; - ASSERT(S_ISDIR(VFS_I(ip)->i_mode)); - /* 2% of an AG's blocks must be free for it to be chosen. */ minfree = mp->m_sb.sb_agblocks / 50; @@ -78,7 +76,7 @@ xfs_filestream_pick_ag( restart: for_each_perag_wrap(mp, start_agno, agno, pag) { - trace_xfs_filestream_scan(pag, ip->i_ino); + trace_xfs_filestream_scan(pag, pino); *longest = 0; err = xfs_bmap_longest_free_extent(pag, NULL, longest); if (err) { @@ -148,9 +146,9 @@ xfs_filestream_pick_ag( * grab. */ if (!max_pag) { - for_each_perag_wrap(mp, start_agno, agno, pag) + for_each_perag_wrap(args->mp, 0, start_agno, args->pag) break; - atomic_inc(&pag->pagf_fstrms); + atomic_inc(&args->pag->pagf_fstrms); *longest = 0; } else { pag = max_pag; @@ -161,44 +159,10 @@ xfs_filestream_pick_ag( xfs_perag_rele(max_pag); } - trace_xfs_filestream_pick(ip, pag, free); - - err = -ENOMEM; - item = kmem_alloc(sizeof(*item), KM_MAYFAIL); - if (!item) - goto out_put_ag; - - - /* - * We are going to use this perag now, so take another ref to it for the - * allocation context returned to the caller. If we raced to create and - * insert the filestreams item into the MRU (-EEXIST), then we still - * keep this reference but free the item reference we gained above. On - * any other failure, we have to drop both. - */ - atomic_inc(&pag->pag_active_ref); - item->pag = pag; + trace_xfs_filestream_pick(pag, pino, free); args->pag = pag; - - err = xfs_mru_cache_insert(mp->m_filestream, ip->i_ino, &item->mru); - if (err) { - if (err == -EEXIST) { - err = 0; - } else { - xfs_perag_rele(args->pag); - args->pag = NULL; - } - goto out_free_item; - } - return 0; -out_free_item: - kmem_free(item); -out_put_ag: - atomic_dec(&pag->pagf_fstrms); - xfs_perag_rele(pag); - return err; } static struct xfs_inode * @@ -227,29 +191,29 @@ xfs_filestream_get_parent( /* * Lookup the mru cache for an existing association. If one exists and we can - * use it, return with the agno and blen indicating that the allocation will - * proceed with that association. + * use it, return with an active perag reference indicating that the allocation + * will proceed with that association. * * If we have no association, or we cannot use the current one and have to - * destroy it, return with blen = 0 and agno pointing at the next agno to try. + * destroy it, return with longest = 0 to tell the caller to create a new + * association. */ -int -xfs_filestream_select_ag_mru( +static int +xfs_filestream_lookup_association( struct xfs_bmalloca *ap, struct xfs_alloc_arg *args, - struct xfs_inode *pip, - xfs_agnumber_t *agno, - xfs_extlen_t *blen) + xfs_ino_t pino, + xfs_extlen_t *longest) { - struct xfs_mount *mp = ap->ip->i_mount; + struct xfs_mount *mp = args->mp; struct xfs_perag *pag; struct xfs_mru_cache_elem *mru; - int error; + int error = 0; - mru = xfs_mru_cache_lookup(mp->m_filestream, pip->i_ino); + *longest = 0; + mru = xfs_mru_cache_lookup(mp->m_filestream, pino); if (!mru) - goto out_default_agno; - + return 0; /* * Grab the pag and take an extra active reference for the caller whilst * the mru item cannot go away. This means we'll pin the perag with @@ -265,103 +229,148 @@ xfs_filestream_select_ag_mru( ap->blkno = XFS_AGB_TO_FSB(args->mp, pag->pag_agno, 0); xfs_bmap_adjacent(ap); - error = xfs_bmap_longest_free_extent(pag, args->tp, blen); - if (error) { - /* We aren't going to use this perag */ - xfs_perag_rele(pag); - if (error != -EAGAIN) - return error; - *blen = 0; - } - /* - * We are done if there's still enough contiguous free space to succeed. * If there is very little free space before we start a filestreams - * allocation, we're almost guaranteed to fail to find a better AG with - * larger free space available so we don't even try. + * allocation, we're almost guaranteed to fail to find a large enough + * free space available so just use the cached AG. */ - *agno = pag->pag_agno; - if (*blen >= args->maxlen || (ap->tp->t_flags & XFS_TRANS_LOWMODE)) { - args->pag = pag; - return 0; + if (ap->tp->t_flags & XFS_TRANS_LOWMODE) { + *longest = 1; + goto out_done; } + error = xfs_bmap_longest_free_extent(pag, args->tp, longest); + if (error == -EAGAIN) + error = 0; + if (error || *longest < args->maxlen) { + /* We aren't going to use this perag */ + *longest = 0; + xfs_perag_rele(pag); + return error; + } + +out_done: + args->pag = pag; + return 0; +} + +static int +xfs_filestream_create_association( + struct xfs_bmalloca *ap, + struct xfs_alloc_arg *args, + xfs_ino_t pino, + xfs_extlen_t *longest) +{ + struct xfs_mount *mp = args->mp; + struct xfs_mru_cache_elem *mru; + struct xfs_fstrm_item *item; + xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, pino); + int flags = 0; + int error; + /* Changing parent AG association now, so remove the existing one. */ - xfs_perag_rele(pag); - mru = xfs_mru_cache_remove(mp->m_filestream, pip->i_ino); + mru = xfs_mru_cache_remove(mp->m_filestream, pino); if (mru) { struct xfs_fstrm_item *item = container_of(mru, struct xfs_fstrm_item, mru); - *agno = (item->pag->pag_agno + 1) % mp->m_sb.sb_agcount; - xfs_fstrm_free_func(mp, mru); - return 0; - } -out_default_agno: - if (xfs_is_inode32(mp)) { + agno = (item->pag->pag_agno + 1) % mp->m_sb.sb_agcount; + xfs_fstrm_free_func(mp, mru); + } else if (xfs_is_inode32(mp)) { xfs_agnumber_t rotorstep = xfs_rotorstep; - *agno = (mp->m_agfrotor / rotorstep) % - mp->m_sb.sb_agcount; + + agno = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount; mp->m_agfrotor = (mp->m_agfrotor + 1) % (mp->m_sb.sb_agcount * rotorstep); - return 0; } - *agno = XFS_INO_TO_AGNO(mp, pip->i_ino); + + ap->blkno = XFS_AGB_TO_FSB(args->mp, agno, 0); + xfs_bmap_adjacent(ap); + + if (ap->datatype & XFS_ALLOC_USERDATA) + flags |= XFS_PICK_USERDATA; + if (ap->tp->t_flags & XFS_TRANS_LOWMODE) + flags |= XFS_PICK_LOWSPACE; + + *longest = ap->length; + error = xfs_filestream_pick_ag(args, pino, agno, flags, longest); + if (error) + return error; + + /* + * We are going to use this perag now, so create an assoication for it. + * xfs_filestream_pick_ag() has already bumped the perag fstrms counter + * for us, so all we need to do here is take another active reference to + * the perag for the cached association. + * + * If we fail to store the association, we need to drop the fstrms + * counter as well as drop the perag reference we take here for the + * item. We do not need to return an error for this failure - as long as + * we return a referenced AG, the allocation can still go ahead just + * fine. + */ + item = kmem_alloc(sizeof(*item), KM_MAYFAIL); + if (!item) + goto out_put_fstrms; + + atomic_inc(&args->pag->pag_active_ref); + item->pag = args->pag; + error = xfs_mru_cache_insert(mp->m_filestream, pino, &item->mru); + if (error) + goto out_free_item; return 0; +out_free_item: + xfs_perag_rele(item->pag); + kmem_free(item); +out_put_fstrms: + atomic_dec(&args->pag->pagf_fstrms); + return 0; } /* * Search for an allocation group with a single extent large enough for - * the request. If one isn't found, then adjust the minimum allocation - * size to the largest space found. + * the request. First we look for an existing association and use that if it + * is found. Otherwise, we create a new association by selecting an AG that fits + * the allocation criteria. + * + * We return with a referenced perag in args->pag to indicate which AG we are + * allocating into or an error with no references held. */ int xfs_filestream_select_ag( struct xfs_bmalloca *ap, struct xfs_alloc_arg *args, - xfs_extlen_t *blen) + xfs_extlen_t *longest) { - struct xfs_mount *mp = ap->ip->i_mount; - struct xfs_inode *pip = NULL; - xfs_agnumber_t agno; - int flags = 0; + struct xfs_mount *mp = args->mp; + struct xfs_inode *pip; + xfs_ino_t ino = 0; int error = 0; + *longest = 0; args->total = ap->total; - *blen = 0; - pip = xfs_filestream_get_parent(ap->ip); - if (!pip) { - ap->blkno = XFS_AGB_TO_FSB(mp, 0, 0); - return 0; + if (pip) { + ino = pip->i_ino; + error = xfs_filestream_lookup_association(ap, args, ino, + longest); + xfs_irele(pip); + if (error) + return error; + if (*longest >= args->maxlen) + goto out_select; + if (ap->tp->t_flags & XFS_TRANS_LOWMODE) + goto out_select; } - error = xfs_filestream_select_ag_mru(ap, args, pip, &agno, blen); + error = xfs_filestream_create_association(ap, args, ino, longest); if (error) - goto out_rele; - if (*blen >= args->maxlen) - goto out_select; - if (ap->tp->t_flags & XFS_TRANS_LOWMODE) - goto out_select; - - ap->blkno = XFS_AGB_TO_FSB(args->mp, agno, 0); - xfs_bmap_adjacent(ap); - *blen = ap->length; - if (ap->datatype & XFS_ALLOC_USERDATA) - flags |= XFS_PICK_USERDATA; - if (ap->tp->t_flags & XFS_TRANS_LOWMODE) - flags |= XFS_PICK_LOWSPACE; + return error; - error = xfs_filestream_pick_ag(args, pip, agno, flags, blen); - if (error) - goto out_rele; out_select: ap->blkno = XFS_AGB_TO_FSB(mp, args->pag->pag_agno, 0); -out_rele: - xfs_irele(pip); - return error; - + return 0; } void diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h index b5f7d225d5b4..1d3569c0d2fe 100644 --- a/fs/xfs/xfs_trace.h +++ b/fs/xfs/xfs_trace.h @@ -668,9 +668,8 @@ DEFINE_FILESTREAM_EVENT(xfs_filestream_lookup); DEFINE_FILESTREAM_EVENT(xfs_filestream_scan); TRACE_EVENT(xfs_filestream_pick, - TP_PROTO(struct xfs_inode *ip, struct xfs_perag *pag, - xfs_extlen_t free), - TP_ARGS(ip, pag, free), + TP_PROTO(struct xfs_perag *pag, xfs_ino_t ino, xfs_extlen_t free), + TP_ARGS(pag, ino, free), TP_STRUCT__entry( __field(dev_t, dev) __field(xfs_ino_t, ino) @@ -679,8 +678,8 @@ TRACE_EVENT(xfs_filestream_pick, __field(xfs_extlen_t, free) ), TP_fast_assign( - __entry->dev = VFS_I(ip)->i_sb->s_dev; - __entry->ino = ip->i_ino; + __entry->dev = pag->pag_mount->m_super->s_dev; + __entry->ino = ino; if (pag) { __entry->agno = pag->pag_agno; __entry->streams = atomic_read(&pag->pagf_fstrms);