/*
* The passed-in chain must be locked and the returned inode will also be
* locked. This routine typically locates or allocates the inode, assigns
* ip->chain (adding a ref to chain if necessary), and returns the inode.
*
* The hammer2_inode structure regulates the interface between the high level
* kernel VNOPS API and the filesystem backend (the chains).
*
* WARNING! This routine sucks up the chain's lock (makes it part of the
* inode lock from the point of view of the inode lock API),
* so callers need to be careful.
*
* WARNING! The mount code is allowed to pass dip == NULL for iroot and
* is allowed to pass pmp == NULL and dip == NULL for sroot.
*/
hammer2_inode_t *
hammer2_inode_get(hammer2_pfsmount_t *pmp, hammer2_inode_t *dip,
hammer2_chain_t *chain)
{
hammer2_inode_t *nip;
KKASSERT(chain->bref.type == HAMMER2_BREF_TYPE_INODE);
/*
* 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).
*/
again:
for (;;) {
nip = hammer2_inode_lookup(pmp, chain->data->ipdata.inum);
if (nip == NULL)
break;
ccms_thread_lock(&nip->topo_cst, CCMS_STATE_EXCLUSIVE);
if ((nip->flags & HAMMER2_INODE_ONRBTREE) == 0) { /* race */
ccms_thread_unlock(&nip->topo_cst);
hammer2_inode_drop(nip);
continue;
}
if (nip->chain != chain)
hammer2_inode_repoint(nip, NULL, chain);
/*
* Consolidated nip/nip->chain is locked (chain locked
* by caller).
*/
return nip;
}
/*
* We couldn't find the inode number, create a new inode.
*/
if (pmp) {
nip = kmalloc(sizeof(*nip), pmp->minode, M_WAITOK | M_ZERO);
atomic_add_long(&pmp->inmem_inodes, 1);
hammer2_chain_memory_inc(pmp);
hammer2_chain_memory_wakeup(pmp);
} else {
nip = kmalloc(sizeof(*nip), M_HAMMER2, M_WAITOK | M_ZERO);
nip->flags = HAMMER2_INODE_SROOT;
}
nip->inum = chain->data->ipdata.inum;
nip->size = chain->data->ipdata.size;
nip->mtime = chain->data->ipdata.mtime;
hammer2_inode_repoint(nip, NULL, chain);
nip->pip = dip; /* can be NULL */
if (dip)
hammer2_inode_ref(dip); /* ref dip for nip->pip */
nip->pmp = pmp;
/*
* ref and lock on nip gives it state compatible to after a
* hammer2_inode_lock_ex() call.
*/
nip->refs = 1;
ccms_cst_init(&nip->topo_cst, &nip->chain);
ccms_thread_lock(&nip->topo_cst, CCMS_STATE_EXCLUSIVE);
/* 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) {
spin_lock(&pmp->inum_spin);
if (RB_INSERT(hammer2_inode_tree, &pmp->inum_tree, nip)) {
spin_unlock(&pmp->inum_spin);
ccms_thread_unlock(&nip->topo_cst);
hammer2_inode_drop(nip);
goto again;
}
atomic_set_int(&nip->flags, HAMMER2_INODE_ONRBTREE);
spin_unlock(&pmp->inum_spin);
}
return (nip);
}
/*
* 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);
}