void
hammer2_xop_group_init(hammer2_pfs_t *pmp, hammer2_xop_group_t *xgrp)
{
hammer2_mtx_init(&xgrp->mtx, "h2xopq");
hammer2_mtx_init(&xgrp->mtx2, "h2xopio");
}
/*
* XXX this API needs a rewrite. It needs to be split into a
* hammer2_inode_alloc() and hammer2_inode_build() to allow us to get
* rid of the inode/chain lock reversal fudge.
*
* Returns the inode associated with the passed-in cluster, allocating a new
* hammer2_inode structure if necessary, then synchronizing it to the passed
* xop cluster. When synchronizing, if idx >= 0, only cluster index (idx)
* is synchronized. Otherwise the whole cluster is synchronized. inum will
* be extracted from the passed-in xop and the inum argument will be ignored.
*
* If xop is passed as NULL then a new hammer2_inode is allocated with the
* specified inum, and returned. For normal inodes, the inode will be
* indexed in memory and if it already exists the existing ip will be
* returned instead of allocating a new one. The superroot and PFS inodes
* are not indexed in memory.
*
* The passed-in cluster must be locked and will remain locked on return.
* The returned inode will be locked and the caller may dispose of both
* via hammer2_inode_unlock() + hammer2_inode_drop(). However, if the caller
* needs to resolve a hardlink it must ref/unlock/relock/drop the inode.
*
* The hammer2_inode structure regulates the interface between the high level
* kernel VNOPS API and the filesystem backend (the chains).
*
* On return the inode is locked with the supplied cluster.
*/
hammer2_inode_t *
hammer2_inode_get(hammer2_pfs_t *pmp, hammer2_xop_head_t *xop,
hammer2_tid_t inum, int idx)
{
hammer2_inode_t *nip;
const hammer2_inode_data_t *iptmp;
const hammer2_inode_data_t *nipdata;
KKASSERT(xop == NULL ||
hammer2_cluster_type(&xop->cluster) ==
HAMMER2_BREF_TYPE_INODE);
KKASSERT(pmp);
/*
* Interlocked lookup/ref of the inode. This code is only needed
* when looking up inodes with nlinks != 0 (TODO: optimize out
* otherwise and test for duplicates).
*
* Cluster can be NULL during the initial pfs allocation.
*/
if (xop) {
iptmp = &hammer2_xop_gdata(xop)->ipdata;
inum = iptmp->meta.inum;
hammer2_xop_pdata(xop);
}
again:
nip = hammer2_inode_lookup(pmp, inum);
if (nip) {
/*
* We may have to unhold the cluster to avoid a deadlock
* against vnlru (and possibly other XOPs).
*/
if (xop) {
if (hammer2_mtx_ex_try(&nip->lock) != 0) {
hammer2_cluster_unhold(&xop->cluster);
hammer2_mtx_ex(&nip->lock);
hammer2_cluster_rehold(&xop->cluster);
}
} else {
hammer2_mtx_ex(&nip->lock);
}
/*
* Handle SMP race (not applicable to the super-root spmp
* which can't index inodes due to duplicative inode numbers).
*/
if (pmp->spmp_hmp == NULL &&
(nip->flags & HAMMER2_INODE_ONRBTREE) == 0) {
hammer2_mtx_unlock(&nip->lock);
hammer2_inode_drop(nip);
goto again;
}
if (xop) {
if (idx >= 0)
hammer2_inode_repoint_one(nip, &xop->cluster,
idx);
else
hammer2_inode_repoint(nip, NULL, &xop->cluster);
}
return nip;
}
/*
* We couldn't find the inode number, create a new inode and try to
* insert it, handle insertion races.
*/
nip = kmalloc(sizeof(*nip), pmp->minode, M_WAITOK | M_ZERO);
spin_init(&nip->cluster_spin, "h2clspin");
atomic_add_long(&pmp->inmem_inodes, 1);
if (pmp->spmp_hmp)
nip->flags = HAMMER2_INODE_SROOT;
/*
* Initialize nip's cluster. A cluster is provided for normal
* inodes but typically not for the super-root or PFS inodes.
*/
nip->cluster.refs = 1;
nip->cluster.pmp = pmp;
nip->cluster.flags |= HAMMER2_CLUSTER_INODE;
if (xop) {
nipdata = &hammer2_xop_gdata(xop)->ipdata;
nip->meta = nipdata->meta;
hammer2_xop_pdata(xop);
atomic_set_int(&nip->flags, HAMMER2_INODE_METAGOOD);
hammer2_inode_repoint(nip, NULL, &xop->cluster);
} else {
nip->meta.inum = inum; /* PFS inum is always 1 XXX */
/* mtime will be updated when a cluster is available */
atomic_set_int(&nip->flags, HAMMER2_INODE_METAGOOD); /*XXX*/
}
nip->pmp = pmp;
/*
* ref and lock on nip gives it state compatible to after a
* hammer2_inode_lock() call.
*/
nip->refs = 1;
hammer2_mtx_init(&nip->lock, "h2inode");
hammer2_mtx_init(&nip->truncate_lock, "h2trunc");
hammer2_mtx_ex(&nip->lock);
TAILQ_INIT(&nip->depend_static.sideq);
/* combination of thread lock and chain lock == inode lock */
/*
* Attempt to add the inode. If it fails we raced another inode
* get. Undo all the work and try again.
*/
if (pmp->spmp_hmp == NULL) {
hammer2_spin_ex(&pmp->inum_spin);
if (RB_INSERT(hammer2_inode_tree, &pmp->inum_tree, nip)) {
hammer2_spin_unex(&pmp->inum_spin);
hammer2_mtx_unlock(&nip->lock);
hammer2_inode_drop(nip);
goto again;
}
atomic_set_int(&nip->flags, HAMMER2_INODE_ONRBTREE);
++pmp->inum_count;
hammer2_spin_unex(&pmp->inum_spin);
}
return (nip);
}
