/*
* Lock an inode, with SYNCQ semantics.
*
* HAMMER2 offers shared and exclusive locks on inodes. Pass a mask of
* flags for options:
*
* - pass HAMMER2_RESOLVE_SHARED if a shared lock is desired. The
* inode locking function will automatically set the RDONLY flag.
* shared locks are not subject to SYNCQ semantics, exclusive locks
* are.
*
* - pass HAMMER2_RESOLVE_ALWAYS if you need the inode's meta-data.
* Most front-end inode locks do.
*
* - pass HAMMER2_RESOLVE_NEVER if you do not want to require that
* the inode data be resolved. This is used by the syncthr because
* it can run on an unresolved/out-of-sync cluster, and also by the
* vnode reclamation code to avoid unnecessary I/O (particularly when
* disposing of hundreds of thousands of cached vnodes).
*
* This function, along with lock4, has SYNCQ semantics. If the inode being
* locked is on the SYNCQ, that is it has been staged by the syncer, we must
* block until the operation is complete (even if we can lock the inode). In
* order to reduce the stall time, we re-order the inode to the front of the
* pmp->syncq prior to blocking. This reordering VERY significantly improves
* performance.
*
* The inode locking function locks the inode itself, resolves any stale
* chains in the inode's cluster, and allocates a fresh copy of the
* cluster with 1 ref and all the underlying chains locked.
*
* ip->cluster will be stable while the inode is locked.
*
* NOTE: We don't combine the inode/chain lock because putting away an
* inode would otherwise confuse multiple lock holders of the inode.
*/
void
hammer2_inode_lock(hammer2_inode_t *ip, int how)
{
hammer2_pfs_t *pmp;
hammer2_inode_ref(ip);
pmp = ip->pmp;
/*
* Inode structure mutex - Shared lock
*/
if (how & HAMMER2_RESOLVE_SHARED) {
hammer2_mtx_sh(&ip->lock);
return;
}
/*
* Inode structure mutex - Exclusive lock
*
* An exclusive lock (if not recursive) must wait for inodes on
* SYNCQ to flush first, to ensure that meta-data dependencies such
* as the nlink count and related directory entries are not split
* across flushes.
*
* If the vnode is locked by the current thread it must be unlocked
* across the tsleep() to avoid a deadlock.
*/
hammer2_mtx_ex(&ip->lock);
if (hammer2_mtx_refs(&ip->lock) > 1)
return;
while ((ip->flags & HAMMER2_INODE_SYNCQ) && pmp) {
hammer2_spin_ex(&pmp->list_spin);
if (ip->flags & HAMMER2_INODE_SYNCQ) {
tsleep_interlock(&ip->flags, 0);
atomic_set_int(&ip->flags, HAMMER2_INODE_SYNCQ_WAKEUP);
TAILQ_REMOVE(&pmp->syncq, ip, entry);
TAILQ_INSERT_HEAD(&pmp->syncq, ip, entry);
hammer2_spin_unex(&pmp->list_spin);
hammer2_mtx_unlock(&ip->lock);
tsleep(&ip->flags, PINTERLOCKED, "h2sync", 0);
hammer2_mtx_ex(&ip->lock);
continue;
}
hammer2_spin_unex(&pmp->list_spin);
break;
}
}
void
hammer2_dev_shlock(hammer2_dev_t *hmp)
{
hammer2_mtx_sh(&hmp->vchain.lock);
}
