Quelle  xfs_filestream.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2006-2007 Silicon Graphics, Inc.
 * Copyright (c) 2014 Christoph Hellwig.
 * All Rights Reserved.
 */
#include "xfs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
#include "xfs_bmap.h"
#include "xfs_bmap_util.h"
#include "xfs_alloc.h"
#include "xfs_mru_cache.h"
#include "xfs_trace.h"
#include "xfs_ag.h"
#include "xfs_ag_resv.h"
#include "xfs_trans.h"
#include "xfs_filestream.h"

struct xfs_fstrm_item {
 struct xfs_mru_cache_elem mru;
 struct xfs_perag  *pag; /* AG in use for this directory */
};

enum xfs_fstrm_alloc {
 XFS_PICK_USERDATA = 1,
 XFS_PICK_LOWSPACE = 2,
};

static void
xfs_fstrm_free_func(
 void   *data,
 struct xfs_mru_cache_elem *mru)
{
 struct xfs_fstrm_item *item =
  container_of(mru, struct xfs_fstrm_item, mru);
 struct xfs_perag *pag = item->pag;

 trace_xfs_filestream_free(pag, mru->key);
 atomic_dec(&pag->pagf_fstrms);
 xfs_perag_rele(pag);

 kfree(item);
}

/*
 * 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,
 xfs_ino_t  pino,
 xfs_agnumber_t  start_agno,
 int   flags,
 xfs_extlen_t  *longest)
{
 struct xfs_mount *mp = args->mp;
 struct xfs_perag *pag;
 struct xfs_perag *max_pag = NULL;
 xfs_extlen_t  minlen = *longest;
 xfs_extlen_t  minfree, maxfree = 0;
 xfs_agnumber_t  agno;
 bool   first_pass = true;

 /* 2% of an AG's blocks must be free for it to be chosen. */
 minfree = mp->m_sb.sb_agblocks / 50;

restart:
 for_each_perag_wrap(mp, start_agno, agno, pag) {
  int  err;

  trace_xfs_filestream_scan(pag, pino);

  *longest = 0;
  err = xfs_bmap_longest_free_extent(pag, NULL, longest);
  if (err) {
   if (err == -EAGAIN) {
    /* Couldn't lock the AGF, skip this AG. */
    err = 0;
    continue;
   }
   xfs_perag_rele(pag);
   if (max_pag)
    xfs_perag_rele(max_pag);
   return err;
  }

  /* Keep track of the AG with the most free blocks. */
  if (pag->pagf_freeblks > maxfree) {
   maxfree = pag->pagf_freeblks;
   if (max_pag)
    xfs_perag_rele(max_pag);
   atomic_inc(&pag_group(pag)->xg_active_ref);
   max_pag = pag;
  }

  /*
   * The AG reference count does two things: it enforces mutual
   * exclusion when examining the suitability of an AG in this
   * loop, and it guards against two filestreams being established
   * in the same AG as each other.
 */
  if (atomic_inc_return(&pag->pagf_fstrms) <= 1) {
   if (((minlen && *longest >= minlen) ||
        (!minlen && pag->pagf_freeblks >= minfree)) &&
       (!xfs_perag_prefers_metadata(pag) ||
        !(flags & XFS_PICK_USERDATA) ||
        (flags & XFS_PICK_LOWSPACE))) {
    /* Break out, retaining the reference on the AG. */
    if (max_pag)
     xfs_perag_rele(max_pag);
    goto done;
   }
  }

  /* Drop the reference on this AG, it's not usable. */
  atomic_dec(&pag->pagf_fstrms);
 }

 /*
  * Allow a second pass to give xfs_bmap_longest_free_extent() another
  * attempt at locking AGFs that it might have skipped over before we
  * fail.
 */
 if (first_pass) {
  first_pass = false;
  goto restart;
 }

 /*
  * We must be low on data space, so run a final lowspace optimised
  * selection pass if we haven't already.
 */
 if (!(flags & XFS_PICK_LOWSPACE)) {
  flags |= XFS_PICK_LOWSPACE;
  goto restart;
 }

 /*
  * No unassociated AGs are available, so select the AG with the most
  * free space, regardless of whether it's already in use by another
  * filestream. It none suit, just use whatever AG we can grab.
 */
 if (!max_pag) {
  for_each_perag_wrap(args->mp, 0, start_agno, pag) {
   max_pag = pag;
   break;
  }

  /* Bail if there are no AGs at all to select from. */
  if (!max_pag)
   return -ENOSPC;
 }

 pag = max_pag;
 atomic_inc(&pag->pagf_fstrms);
