/*
* Allocate a XOP request.
*
* Once allocated a XOP request can be started, collected, and retired,
* and can be retired early if desired.
*
* NOTE: Fifo indices might not be zero but ri == wi on objcache_get().
*/
void *
hammer2_xop_alloc(hammer2_inode_t *ip, int flags)
{
hammer2_xop_t *xop;
xop = objcache_get(cache_xops, M_WAITOK);
KKASSERT(xop->head.cluster.array[0].chain == NULL);
xop->head.ip = ip;
xop->head.func = NULL;
xop->head.state = 0;
xop->head.error = 0;
xop->head.collect_key = 0;
if (flags & HAMMER2_XOP_MODIFYING)
xop->head.mtid = hammer2_trans_sub(ip->pmp);
else
xop->head.mtid = 0;
xop->head.cluster.nchains = ip->cluster.nchains;
xop->head.cluster.pmp = ip->pmp;
xop->head.cluster.flags = HAMMER2_CLUSTER_LOCKED;
/*
* run_mask - Active thread (or frontend) associated with XOP
*/
xop->head.run_mask = HAMMER2_XOPMASK_VOP;
hammer2_inode_ref(ip);
return xop;
}
/*
* Allocates a new directory entry for the node node with a name of name.
* The new directory entry is returned in *de.
*
* The link count of node is increased by one to reflect the new object
* referencing it.
*
* Returns zero on success or an appropriate error code on failure.
*/
int
tmpfs_alloc_dirent(struct tmpfs_mount *tmp, struct tmpfs_node *node,
const char *name, uint16_t len, struct tmpfs_dirent **de)
{
struct tmpfs_dirent *nde;
nde = objcache_get(tmp->tm_dirent_pool, M_WAITOK);
nde->td_name = kmalloc(len + 1, tmp->tm_name_zone, M_WAITOK | M_NULLOK);
if (nde->td_name == NULL) {
objcache_put(tmp->tm_dirent_pool, nde);
*de = NULL;
return (ENOSPC);
}
nde->td_namelen = len;
bcopy(name, nde->td_name, len);
nde->td_name[len] = '\0';
nde->td_node = node;
TMPFS_NODE_LOCK(node);
++node->tn_links;
TMPFS_NODE_UNLOCK(node);
*de = nde;
return 0;
}
int main(int argc, char *argv[])
{
static char k1[] = { 'a' };
static char k2[] = { 'a', 'a' };
static char k3[] = { 'a', '\0', 'a' };
struct objcache cache;
struct objcache_entry *ep1, *ep2, *ep3;
int rc;
g_thread_init(NULL);
rc = objcache_init(&cache);
OK(rc==0);
ep1 = objcache_get(&cache, k1, sizeof(k1));
OK(ep1 != NULL);
ep2 = objcache_get(&cache, k2, sizeof(k2));
OK(ep2 != NULL);
ep3 = objcache_get(&cache, k3, sizeof(k3));
OK(ep3 != NULL);
rc = objcache_count(&cache);
OK(rc == 3);
OK(ep1->ref == 1); /* no collisions, else improve hash */
objcache_put(&cache, ep1);
objcache_put(&cache, ep2);
objcache_put(&cache, ep3);
ep2 = objcache_get(&cache, k2, sizeof(k2));
OK(ep2 != NULL);
OK(ep2->ref == 1); /* new */
objcache_put(&cache, ep2);
rc = objcache_count(&cache);
OK(rc == 0);
objcache_fini(&cache);
return 0;
}
/*
* Initialize a nlookup() structure, early error return for copyin faults
* or a degenerate empty string (which is not allowed).
*
* The first process proc0's credentials are used if the calling thread
* is not associated with a process context.
*
* MPSAFE
*/
int
nlookup_init(struct nlookupdata *nd,
const char *path, enum uio_seg seg, int flags)
{
size_t pathlen;
struct proc *p;
thread_t td;
int error;
td = curthread;
p = td->td_proc;
/*
* note: the pathlen set by copy*str() includes the terminating \0.
*/
bzero(nd, sizeof(struct nlookupdata));
nd->nl_path = objcache_get(namei_oc, M_WAITOK);
nd->nl_flags |= NLC_HASBUF;
if (seg == UIO_SYSSPACE)
error = copystr(path, nd->nl_path, MAXPATHLEN, &pathlen);
else
error = copyinstr(path, nd->nl_path, MAXPATHLEN, &pathlen);
/*
* Don't allow empty pathnames.
* POSIX.1 requirement: "" is not a vaild file name.
*/
if (error == 0 && pathlen <= 1)
error = ENOENT;
if (error == 0) {
if (p && p->p_fd) {
cache_copy_ncdir(p, &nd->nl_nch);
cache_copy(&p->p_fd->fd_nrdir, &nd->nl_rootnch);
if (p->p_fd->fd_njdir.ncp)
cache_copy(&p->p_fd->fd_njdir, &nd->nl_jailnch);
nd->nl_cred = td->td_ucred;
nd->nl_flags |= NLC_BORROWCRED | NLC_NCDIR;
} else {
cache_copy(&rootnch, &nd->nl_nch);
cache_copy(&nd->nl_nch, &nd->nl_rootnch);
cache_copy(&nd->nl_nch, &nd->nl_jailnch);
nd->nl_cred = proc0.p_ucred;
nd->nl_flags |= NLC_BORROWCRED;
}
nd->nl_td = td;
nd->nl_flags |= flags;
} else {
nlookup_done(nd);
}
return(error);
}
void *
AcpiOsAcquireObject(ACPI_CACHE_T *Cache)
{
struct acpiobjhead *head;
head = objcache_get(Cache->cache, M_WAITOK);
bzero(head, Cache->args.objsize);
head->state = TRACK_ALLOCATED;
#if ACPI_DEBUG_CACHE
head->cache = Cache;
head->func = "nowhere";
head->line = 0;
#endif
return (head + 1);
}
/*
* Read the contents of a symlink, allocate a path buffer out of the
* namei_oc and initialize the supplied nlcomponent with the result.
*
* If an error occurs no buffer will be allocated or returned in the nlc.
*/
int
nreadsymlink(struct nlookupdata *nd, struct nchandle *nch,
struct nlcomponent *nlc)
{
struct vnode *vp;
struct iovec aiov;
struct uio auio;
int linklen;
int error;
char *cp;
nlc->nlc_nameptr = NULL;
nlc->nlc_namelen = 0;
if (nch->ncp->nc_vp == NULL)
return(ENOENT);
if ((error = cache_vget(nch, nd->nl_cred, LK_SHARED, &vp)) != 0)
return(error);
cp = objcache_get(namei_oc, M_WAITOK);
aiov.iov_base = cp;
aiov.iov_len = MAXPATHLEN;
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_offset = 0;
auio.uio_rw = UIO_READ;
auio.uio_segflg = UIO_SYSSPACE;
auio.uio_td = nd->nl_td;
auio.uio_resid = MAXPATHLEN - 1;
error = VOP_READLINK(vp, &auio, nd->nl_cred);
if (error)
goto fail;
linklen = MAXPATHLEN - 1 - auio.uio_resid;
if (varsym_enable) {
linklen = varsymreplace(cp, linklen, MAXPATHLEN - 1);
if (linklen < 0) {
error = ENAMETOOLONG;
goto fail;
}
}
cp[linklen] = 0;
nlc->nlc_nameptr = cp;
nlc->nlc_namelen = linklen;
vput(vp);
return(0);
fail:
objcache_put(namei_oc, cp);
vput(vp);
return(error);
}
static struct puffs_msgpark *
puffs_msgpark_alloc(int waitok)
{
struct puffs_msgpark *park;
park = objcache_get(parkpc, waitok ? M_WAITOK : M_NOWAIT);
if (park == NULL)
return park;
park->park_refcount = 1;
park->park_preq = park->park_creq = NULL;
park->park_flags = PARKFLAG_WANTREPLY;
#ifdef PUFFSDEBUG
totalpark++;
#endif
return park;
}
/*
* This works similarly to nlookup_init_raw() but does not rely
* on rootnch being initialized yet.
*/
int
nlookup_init_root(struct nlookupdata *nd,
const char *path, enum uio_seg seg, int flags,
struct ucred *cred, struct nchandle *ncstart,
struct nchandle *ncroot)
{
size_t pathlen;
thread_t td;
int error;
td = curthread;
bzero(nd, sizeof(struct nlookupdata));
nd->nl_path = objcache_get(namei_oc, M_WAITOK);
nd->nl_flags |= NLC_HASBUF;
if (seg == UIO_SYSSPACE)
error = copystr(path, nd->nl_path, MAXPATHLEN, &pathlen);
else
error = copyinstr(path, nd->nl_path, MAXPATHLEN, &pathlen);
/*
* Don't allow empty pathnames.
* POSIX.1 requirement: "" is not a vaild file name.
*/
if (error == 0 && pathlen <= 1)
error = ENOENT;
if (error == 0) {
cache_copy(ncstart, &nd->nl_nch);
cache_copy(ncroot, &nd->nl_rootnch);
cache_copy(ncroot, &nd->nl_jailnch);
nd->nl_cred = crhold(cred);
nd->nl_td = td;
nd->nl_flags |= flags;
} else {
nlookup_done(nd);
}
return(error);
}
static int
hammer_vfs_mount(struct mount *mp, char *mntpt, caddr_t data,
struct ucred *cred)
{
struct hammer_mount_info info;
hammer_mount_t hmp;
hammer_volume_t rootvol;
struct vnode *rootvp;
struct vnode *devvp = NULL;
const char *upath; /* volume name in userspace */
char *path; /* volume name in system space */
int error;
int i;
int master_id;
char *next_volume_ptr = NULL;
/*
* Accept hammer_mount_info. mntpt is NULL for root mounts at boot.
*/
if (mntpt == NULL) {
bzero(&info, sizeof(info));
info.asof = 0;
info.hflags = 0;
info.nvolumes = 1;
next_volume_ptr = mp->mnt_stat.f_mntfromname;
/* Count number of volumes separated by ':' */
for (char *p = next_volume_ptr; *p != '\0'; ++p) {
if (*p == ':') {
++info.nvolumes;
}
}
mp->mnt_flag &= ~MNT_RDONLY; /* mount R/W */
} else {
if ((error = copyin(data, &info, sizeof(info))) != 0)
return (error);
}
/*
* updating or new mount
*/
if (mp->mnt_flag & MNT_UPDATE) {
hmp = (void *)mp->mnt_data;
KKASSERT(hmp != NULL);
} else {
if (info.nvolumes <= 0 || info.nvolumes > HAMMER_MAX_VOLUMES)
return (EINVAL);
hmp = NULL;
}
/*
* master-id validation. The master id may not be changed by a
* mount update.
*/
if (info.hflags & HMNT_MASTERID) {
if (hmp && hmp->master_id != info.master_id) {
kprintf("hammer: cannot change master id "
"with mount update\n");
return(EINVAL);
}
master_id = info.master_id;
if (master_id < -1 || master_id >= HAMMER_MAX_MASTERS)
return (EINVAL);
} else {
if (hmp)
master_id = hmp->master_id;
else
master_id = 0;
}
/*
* Internal mount data structure
*/
if (hmp == NULL) {
hmp = kmalloc(sizeof(*hmp), M_HAMMER, M_WAITOK | M_ZERO);
mp->mnt_data = (qaddr_t)hmp;
hmp->mp = mp;
/*TAILQ_INIT(&hmp->recycle_list);*/
/*
* Make sure kmalloc type limits are set appropriately.
*
* Our inode kmalloc group is sized based on maxvnodes
* (controlled by the system, not us).
*/
kmalloc_create(&hmp->m_misc, "HAMMER-others");
kmalloc_create(&hmp->m_inodes, "HAMMER-inodes");
kmalloc_raise_limit(hmp->m_inodes, 0); /* unlimited */
hmp->root_btree_beg.localization = 0x00000000U;
hmp->root_btree_beg.obj_id = -0x8000000000000000LL;
hmp->root_btree_beg.key = -0x8000000000000000LL;
hmp->root_btree_beg.create_tid = 1;
hmp->root_btree_beg.delete_tid = 1;
hmp->root_btree_beg.rec_type = 0;
hmp->root_btree_beg.obj_type = 0;
hmp->root_btree_end.localization = 0xFFFFFFFFU;
hmp->root_btree_end.obj_id = 0x7FFFFFFFFFFFFFFFLL;
hmp->root_btree_end.key = 0x7FFFFFFFFFFFFFFFLL;
hmp->root_btree_end.create_tid = 0xFFFFFFFFFFFFFFFFULL;
hmp->root_btree_end.delete_tid = 0; /* special case */
hmp->root_btree_end.rec_type = 0xFFFFU;
hmp->root_btree_end.obj_type = 0;
hmp->krate.freq = 1; /* maximum reporting rate (hz) */
hmp->krate.count = -16; /* initial burst */
hmp->sync_lock.refs = 1;
hmp->free_lock.refs = 1;
hmp->undo_lock.refs = 1;
hmp->blkmap_lock.refs = 1;
hmp->snapshot_lock.refs = 1;
hmp->volume_lock.refs = 1;
TAILQ_INIT(&hmp->delay_list);
TAILQ_INIT(&hmp->flush_group_list);
TAILQ_INIT(&hmp->objid_cache_list);
TAILQ_INIT(&hmp->undo_lru_list);
TAILQ_INIT(&hmp->reclaim_list);
RB_INIT(&hmp->rb_dedup_crc_root);
RB_INIT(&hmp->rb_dedup_off_root);
TAILQ_INIT(&hmp->dedup_lru_list);
}
hmp->hflags &= ~HMNT_USERFLAGS;
hmp->hflags |= info.hflags & HMNT_USERFLAGS;
hmp->master_id = master_id;
if (info.asof) {
mp->mnt_flag |= MNT_RDONLY;
hmp->asof = info.asof;
} else {
hmp->asof = HAMMER_MAX_TID;
}
hmp->volume_to_remove = -1;
/*
* Re-open read-write if originally read-only, or vise-versa.
*
* When going from read-only to read-write execute the stage2
* recovery if it has not already been run.
*/
if (mp->mnt_flag & MNT_UPDATE) {
lwkt_gettoken(&hmp->fs_token);
error = 0;
if (hmp->ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
kprintf("HAMMER read-only -> read-write\n");
hmp->ronly = 0;
RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
hammer_adjust_volume_mode, NULL);
rootvol = hammer_get_root_volume(hmp, &error);
if (rootvol) {
hammer_recover_flush_buffers(hmp, rootvol, 1);
error = hammer_recover_stage2(hmp, rootvol);
bcopy(rootvol->ondisk->vol0_blockmap,
hmp->blockmap,
sizeof(hmp->blockmap));
hammer_rel_volume(rootvol, 0);
}
RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
hammer_reload_inode, NULL);
/* kernel clears MNT_RDONLY */
} else if (hmp->ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
kprintf("HAMMER read-write -> read-only\n");
hmp->ronly = 1; /* messy */
RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
hammer_reload_inode, NULL);
hmp->ronly = 0;
hammer_flusher_sync(hmp);
hammer_flusher_sync(hmp);
hammer_flusher_sync(hmp);
hmp->ronly = 1;
RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
hammer_adjust_volume_mode, NULL);
}
lwkt_reltoken(&hmp->fs_token);
return(error);
}
RB_INIT(&hmp->rb_vols_root);
RB_INIT(&hmp->rb_inos_root);
RB_INIT(&hmp->rb_redo_root);
RB_INIT(&hmp->rb_nods_root);
RB_INIT(&hmp->rb_undo_root);
RB_INIT(&hmp->rb_resv_root);
RB_INIT(&hmp->rb_bufs_root);
RB_INIT(&hmp->rb_pfsm_root);
hmp->ronly = ((mp->mnt_flag & MNT_RDONLY) != 0);
RB_INIT(&hmp->volu_root);
RB_INIT(&hmp->undo_root);
RB_INIT(&hmp->data_root);
RB_INIT(&hmp->meta_root);
RB_INIT(&hmp->lose_root);
TAILQ_INIT(&hmp->iorun_list);
lwkt_token_init(&hmp->fs_token, "hammerfs");
lwkt_token_init(&hmp->io_token, "hammerio");
lwkt_gettoken(&hmp->fs_token);
/*
* Load volumes
*/
path = objcache_get(namei_oc, M_WAITOK);
hmp->nvolumes = -1;
for (i = 0; i < info.nvolumes; ++i) {
if (mntpt == NULL) {
/*
* Root mount.
*/
KKASSERT(next_volume_ptr != NULL);
strcpy(path, "");
if (*next_volume_ptr != '/') {
/* relative path */
strcpy(path, "/dev/");
}
int k;
for (k = strlen(path); k < MAXPATHLEN-1; ++k) {
if (*next_volume_ptr == '\0') {
break;
} else if (*next_volume_ptr == ':') {
++next_volume_ptr;
break;
} else {
path[k] = *next_volume_ptr;
++next_volume_ptr;
}
}
path[k] = '\0';
error = 0;
cdev_t dev = kgetdiskbyname(path);
error = bdevvp(dev, &devvp);
if (error) {
kprintf("hammer_mountroot: can't find devvp\n");
}
} else {
error = copyin(&info.volumes[i], &upath,
sizeof(char *));
if (error == 0)
error = copyinstr(upath, path,
MAXPATHLEN, NULL);
}
if (error == 0)
error = hammer_install_volume(hmp, path, devvp);
if (error)
break;
}
objcache_put(namei_oc, path);
/*
* Make sure we found a root volume
*/
if (error == 0 && hmp->rootvol == NULL) {
kprintf("hammer_mount: No root volume found!\n");
error = EINVAL;
}
/*
* Check that all required volumes are available
*/
if (error == 0 && hammer_mountcheck_volumes(hmp)) {
kprintf("hammer_mount: Missing volumes, cannot mount!\n");
error = EINVAL;
}
if (error) {
/* called with fs_token held */
hammer_free_hmp(mp);
return (error);
}
/*
* No errors, setup enough of the mount point so we can lookup the
* root vnode.
*/
mp->mnt_iosize_max = MAXPHYS;
mp->mnt_kern_flag |= MNTK_FSMID;
mp->mnt_kern_flag |= MNTK_THR_SYNC; /* new vsyncscan semantics */
/*
* MPSAFE code. Note that VOPs and VFSops which are not MPSAFE
* will acquire a per-mount token prior to entry and release it
* on return, so even if we do not specify it we no longer get
* the BGL regardlless of how we are flagged.
*/
mp->mnt_kern_flag |= MNTK_ALL_MPSAFE;
/*MNTK_RD_MPSAFE | MNTK_GA_MPSAFE | MNTK_IN_MPSAFE;*/
/*
* note: f_iosize is used by vnode_pager_haspage() when constructing
* its VOP_BMAP call.
*/
mp->mnt_stat.f_iosize = HAMMER_BUFSIZE;
mp->mnt_stat.f_bsize = HAMMER_BUFSIZE;
mp->mnt_vstat.f_frsize = HAMMER_BUFSIZE;
mp->mnt_vstat.f_bsize = HAMMER_BUFSIZE;
mp->mnt_maxsymlinklen = 255;
mp->mnt_flag |= MNT_LOCAL;
vfs_add_vnodeops(mp, &hammer_vnode_vops, &mp->mnt_vn_norm_ops);
vfs_add_vnodeops(mp, &hammer_spec_vops, &mp->mnt_vn_spec_ops);
vfs_add_vnodeops(mp, &hammer_fifo_vops, &mp->mnt_vn_fifo_ops);
/*
* The root volume's ondisk pointer is only valid if we hold a
* reference to it.
*/
rootvol = hammer_get_root_volume(hmp, &error);
if (error)
goto failed;
/*
* Perform any necessary UNDO operations. The recovery code does
* call hammer_undo_lookup() so we have to pre-cache the blockmap,
* and then re-copy it again after recovery is complete.
*
* If this is a read-only mount the UNDO information is retained
* in memory in the form of dirty buffer cache buffers, and not
* written back to the media.
*/
bcopy(rootvol->ondisk->vol0_blockmap, hmp->blockmap,
sizeof(hmp->blockmap));
/*
* Check filesystem version
*/
hmp->version = rootvol->ondisk->vol_version;
if (hmp->version < HAMMER_VOL_VERSION_MIN ||
hmp->version > HAMMER_VOL_VERSION_MAX) {
kprintf("HAMMER: mount unsupported fs version %d\n",
hmp->version);
error = ERANGE;
goto done;
}
/*
* The undo_rec_limit limits the size of flush groups to avoid
* blowing out the UNDO FIFO. This calculation is typically in
* the tens of thousands and is designed primarily when small
* HAMMER filesystems are created.
*/
hmp->undo_rec_limit = hammer_undo_max(hmp) / 8192 + 100;
if (hammer_debug_general & 0x0001)
kprintf("HAMMER: undo_rec_limit %d\n", hmp->undo_rec_limit);
/*
* NOTE: Recover stage1 not only handles meta-data recovery, it
* also sets hmp->undo_seqno for HAMMER VERSION 4+ filesystems.
*/
error = hammer_recover_stage1(hmp, rootvol);
if (error) {
kprintf("Failed to recover HAMMER filesystem on mount\n");
goto done;
}
/*
* Finish setup now that we have a good root volume.
*
* The top 16 bits of fsid.val[1] is a pfs id.
*/
ksnprintf(mp->mnt_stat.f_mntfromname,
sizeof(mp->mnt_stat.f_mntfromname), "%s",
rootvol->ondisk->vol_name);
mp->mnt_stat.f_fsid.val[0] =
crc32((char *)&rootvol->ondisk->vol_fsid + 0, 8);
mp->mnt_stat.f_fsid.val[1] =
crc32((char *)&rootvol->ondisk->vol_fsid + 8, 8);
mp->mnt_stat.f_fsid.val[1] &= 0x0000FFFF;
mp->mnt_vstat.f_fsid_uuid = rootvol->ondisk->vol_fsid;
mp->mnt_vstat.f_fsid = crc32(&mp->mnt_vstat.f_fsid_uuid,
sizeof(mp->mnt_vstat.f_fsid_uuid));
/*
* Certain often-modified fields in the root volume are cached in
* the hammer_mount structure so we do not have to generate lots
* of little UNDO structures for them.
*
* Recopy after recovery. This also has the side effect of
* setting our cached undo FIFO's first_offset, which serves to
* placemark the FIFO start for the NEXT flush cycle while the
* on-disk first_offset represents the LAST flush cycle.
*/
hmp->next_tid = rootvol->ondisk->vol0_next_tid;
hmp->flush_tid1 = hmp->next_tid;
hmp->flush_tid2 = hmp->next_tid;
bcopy(rootvol->ondisk->vol0_blockmap, hmp->blockmap,
sizeof(hmp->blockmap));
hmp->copy_stat_freebigblocks = rootvol->ondisk->vol0_stat_freebigblocks;
hammer_flusher_create(hmp);
/*
* Locate the root directory using the root cluster's B-Tree as a
* starting point. The root directory uses an obj_id of 1.
*
* FUTURE: Leave the root directory cached referenced but unlocked
* in hmp->rootvp (need to flush it on unmount).
*/
error = hammer_vfs_vget(mp, NULL, 1, &rootvp);
if (error)
goto done;
vput(rootvp);
/*vn_unlock(hmp->rootvp);*/
if (hmp->ronly == 0)
error = hammer_recover_stage2(hmp, rootvol);
/*
* If the stage2 recovery fails be sure to clean out all cached
* vnodes before throwing away the mount structure or bad things
* will happen.
*/
if (error)
vflush(mp, 0, 0);
done:
if ((mp->mnt_flag & MNT_UPDATE) == 0) {
/* New mount */
/* Populate info for mount point (NULL pad)*/
bzero(mp->mnt_stat.f_mntonname, MNAMELEN);
size_t size;
if (mntpt) {
copyinstr(mntpt, mp->mnt_stat.f_mntonname,
MNAMELEN -1, &size);
} else { /* Root mount */
mp->mnt_stat.f_mntonname[0] = '/';
}
}
(void)VFS_STATFS(mp, &mp->mnt_stat, cred);
hammer_rel_volume(rootvol, 0);
failed:
/*
* Cleanup and return.
*/
if (error) {
/* called with fs_token held */
hammer_free_hmp(mp);
} else {
lwkt_reltoken(&hmp->fs_token);
}
return (error);
}
int
nfs_nget(struct mount *mntp, nfsfh_t *fhp, int fhsize, struct nfsnode **npp)
{
struct nfsnode *np, *np2;
struct nfsnodehashhead *nhpp;
struct vnode *vp;
int error;
int lkflags;
struct nfsmount *nmp;
/*
* Calculate nfs mount point and figure out whether the rslock should
* be interruptable or not.
*/
nmp = VFSTONFS(mntp);
if (nmp->nm_flag & NFSMNT_INT)
lkflags = LK_PCATCH;
else
lkflags = 0;
lwkt_gettoken(&nfsnhash_token);
retry:
nhpp = NFSNOHASH(fnv_32_buf(fhp->fh_bytes, fhsize, FNV1_32_INIT));
loop:
for (np = nhpp->lh_first; np; np = np->n_hash.le_next) {
if (mntp != NFSTOV(np)->v_mount || np->n_fhsize != fhsize ||
bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize)) {
continue;
}
vp = NFSTOV(np);
if (vget(vp, LK_EXCLUSIVE))
goto loop;
for (np = nhpp->lh_first; np; np = np->n_hash.le_next) {
if (mntp == NFSTOV(np)->v_mount &&
np->n_fhsize == fhsize &&
bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize) == 0
) {
break;
}
}
if (np == NULL || NFSTOV(np) != vp) {
vput(vp);
goto loop;
}
*npp = np;
lwkt_reltoken(&nfsnhash_token);
return(0);
}
/*
* Obtain a lock to prevent a race condition if the getnewvnode()
* or MALLOC() below happens to block.
*/
if (lockmgr(&nfsnhash_lock, LK_EXCLUSIVE | LK_SLEEPFAIL))
goto loop;
/*
* Allocate before getnewvnode since doing so afterward
* might cause a bogus v_data pointer to get dereferenced
* elsewhere if objcache should block.
*/
np = objcache_get(nfsnode_objcache, M_WAITOK);
error = getnewvnode(VT_NFS, mntp, &vp, 0, 0);
if (error) {
lockmgr(&nfsnhash_lock, LK_RELEASE);
*npp = NULL;
objcache_put(nfsnode_objcache, np);
lwkt_reltoken(&nfsnhash_token);
return (error);
}
/*
* Initialize most of (np).
*/
bzero(np, sizeof (*np));
if (fhsize > NFS_SMALLFH) {
MALLOC(np->n_fhp, nfsfh_t *, fhsize, M_NFSBIGFH, M_WAITOK);
} else {
/*
* Allocates a new node of type 'type' inside the 'tmp' mount point, with
* its owner set to 'uid', its group to 'gid' and its mode set to 'mode',
* using the credentials of the process 'p'.
*
* If the node type is set to 'VDIR', then the parent parameter must point
* to the parent directory of the node being created. It may only be NULL
* while allocating the root node.
*
* If the node type is set to 'VBLK' or 'VCHR', then the rdev parameter
* specifies the device the node represents.
*
* If the node type is set to 'VLNK', then the parameter target specifies
* the file name of the target file for the symbolic link that is being
* created.
*
* Note that new nodes are retrieved from the available list if it has
* items or, if it is empty, from the node pool as long as there is enough
* space to create them.
*
* Returns zero on success or an appropriate error code on failure.
*/
int
tmpfs_alloc_node(struct tmpfs_mount *tmp, enum vtype type,
uid_t uid, gid_t gid, mode_t mode,
char *target, int rmajor, int rminor,
struct tmpfs_node **node)
{
struct tmpfs_node *nnode;
struct timespec ts;
udev_t rdev;
KKASSERT(IFF(type == VLNK, target != NULL));
KKASSERT(IFF(type == VBLK || type == VCHR, rmajor != VNOVAL));
if (tmp->tm_nodes_inuse >= tmp->tm_nodes_max)
return (ENOSPC);
nnode = objcache_get(tmp->tm_node_pool, M_WAITOK | M_NULLOK);
if (nnode == NULL)
return (ENOSPC);
/* Generic initialization. */
nnode->tn_type = type;
vfs_timestamp(&ts);
nnode->tn_ctime = nnode->tn_mtime = nnode->tn_atime
= ts.tv_sec;
nnode->tn_ctimensec = nnode->tn_mtimensec = nnode->tn_atimensec
= ts.tv_nsec;
nnode->tn_uid = uid;
nnode->tn_gid = gid;
nnode->tn_mode = mode;
nnode->tn_id = tmpfs_fetch_ino(tmp);
nnode->tn_advlock.init_done = 0;
KKASSERT(nnode->tn_links == 0);
/* Type-specific initialization. */
switch (nnode->tn_type) {
case VBLK:
case VCHR:
rdev = makeudev(rmajor, rminor);
if (rdev == NOUDEV) {
objcache_put(tmp->tm_node_pool, nnode);
return(EINVAL);
}
nnode->tn_rdev = rdev;
break;
case VDIR:
RB_INIT(&nnode->tn_dir.tn_dirtree);
RB_INIT(&nnode->tn_dir.tn_cookietree);
nnode->tn_size = 0;
break;
case VFIFO:
/* FALLTHROUGH */
case VSOCK:
break;
case VLNK:
nnode->tn_size = strlen(target);
nnode->tn_link = kmalloc(nnode->tn_size + 1, tmp->tm_name_zone,
M_WAITOK | M_NULLOK);
if (nnode->tn_link == NULL) {
objcache_put(tmp->tm_node_pool, nnode);
return (ENOSPC);
}
bcopy(target, nnode->tn_link, nnode->tn_size);
nnode->tn_link[nnode->tn_size] = '\0';
break;
case VREG:
nnode->tn_reg.tn_aobj = swap_pager_alloc(NULL, 0,
VM_PROT_DEFAULT, 0);
nnode->tn_reg.tn_aobj_pages = 0;
nnode->tn_size = 0;
vm_object_set_flag(nnode->tn_reg.tn_aobj, OBJ_NOPAGEIN);
break;
default:
panic("tmpfs_alloc_node: type %p %d", nnode, (int)nnode->tn_type);
}
TMPFS_NODE_LOCK(nnode);
TMPFS_LOCK(tmp);
LIST_INSERT_HEAD(&tmp->tm_nodes_used, nnode, tn_entries);
tmp->tm_nodes_inuse++;
TMPFS_UNLOCK(tmp);
TMPFS_NODE_UNLOCK(nnode);
*node = nnode;
return 0;
}