xfs_agnumber_t
xfs_filestream_lookup_ag(
xfs_inode_t *ip)
{
xfs_mru_cache_t *cache;
fstrm_item_t *item;
xfs_agnumber_t ag;
int ref;
if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
ASSERT(0);
return NULLAGNUMBER;
}
cache = ip->i_mount->m_filestream;
item = xfs_mru_cache_lookup(cache, ip->i_ino);
if (!item) {
TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
return NULLAGNUMBER;
}
ASSERT(ip == item->ip);
ag = item->ag;
ref = xfs_filestream_peek_ag(ip->i_mount, ag);
xfs_mru_cache_done(cache);
TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
return ag;
}
/*
* Find the right allocation group for a file, either by finding an
* existing file stream or creating a new one.
*
* Returns NULLAGNUMBER in case of an error.
*/
xfs_agnumber_t
xfs_filestream_lookup_ag(
struct xfs_inode *ip)
{
struct xfs_mount *mp = ip->i_mount;
struct xfs_inode *pip = NULL;
xfs_agnumber_t startag, ag = NULLAGNUMBER;
struct xfs_mru_cache_elem *mru;
ASSERT(S_ISREG(ip->i_d.di_mode));
pip = xfs_filestream_get_parent(ip);
if (!pip)
goto out;
mru = xfs_mru_cache_lookup(mp->m_filestream, pip->i_ino);
if (mru) {
ag = container_of(mru, struct xfs_fstrm_item, mru)->ag;
xfs_mru_cache_done(mp->m_filestream);
trace_xfs_filestream_lookup(ip, ag);
goto out;
}
/*
* Set the starting AG using the rotor for inode32, otherwise
* use the directory inode's AG.
*/
if (mp->m_flags & XFS_MOUNT_32BITINODES) {
xfs_agnumber_t rotorstep = xfs_rotorstep;
startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
mp->m_agfrotor = (mp->m_agfrotor + 1) %
(mp->m_sb.sb_agcount * rotorstep);
} else
startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
if (xfs_filestream_pick_ag(pip, startag, &ag, 0, 0))
ag = NULLAGNUMBER;
out:
IRELE(pip);
return ag;
}
int
xfs_filestream_new_ag(
xfs_bmalloca_t *ap,
xfs_agnumber_t *agp)
{
int flags, err;
xfs_inode_t *ip, *pip = NULL;
xfs_mount_t *mp;
xfs_mru_cache_t *cache;
xfs_extlen_t minlen;
fstrm_item_t *dir, *file;
xfs_agnumber_t ag = NULLAGNUMBER;
ip = ap->ip;
mp = ip->i_mount;
cache = mp->m_filestream;
minlen = ap->alen;
*agp = NULLAGNUMBER;
/*
* Look for the file in the cache, removing it if it's found. Doing
* this allows it to be held across the dir lookup that follows.
*/
file = xfs_mru_cache_remove(cache, ip->i_ino);
if (file) {
ASSERT(ip == file->ip);
/* Save the file's parent inode and old AG number for later. */
pip = file->pip;
ag = file->ag;
/* Look for the file's directory in the cache. */
dir = xfs_mru_cache_lookup(cache, pip->i_ino);
if (dir) {
ASSERT(pip == dir->ip);
/*
* If the directory has already moved on to a new AG,
* use that AG as the new AG for the file. Don't
* forget to twiddle the AG refcounts to match the
* movement.
*/
if (dir->ag != file->ag) {
xfs_filestream_put_ag(mp, file->ag);
xfs_filestream_get_ag(mp, dir->ag);
*agp = file->ag = dir->ag;
}
xfs_mru_cache_done(cache);
}
/*
* Put the file back in the cache. If this fails, the free
* function needs to be called to tidy up in the same way as if
* the item had simply expired from the cache.
*/
err = xfs_mru_cache_insert(cache, ip->i_ino, file);
if (err) {
xfs_fstrm_free_func(ip->i_ino, file);
return err;
}
/*
* If the file's AG was moved to the directory's new AG, there's
* nothing more to be done.
*/
if (*agp != NULLAGNUMBER) {
TRACE_MOVEAG(mp, ip, pip,
ag, xfs_filestream_peek_ag(mp, ag),
*agp, xfs_filestream_peek_ag(mp, *agp));
return 0;
}
}
/*
* If the file's parent directory is known, take its iolock in exclusive
* mode to prevent two sibling files from racing each other to migrate
* themselves and their parent to different AGs.
*/
if (pip)
xfs_ilock(pip, XFS_IOLOCK_EXCL);
/*
* A new AG needs to be found for the file. If the file's parent
* directory is also known, it will be moved to the new AG as well to
* ensure that files created inside it in future use the new AG.
*/
ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
(ap->low ? XFS_PICK_LOWSPACE : 0);
err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
if (err || *agp == NULLAGNUMBER)
goto exit;
/*
* If the file wasn't found in the file cache, then its parent directory
* inode isn't known. For this to have happened, the file must either
* be pre-existing, or it was created long enough ago that its cache
* entry has expired. This isn't the sort of usage that the filestreams
* allocator is trying to optimise, so there's no point trying to track
* its new AG somehow in the filestream data structures.
*/
if (!pip) {
TRACE_ORPHAN(mp, ip, *agp);
goto exit;
}
/* Associate the parent inode with the AG. */
err = _xfs_filestream_update_ag(pip, NULL, *agp);
if (err)
goto exit;
/* Associate the file inode with the AG. */
err = _xfs_filestream_update_ag(ip, pip, *agp);
if (err)
goto exit;
TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
*agp, xfs_filestream_peek_ag(mp, *agp));
exit:
/*
* If _xfs_filestream_pick_ag() returned a valid AG, remove the
* reference it took on it, since the file and directory will have taken
* their own now if they were successfully cached.
*/
if (*agp != NULLAGNUMBER)
xfs_filestream_put_ag(mp, *agp);
else
*agp = 0;
if (pip)
xfs_iunlock(pip, XFS_IOLOCK_EXCL);
return err;
}
int
xfs_filestream_associate(
xfs_inode_t *pip,
xfs_inode_t *ip)
{
xfs_mount_t *mp;
xfs_mru_cache_t *cache;
fstrm_item_t *item;
xfs_agnumber_t ag, rotorstep, startag;
int err = 0;
ASSERT(pip->i_d.di_mode & S_IFDIR);
ASSERT(ip->i_d.di_mode & S_IFREG);
if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
return -EINVAL;
mp = pip->i_mount;
cache = mp->m_filestream;
/*
* We have a problem, Houston.
*
* Taking the iolock here violates inode locking order - we already
* hold the ilock. Hence if we block getting this lock we may never
* wake. Unfortunately, that means if we can't get the lock, we're
* screwed in terms of getting a stream association - we can't spin
* waiting for the lock because someone else is waiting on the lock we
* hold and we cannot drop that as we are in a transaction here.
*
* Lucky for us, this inversion is not a problem because it's a
* directory inode that we are trying to lock here.
*
* So, if we can't get the iolock without sleeping then just give up
*/
if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL))
return 1;
/* If the parent directory is already in the cache, use its AG. */
item = xfs_mru_cache_lookup(cache, pip->i_ino);
if (item) {
ASSERT(item->ip == pip);
ag = item->ag;
xfs_mru_cache_done(cache);
TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
err = _xfs_filestream_update_ag(ip, pip, ag);
goto exit;
}
/*
* Set the starting AG using the rotor for inode32, otherwise
* use the directory inode's AG.
*/
if (mp->m_flags & XFS_MOUNT_32BITINODES) {
rotorstep = xfs_rotorstep;
startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
mp->m_agfrotor = (mp->m_agfrotor + 1) %
(mp->m_sb.sb_agcount * rotorstep);
} else
startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
/* Pick a new AG for the parent inode starting at startag. */
err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
if (err || ag == NULLAGNUMBER)
goto exit_did_pick;
/* Associate the parent inode with the AG. */
err = _xfs_filestream_update_ag(pip, NULL, ag);
if (err)
goto exit_did_pick;
/* Associate the file inode with the AG. */
err = _xfs_filestream_update_ag(ip, pip, ag);
if (err)
goto exit_did_pick;
TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
exit_did_pick:
/*
* If _xfs_filestream_pick_ag() returned a valid AG, remove the
* reference it took on it, since the file and directory will have taken
* their own now if they were successfully cached.
*/
if (ag != NULLAGNUMBER)
xfs_filestream_put_ag(mp, ag);
exit:
xfs_iunlock(pip, XFS_IOLOCK_EXCL);
return -err;
}
static int
_xfs_filestream_update_ag(
xfs_inode_t *ip,
xfs_inode_t *pip,
xfs_agnumber_t ag)
{
int err = 0;
xfs_mount_t *mp;
xfs_mru_cache_t *cache;
fstrm_item_t *item;
xfs_agnumber_t old_ag;
xfs_inode_t *old_pip;
/*
* Either ip is a regular file and pip is a directory, or ip is a
* directory and pip is NULL.
*/
ASSERT(ip && (((ip->i_d.di_mode & S_IFREG) && pip &&
(pip->i_d.di_mode & S_IFDIR)) ||
((ip->i_d.di_mode & S_IFDIR) && !pip)));
mp = ip->i_mount;
cache = mp->m_filestream;
item = xfs_mru_cache_lookup(cache, ip->i_ino);
if (item) {
ASSERT(item->ip == ip);
old_ag = item->ag;
item->ag = ag;
old_pip = item->pip;
item->pip = pip;
xfs_mru_cache_done(cache);
/*
* If the AG has changed, drop the old ref and take a new one,
* effectively transferring the reference from old to new AG.
*/
if (ag != old_ag) {
xfs_filestream_put_ag(mp, old_ag);
xfs_filestream_get_ag(mp, ag);
}
/*
* If ip is a file and its pip has changed, drop the old ref and
* take a new one.
*/
if (pip && pip != old_pip) {
IRELE(old_pip);
IHOLD(pip);
}
TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
ag, xfs_filestream_peek_ag(mp, ag));
return 0;
}
item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
if (!item)
return ENOMEM;
item->ag = ag;
item->ip = ip;
item->pip = pip;
err = xfs_mru_cache_insert(cache, ip->i_ino, item);
if (err) {
kmem_zone_free(item_zone, item);
return err;
}
/* Take a reference on the AG. */
xfs_filestream_get_ag(mp, ag);
/*
* Take a reference on the inode itself regardless of whether it's a
* regular file or a directory.
*/
IHOLD(ip);
/*
* In the case of a regular file, take a reference on the parent inode
* as well to ensure it remains in-core.
*/
if (pip)
IHOLD(pip);
TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
ag, xfs_filestream_peek_ag(mp, ag));
return 0;
}
int
xfs_filestream_new_ag(
xfs_bmalloca_t *ap,
xfs_agnumber_t *agp)
{
int flags, err;
xfs_inode_t *ip, *pip = NULL;
xfs_mount_t *mp;
xfs_mru_cache_t *cache;
xfs_extlen_t minlen;
fstrm_item_t *dir, *file;
xfs_agnumber_t ag = NULLAGNUMBER;
ip = ap->ip;
mp = ip->i_mount;
cache = mp->m_filestream;
minlen = ap->length;
*agp = NULLAGNUMBER;
file = xfs_mru_cache_remove(cache, ip->i_ino);
if (file) {
ASSERT(ip == file->ip);
pip = file->pip;
ag = file->ag;
dir = xfs_mru_cache_lookup(cache, pip->i_ino);
if (dir) {
ASSERT(pip == dir->ip);
if (dir->ag != file->ag) {
xfs_filestream_put_ag(mp, file->ag);
xfs_filestream_get_ag(mp, dir->ag);
*agp = file->ag = dir->ag;
}
xfs_mru_cache_done(cache);
}
err = xfs_mru_cache_insert(cache, ip->i_ino, file);
if (err) {
xfs_fstrm_free_func(ip->i_ino, file);
return err;
}
if (*agp != NULLAGNUMBER) {
TRACE_MOVEAG(mp, ip, pip,
ag, xfs_filestream_peek_ag(mp, ag),
*agp, xfs_filestream_peek_ag(mp, *agp));
return 0;
}
}
if (pip)
xfs_ilock(pip, XFS_IOLOCK_EXCL | XFS_IOLOCK_PARENT);
ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
(ap->flist->xbf_low ? XFS_PICK_LOWSPACE : 0);
err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
if (err || *agp == NULLAGNUMBER)
goto exit;
if (!pip) {
TRACE_ORPHAN(mp, ip, *agp);
goto exit;
}
err = _xfs_filestream_update_ag(pip, NULL, *agp);
if (err)
goto exit;
err = _xfs_filestream_update_ag(ip, pip, *agp);
if (err)
goto exit;
TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
*agp, xfs_filestream_peek_ag(mp, *agp));
exit:
if (*agp != NULLAGNUMBER)
xfs_filestream_put_ag(mp, *agp);
else
*agp = 0;
if (pip)
xfs_iunlock(pip, XFS_IOLOCK_EXCL);
return err;
}
int
xfs_filestream_associate(
xfs_inode_t *pip,
xfs_inode_t *ip)
{
xfs_mount_t *mp;
xfs_mru_cache_t *cache;
fstrm_item_t *item;
xfs_agnumber_t ag, rotorstep, startag;
int err = 0;
ASSERT(S_ISDIR(pip->i_d.di_mode));
ASSERT(S_ISREG(ip->i_d.di_mode));
if (!S_ISDIR(pip->i_d.di_mode) || !S_ISREG(ip->i_d.di_mode))
return -EINVAL;
mp = pip->i_mount;
cache = mp->m_filestream;
if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL))
return 1;
item = xfs_mru_cache_lookup(cache, pip->i_ino);
if (item) {
ASSERT(item->ip == pip);
ag = item->ag;
xfs_mru_cache_done(cache);
TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
err = _xfs_filestream_update_ag(ip, pip, ag);
goto exit;
}
if (mp->m_flags & XFS_MOUNT_32BITINODES) {
rotorstep = xfs_rotorstep;
startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
mp->m_agfrotor = (mp->m_agfrotor + 1) %
(mp->m_sb.sb_agcount * rotorstep);
} else
startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
if (err || ag == NULLAGNUMBER)
goto exit_did_pick;
err = _xfs_filestream_update_ag(pip, NULL, ag);
if (err)
goto exit_did_pick;
err = _xfs_filestream_update_ag(ip, pip, ag);
if (err)
goto exit_did_pick;
TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
exit_did_pick:
if (ag != NULLAGNUMBER)
xfs_filestream_put_ag(mp, ag);
exit:
xfs_iunlock(pip, XFS_IOLOCK_EXCL);
return -err;
}
static int
_xfs_filestream_update_ag(
xfs_inode_t *ip,
xfs_inode_t *pip,
xfs_agnumber_t ag)
{
int err = 0;
xfs_mount_t *mp;
xfs_mru_cache_t *cache;
fstrm_item_t *item;
xfs_agnumber_t old_ag;
xfs_inode_t *old_pip;
ASSERT(ip && ((S_ISREG(ip->i_d.di_mode) && pip &&
S_ISDIR(pip->i_d.di_mode)) ||
(S_ISDIR(ip->i_d.di_mode) && !pip)));
mp = ip->i_mount;
cache = mp->m_filestream;
item = xfs_mru_cache_lookup(cache, ip->i_ino);
if (item) {
ASSERT(item->ip == ip);
old_ag = item->ag;
item->ag = ag;
old_pip = item->pip;
item->pip = pip;
xfs_mru_cache_done(cache);
if (ag != old_ag) {
xfs_filestream_put_ag(mp, old_ag);
xfs_filestream_get_ag(mp, ag);
}
if (pip && pip != old_pip) {
IRELE(old_pip);
IHOLD(pip);
}
TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
ag, xfs_filestream_peek_ag(mp, ag));
return 0;
}
item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
if (!item)
return ENOMEM;
item->ag = ag;
item->ip = ip;
item->pip = pip;
err = xfs_mru_cache_insert(cache, ip->i_ino, item);
if (err) {
kmem_zone_free(item_zone, item);
return err;
}
xfs_filestream_get_ag(mp, ag);
IHOLD(ip);
if (pip)
IHOLD(pip);
TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
ag, xfs_filestream_peek_ag(mp, ag));
return 0;
}