done:
 trace_xfs_filestream_pick(pag, pino);
 args->pag = pag;
 return 0;
}

static struct xfs_inode *
xfs_filestream_get_parent(
 struct xfs_inode *ip)
{
 struct inode  *inode = VFS_I(ip), *dir = NULL;
 struct dentry  *dentry, *parent;

 dentry = d_find_alias(inode);
 if (!dentry)
  goto out;

 parent = dget_parent(dentry);
 if (!parent)
  goto out_dput;

 dir = igrab(d_inode(parent));
 dput(parent);

out_dput:
 dput(dentry);
out:
 return dir ? XFS_I(dir) : NULL;
}

/*
 * Lookup the mru cache for an existing association. If one exists and we can
 * 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 longest = 0 to tell the caller to create a new
 * association.
 */
static int
xfs_filestream_lookup_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_perag *pag;
 struct xfs_mru_cache_elem *mru;
 int   error = 0;

 *longest = 0;
 mru = xfs_mru_cache_lookup(mp->m_filestream, pino);
 if (!mru)
  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
  * the reference we get here even if the filestreams association is torn
  * down immediately after we mark the lookup as done.
 */
 pag = container_of(mru, struct xfs_fstrm_item, mru)->pag;
 atomic_inc(&pag_group(pag)->xg_active_ref);
 xfs_mru_cache_done(mp->m_filestream);

 trace_xfs_filestream_lookup(pag, ap->ip->i_ino);

 ap->blkno = xfs_agbno_to_fsb(pag, 0);
 xfs_bmap_adjacent(ap);

 /*
  * If there is very little free space before we start a filestreams
  * allocation, we're almost guaranteed to fail to find a large enough
  * free space available so just use the cached AG.
 */
 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. */
 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 = (pag_agno(item->pag) + 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;
  mp->m_agfrotor = (mp->m_agfrotor + 1) %
     (mp->m_sb.sb_agcount * rotorstep);
 }

 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 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 = kmalloc(sizeof(*item), GFP_KERNEL | __GFP_RETRY_MAYFAIL);
 if (!item)
  goto out_put_fstrms;

 atomic_inc(&pag_group(args->pag)->xg_active_ref);
 item->pag = args->pag;
 xfs_mru_cache_insert(mp->m_filestream, pino, &item->mru);
 return 0;

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. 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  *longest)
{
 struct xfs_inode *pip;
 xfs_ino_t  ino = 0;
 int   error = 0;

 *longest = 0;
 args->total = ap->total;
 pip = xfs_filestream_get_parent(ap->ip);
 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_create_association(ap, args, ino, longest);
 if (error)
  return error;

out_select:
 ap->blkno = xfs_agbno_to_fsb(args->pag, 0);
 return 0;
}

void
xfs_filestream_deassociate(
 struct xfs_inode *ip)
{
 xfs_mru_cache_delete(ip->i_mount->m_filestream, ip->i_ino);
}

int
xfs_filestream_mount(
 xfs_mount_t *mp)
{
 /*
  * The filestream timer tunable is currently fixed within the range of
  * one second to four minutes, with five seconds being the default.  The
  * group count is somewhat arbitrary, but it'd be nice to adhere to the
  * timer tunable to within about 10 percent.  This requires at least 10
  * groups.
 */
 return xfs_mru_cache_create(&mp->m_filestream, mp,
   xfs_fstrm_centisecs * 10, 10, xfs_fstrm_free_func);
}

void
xfs_filestream_unmount(
 xfs_mount_t *mp)
{
 xfs_mru_cache_destroy(mp->m_filestream);
}