static void
vdev_file_io_start(zio_t *zio)
{
vdev_t *vd = zio->io_vd;
vdev_file_t *vf = vd->vdev_tsd;
ssize_t resid = 0;
if (zio->io_type == ZIO_TYPE_IOCTL) {
if (!vdev_readable(vd)) {
zio->io_error = SET_ERROR(ENXIO);
zio_interrupt(zio);
return;
}
switch (zio->io_cmd) {
case DKIOCFLUSHWRITECACHE:
if (!vnode_getwithvid(vf->vf_vnode, vf->vf_vid)) {
zio->io_error = VOP_FSYNC(vf->vf_vnode, FSYNC | FDSYNC,
kcred, NULL);
vnode_put(vf->vf_vnode);
}
break;
default:
zio->io_error = SET_ERROR(ENOTSUP);
}
zio_interrupt(zio);
return;
}
ASSERT(zio->io_type == ZIO_TYPE_READ || zio->io_type == ZIO_TYPE_WRITE);
if (!vnode_getwithvid(vf->vf_vnode, vf->vf_vid)) {
/*
VERIFY3U(taskq_dispatch(vdev_file_taskq, vdev_file_io_strategy, zio,
TQ_PUSHPAGE), !=, 0);
*/
zio->io_error = vn_rdwr(zio->io_type == ZIO_TYPE_READ ?
UIO_READ : UIO_WRITE, vf->vf_vnode, zio->io_data,
zio->io_size, zio->io_offset, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, &resid);
vnode_put(vf->vf_vnode);
}
if (resid != 0 && zio->io_error == 0)
zio->io_error = SET_ERROR(ENOSPC);
zio_interrupt(zio);
return;
}
/**
* ntfs_inode_hash_list_find - find and return a loaded ntfs inode
*
* Search the ntfs inode hash bucket @list for the ntfs inode matching @na and
* if present return it. If not present return NULL.
*
* If the found ntfs inode has a vnode attached, then get an iocount reference
* on the vnode.
*/
static inline ntfs_inode *ntfs_inode_hash_list_find(const ntfs_volume *vol,
const ntfs_inode_list_head *list, const ntfs_attr *na)
{
ntfs_inode *ni;
retry:
mtx_lock(&ntfs_inode_hash_lock);
ni = ntfs_inode_hash_list_find_nolock(vol, list, na);
if (ni) {
vnode_t vn;
u32 vn_id = 0;
// FIXME: If this is an extent inode (i.e. it has no vnode), do
// we want to take an iocount reference on its base vnode? If
// so we would need to make sure to release it when finished
// with the extent inode. -> Need to do that but only when we
// start looking up extent inodes from the $MFT pageout code
// path so that the base inode cannot disappear under us which
// would also cause the extent ntfs inode to disappear under
// us.
vn = ni->vn;
if (vn)
vn_id = vnode_vid(vn);
mtx_unlock(&ntfs_inode_hash_lock);
if (vn && vnode_getwithvid(vn, vn_id))
goto retry;
return ni;
}
mtx_unlock(&ntfs_inode_hash_lock);
return ni;
}
static int
vdev_file_io_start(zio_t *zio)
{
vdev_t *vd = zio->io_vd;
vdev_file_t *vf = vd->vdev_tsd;
ssize_t resid = 0;
if (zio->io_type == ZIO_TYPE_IOCTL) {
if (!vdev_readable(vd)) {
zio->io_error = ENXIO;
return (ZIO_PIPELINE_CONTINUE);
}
switch (zio->io_cmd) {
case DKIOCFLUSHWRITECACHE:
vnode_getwithvid(vf->vf_vnode, vf->vf_vid);
zio->io_error = VOP_FSYNC(vf->vf_vnode, FSYNC | FDSYNC,
kcred, NULL);
vnode_put(vf->vf_vnode);
break;
default:
zio->io_error = ENOTSUP;
}
return (ZIO_PIPELINE_CONTINUE);
}
vnode_getwithvid(vf->vf_vnode, vf->vf_vid);
zio->io_error = vn_rdwr(zio->io_type == ZIO_TYPE_READ ?
UIO_READ : UIO_WRITE, vf->vf_vnode, zio->io_data,
zio->io_size, zio->io_offset, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, &resid);
vnode_put(vf->vf_vnode);
if (resid != 0 && zio->io_error == 0)
zio->io_error = ENOSPC;
zio_interrupt(zio);
return (ZIO_PIPELINE_STOP);
}
/*
* Act like null_hashget, but add passed null_node to hash if no existing
* node found.
*/
static int
null_hashins(struct mount * mp, struct null_node * xp, struct vnode ** vpp)
{
struct null_node_hashhead * hd;
struct null_node * oxp;
struct vnode * ovp;
int error = 0;
hd = NULL_NHASH(xp->null_lowervp);
lck_mtx_lock(&null_hashmtx);
LIST_FOREACH(oxp, hd, null_hash)
{
if (oxp->null_lowervp == xp->null_lowervp && vnode_mount(NULLTOV(oxp)) == mp) {
/*
* See null_hashget for a description of this
* operation.
*/
ovp = NULLTOV(oxp);
if (oxp->null_lowervid != vnode_vid(oxp->null_lowervp)) {
/*vp doesn't exist so return null (not sure we are actually gonna catch
recycle right now
This is an exceptional case right now, it suggests the vnode we are
trying to add has been recycled
don't add it.*/
error = EIO;
goto end;
}
/* if we found something in the hash map then grab an iocount */
error = vnode_getwithvid(ovp, oxp->null_myvid);
if (error == 0) {
*vpp = ovp;
}
goto end;
}
}
/* if it wasn't in the hash map then the vnode pointed to by xp already has a
* iocount so don't bother */
LIST_INSERT_HEAD(hd, xp, null_hash);
xp->null_flags |= NULL_FLAG_HASHED;
end:
lck_mtx_unlock(&null_hashmtx);
return error;
}
static int
nullfs_read(struct vnop_read_args * ap)
{
int error = EIO;
struct vnode *vp, *lvp;
NULLFSDEBUG("%s %p\n", __FUNCTION__, ap->a_vp);
if (nullfs_checkspecialvp(ap->a_vp)) {
return ENOTSUP; /* the special vnodes can't be read */
}
vp = ap->a_vp;
lvp = NULLVPTOLOWERVP(vp);
/*
* First some house keeping
*/
if (vnode_getwithvid(lvp, NULLVPTOLOWERVID(vp)) == 0) {
if (!vnode_isreg(lvp) && !vnode_islnk(lvp)) {
error = EPERM;
goto end;
}
if (uio_resid(ap->a_uio) == 0) {
error = 0;
goto end;
}
/*
* Now ask VM/UBC/VFS to do our bidding
*/
error = VNOP_READ(lvp, ap->a_uio, ap->a_ioflag, ap->a_context);
if (error) {
NULLFSDEBUG("VNOP_READ failed: %d\n", error);
}
end:
vnode_put(lvp);
}
return error;
}
static void
vdev_file_close(vdev_t *vd)
{
vdev_file_t *vf = vd->vdev_tsd;
if (vd->vdev_reopening || vf == NULL)
return;
if (vf->vf_vnode != NULL) {
vnode_getwithvid(vf->vf_vnode, vf->vf_vid);
// Also commented out in MacZFS
//(void) VOP_PUTPAGE(vf->vf_vnode, 0, 0, B_INVAL, kcred, NULL);
(void) VOP_CLOSE(vf->vf_vnode, spa_mode(vd->vdev_spa), 1, 0,
kcred, NULL);
}
vd->vdev_delayed_close = B_FALSE;
kmem_free(vf, sizeof (vdev_file_t));
vd->vdev_tsd = NULL;
}
/* This returns vnode with ioref */
static vnode_t
cttyvp(proc_t p)
{
vnode_t vp;
int vid;
struct session *sessp;
sessp = proc_session(p);
session_lock(sessp);
vp = (p->p_flag & P_CONTROLT ? sessp->s_ttyvp : NULLVP);
vid = sessp->s_ttyvid;
session_unlock(sessp);
session_rele(sessp);
if (vp != NULLVP) {
/* cannot get an IO reference, return NULLVP */
if (vnode_getwithvid(vp, vid) != 0)
vp = NULLVP;
}
return(vp);
}
/*
* Find the nullfs vnode mapped to lowervp. Return it in *vpp with an iocount if found.
* Return 0 on success. On failure *vpp will be null and a non-zero error code will be returned.
*/
int
null_hashget(struct mount * mp, struct vnode * lowervp, struct vnode ** vpp)
{
struct null_node_hashhead * hd;
struct null_node * a;
struct vnode * vp;
int error = ENOENT;
/*
* Find hash base, and then search the (two-way) linked
* list looking for a null_node structure which is referencing
* the lower vnode. We only give up our reference at reclaim so
* just check whether the lowervp has gotten pulled from under us
*/
hd = NULL_NHASH(lowervp);
lck_mtx_lock(&null_hashmtx);
LIST_FOREACH(a, hd, null_hash)
{
if (a->null_lowervp == lowervp && vnode_mount(NULLTOV(a)) == mp) {
vp = NULLTOV(a);
if (a->null_lowervid != vnode_vid(lowervp)) {
/*lowervp has reved */
error = EIO;
} else {
/* if we found something then get an iocount on it */
error = vnode_getwithvid(vp, a->null_myvid);
if (error == 0) {
*vpp = vp;
}
}
break;
}
}
lck_mtx_unlock(&null_hashmtx);
return error;
}
static void
vnstrategy(struct buf *bp)
{
struct vn_softc *vn;
int error = 0;
long sz; /* in sc_secsize chunks */
daddr64_t blk_num;
struct vnode * shadow_vp = NULL;
struct vnode * vp = NULL;
struct vfs_context context;
vn = vn_table + vnunit(buf_device(bp));
if ((vn->sc_flags & VNF_INITED) == 0) {
error = ENXIO;
goto done;
}
context.vc_thread = current_thread();
context.vc_ucred = vn->sc_cred;
buf_setresid(bp, buf_count(bp));
/*
* Check for required alignment. Transfers must be a valid
* multiple of the sector size.
*/
blk_num = buf_blkno(bp);
if (buf_count(bp) % vn->sc_secsize != 0) {
error = EINVAL;
goto done;
}
sz = howmany(buf_count(bp), vn->sc_secsize);
/*
* If out of bounds return an error. If at the EOF point,
* simply read or write less.
*/
if (blk_num >= 0 && (u_int64_t)blk_num >= vn->sc_size) {
if (blk_num > 0 && (u_int64_t)blk_num > vn->sc_size) {
error = EINVAL;
}
goto done;
}
/*
* If the request crosses EOF, truncate the request.
*/
if ((blk_num + sz) > 0 && ((u_int64_t)(blk_num + sz)) > vn->sc_size) {
buf_setcount(bp, (vn->sc_size - blk_num) * vn->sc_secsize);
buf_setresid(bp, buf_count(bp));
}
vp = vn->sc_vp;
if (vp == NULL) {
error = ENXIO;
goto done;
}
error = vnode_getwithvid(vp, vn->sc_vid);
if (error != 0) {
/* the vnode is no longer available, abort */
error = ENXIO;
vnclear(vn, &context);
goto done;
}
shadow_vp = vn->sc_shadow_vp;
if (shadow_vp != NULL) {
error = vnode_getwithvid(shadow_vp,
vn->sc_shadow_vid);
if (error != 0) {
/* the vnode is no longer available, abort */
error = ENXIO;
vnode_put(vn->sc_vp);
vnclear(vn, &context);
goto done;
}
}
error = vn_readwrite_io(vn, bp, &context);
vnode_put(vp);
if (shadow_vp != NULL) {
vnode_put(shadow_vp);
}
done:
if (error) {
buf_seterror(bp, error);
}
buf_biodone(bp);
return;
}
static int
vnwrite(dev_t dev, struct uio *uio, int ioflag)
{
struct vfs_context context;
int error;
off_t offset;
proc_t p;
user_ssize_t resid;
struct vn_softc * vn;
int unit;
unit = vnunit(dev);
if (vnunit(dev) >= NVNDEVICE) {
return (ENXIO);
}
p = current_proc();
vn = vn_table + unit;
if ((vn->sc_flags & VNF_INITED) == 0) {
error = ENXIO;
goto done;
}
if (vn->sc_flags & VNF_READONLY) {
error = EROFS;
goto done;
}
context.vc_thread = current_thread();
context.vc_ucred = vn->sc_cred;
error = vnode_getwithvid(vn->sc_vp, vn->sc_vid);
if (error != 0) {
/* the vnode is no longer available, abort */
error = ENXIO;
vnclear(vn, &context);
goto done;
}
resid = uio_resid(uio);
offset = uio_offset(uio);
/*
* If out of bounds return an error. If at the EOF point,
* simply write less.
*/
if (offset >= (off_t)vn->sc_fsize) {
if (offset > (off_t)vn->sc_fsize) {
error = EINVAL;
}
goto done;
}
/*
* If the request crosses EOF, truncate the request.
*/
if ((offset + resid) > (off_t)vn->sc_fsize) {
resid = (off_t)vn->sc_fsize - offset;
uio_setresid(uio, resid);
}
if (vn->sc_shadow_vp != NULL) {
error = vnode_getwithvid(vn->sc_shadow_vp,
vn->sc_shadow_vid);
if (error != 0) {
/* the vnode is no longer available, abort */
error = ENXIO;
vnode_put(vn->sc_vp);
vnclear(vn, &context);
goto done;
}
error = vnwrite_shadow(vn, uio, ioflag, &context);
vnode_put(vn->sc_shadow_vp);
} else {
error = VNOP_WRITE(vn->sc_vp, uio, ioflag, &context);
}
vnode_put(vn->sc_vp);
done:
return (error);
}
static int
vdev_file_open(vdev_t *vd, uint64_t *psize, uint64_t *max_psize,
uint64_t *ashift)
{
vdev_file_t *vf;
vnode_t *vp;
vattr_t vattr;
int error = 0;
vnode_t *rootdir;
/*
* We must have a pathname, and it must be absolute.
*/
if (vd->vdev_path == NULL || vd->vdev_path[0] != '/') {
vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
return (EINVAL);
}
/*
* Reopen the device if it's not currently open. Otherwise,
* just update the physical size of the device.
*/
if (vd->vdev_tsd != NULL) {
ASSERT(vd->vdev_reopening);
vf = vd->vdev_tsd;
vnode_getwithvid(vf->vf_vnode, vf->vf_vid);
goto skip_open;
}
vf = vd->vdev_tsd = kmem_zalloc(sizeof (vdev_file_t), KM_PUSHPAGE);
/*
* We always open the files from the root of the global zone, even if
* we're in a local zone. If the user has gotten to this point, the
* administrator has already decided that the pool should be available
* to local zone users, so the underlying devices should be as well.
*/
ASSERT(vd->vdev_path != NULL && vd->vdev_path[0] == '/');
/*
vn_openat(char *pnamep,
enum uio_seg seg,
int filemode,
int createmode,
struct vnode **vpp,
enum create crwhy,
mode_t umask,
struct vnode *startvp)
extern int vn_openat(char *pnamep, enum uio_seg seg, int filemode,
int createmode, struct vnode **vpp, enum create crwhy,
mode_t umask, struct vnode *startvp);
*/
rootdir = getrootdir();
error = vn_openat(vd->vdev_path + 1,
UIO_SYSSPACE,
spa_mode(vd->vdev_spa) | FOFFMAX,
0,
&vp,
0,
0,
rootdir
);
if (error) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
return (error);
}
vf->vf_vnode = vp;
vf->vf_vid = vnode_vid(vp);
#ifdef _KERNEL
/*
* Make sure it's a regular file.
*/
if (!vnode_isreg(vp)) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
vnode_put(vf->vf_vnode);
return (ENODEV);
}
#endif
skip_open:
/*
* Determine the physical size of the file.
*/
vattr.va_mask = AT_SIZE;
error = VOP_GETATTR(vf->vf_vnode, &vattr, 0, kcred, NULL);
if (error) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
vnode_put(vf->vf_vnode);
return (error);
}
*max_psize = *psize = vattr.va_size;
*ashift = SPA_MINBLOCKSHIFT;
vnode_put(vf->vf_vnode);
return (0);
}
/*
* Finds the procfsnode_t for a node with a given id and referencing a given structure node
* on a given instance of the file system. If the node does not already exist, it is created,
* entered into the node has table and a vnode is created and attached to it. If the node already
* exists, it is returned along with its vnode. In both cases, the vnode has an additional iocount,
* which the caller must remove at some point by calling vnode_put().
*
* Creation of a vnode cannot be performed by this function because the information required
* to initialize it is known only to the caller. The caller must supply a pointer to a function
* that will create the vnode when required, along with an opaque context pointer that is passed
* to the creation function, along with a pointer to the corresponding procfsnode_t. The creation
* function must either create the vnode and link it to the procfsnode_t or return an error.
*
* The allocation of the procfsnode_t that is done here is reversed in the procfs_reclaim() function,
* which is called when the node's associated vnode is being reclaimed.
*/
int
procfsnode_find(procfs_mount_t *pmp, procfsnode_id_t node_id, procfs_structure_node_t *snode,
procfsnode_t **pnpp, vnode_t *vnpp,
create_vnode_func create_vnode_func,
void *create_vnode_params) {
int error = 0;
boolean_t locked = TRUE;
procfsnode_t *target_procfsnode = NULL; // This is the node that we will return.
procfsnode_t *new_procfsnode = NULL; // Newly allocated node. Will be freed if not used.
vnode_t target_vnode = NULL; // Start by assuming we will not get a vnode.
int32_t mount_id = pmp->pmnt_id; // File system id.
// Lock the hash table. We'll keep this locked until we are done,
// unless we need to allocate memory. In that case, we'll drop the
// lock, but we'll have to revisit all of our assumptions when we
// reacquire it, because another thread may have created the node
// we are looking for.
lck_mtx_lock(procfsnode_hash_mutex);
boolean_t done = FALSE;
while (!done) {
assert(locked);
error = 0;
// Select the correct hash bucket and walk along it, looking for an existing
// node with the correct attributes.
int nodehash = HASH_FOR_MOUNT_AND_ID(mount_id, node_id);
procfs_hash_head *hash_bucket = PROCFS_NODE_HASH_TO_BUCKET_HEADER(nodehash);
LIST_FOREACH(target_procfsnode, hash_bucket, node_hash) {
if (target_procfsnode->node_mnt_id == mount_id
&& target_procfsnode->node_id.nodeid_pid == node_id.nodeid_pid
&&target_procfsnode->node_id.nodeid_objectid == node_id.nodeid_objectid
&& target_procfsnode->node_id.nodeid_base_id == node_id.nodeid_base_id) {
// Matched.
break;
}
}
// We got a match if target_procfsnode is not NULL.
if (target_procfsnode == NULL) {
// We did not find a match, so either allocate a new node or use the
// one we created last time around this loop.
if (new_procfsnode == NULL) {
// We need to allocate a new node. Before doing that, unlock
// the node hash, because the memory allocation may block.
lck_mtx_unlock(procfsnode_hash_mutex);
locked = FALSE;
new_procfsnode = (procfsnode_t *)OSMalloc(sizeof(procfsnode_t), procfs_osmalloc_tag);
if (new_procfsnode == NULL) {
// Allocation failure - bail. Nothing to clean up and
// we don't hold the lock.
error = ENOMEM;
break;
}
// We got a new procfsnode. Relock the node hash, then go around the
// loop again. This is necessary because someone else may have created
// the same node after we dropped the lock. If that's the case, we'll
// find that node next time around and we'll use it. The one we just
// allocated will remain in target_procfsnode and will be freed before we return.
lck_mtx_lock(procfsnode_hash_mutex);
locked = TRUE;
continue;
} else {
// If we get here, we know that we need to use the node that we
// allocated last time around the loop, so promote it to target_procfsnode
assert(locked);
assert(new_procfsnode != NULL);
target_procfsnode = new_procfsnode;
// Initialize the new node.
memset(target_procfsnode, 0, sizeof(procfsnode_t));
target_procfsnode->node_mnt_id = mount_id;
target_procfsnode->node_id = node_id;
target_procfsnode->node_structure_node = snode;
// Add the node to the node hash. We already know which bucket
// it belongs to.
LIST_INSERT_HEAD(hash_bucket, target_procfsnode, node_hash);
}
}
// At this point, we have a procfsnode_t, which either already existed
// or was just created. We also have the lock for the node hash table.
assert(target_procfsnode != NULL);
assert(locked);
// Check whether another thread is already in the process of creating a
// vnode for this procfsnode_t. If it is, wait until it's done and go
// around the loop again.
if (target_procfsnode->node_attaching_vnode) {
// Indicate that a wakeup is needed when the attaching thread
// is done.
target_procfsnode->node_thread_waiting_attach = TRUE;
// Sleeping will drop and relock the mutex.
msleep(target_procfsnode, procfsnode_hash_mutex, PINOD, "procfsnode_find", NULL);
// Since anything can have changed while we were away, go around
// the loop again.
continue;
}
target_vnode = target_procfsnode->node_vnode;
if (target_vnode != NULL) {
// We already have a vnode. We need to check if it has been reassigned.
// To do that, unlock and check the vnode id.
uint32_t vid = vnode_vid(target_vnode);
lck_mtx_unlock(procfsnode_hash_mutex);
locked = FALSE;
error = vnode_getwithvid(target_vnode, vid);
if (error != 0) {
// Vnode changed identity, so we need to redo everything. Relock
// because we are expected to hold the lock at the top of the loop.
// Getting here means that the vnode was reclaimed and the procfsnode
// was removed from the hash and freed, so we will be restarting from scratch.
lck_mtx_lock(procfsnode_hash_mutex);
target_procfsnode = NULL;
new_procfsnode = NULL;
locked = TRUE;
continue;
}
// The vnode was still present and has not changed id. All we need to do
// is terminate the loop. We don't hold the lock, "locked" is FALSE and
// we don't need to relock (and indeed doing so would introduce yet more
// race conditions). vnode_getwithvid() added an iocount reference for us,
// which the caller is expected to eventually release with vnode_put().
assert(error == 0);
break;
}
// At this point, we have procfsnode_t in the node hash, but we don't have a
// vnode. To create the vnode, we have to release the node hash lock and invoke
// the caller's create_vnode_func callback. Before doing that, we need to set
// node_attaching_vnode to force any other threads that come in here to wait for
// this thread to create the vnode (or fail).
target_procfsnode->node_attaching_vnode = TRUE;
lck_mtx_unlock(procfsnode_hash_mutex);
locked = FALSE;
error = (*create_vnode_func)(create_vnode_params, target_procfsnode, &target_vnode);
assert(error != 0 || target_vnode != NULL);
// Relock the hash table and clear node_attaching_vnode now that we are
// safely back from the caller's callback.
lck_mtx_lock(procfsnode_hash_mutex);
locked = TRUE;
target_procfsnode->node_attaching_vnode = FALSE;
// If there are threads waiting for the vnode attach to complete,
// wake them up.
if (target_procfsnode->node_thread_waiting_attach) {
target_procfsnode->node_thread_waiting_attach = FALSE;
wakeup(target_procfsnode);
}
// Now check whether we succeeded.
if (error != 0) {
// Failed to create the vnode -- this is fatal.
// Remove the procfsnode_t from the hash table and
// release it.
procfsnode_free_node(target_procfsnode);
new_procfsnode = NULL; // To avoid double free.
break;
}
// We got the new vnode and it's already linked to the procfsnode_t.
// Link the procfsnode_t to it. Also add a file system reference to
// the vnode itself.
target_procfsnode->node_vnode = target_vnode;
vnode_addfsref(target_vnode);
break;
}
// Unlock the hash table, if it is still locked.
if (locked) {
lck_mtx_unlock(procfsnode_hash_mutex);
}
// Free the node we allocated, if we didn't use it. We do this
// *after* releasing the hash lock just in case it might block.
if (new_procfsnode != NULL && new_procfsnode != target_procfsnode) {
OSFree(new_procfsnode, sizeof(procfsnode_t), procfs_osmalloc_tag);
}
// Set the return value, or NULL if we failed.
*pnpp = error == 0 ? target_procfsnode : NULL;
*vnpp = error == 0 ? target_vnode : NULL;
return error;
}
/*
* Use the device, inum pair to find the incore cnode.
*
* If it is in core, but locked, wait for it.
*/
struct vnode *
hfs_chash_getvnode(struct hfsmount *hfsmp, ino_t inum, int wantrsrc, int skiplock, int allow_deleted)
{
struct cnode *cp;
struct vnode *vp;
int error;
u_int32_t vid;
/*
* Go through the hash list
* If a cnode is in the process of being cleaned out or being
* allocated, wait for it to be finished and then try again.
*/
loop:
hfs_chash_lock_spin(hfsmp);
for (cp = CNODEHASH(hfsmp, inum)->lh_first; cp; cp = cp->c_hash.le_next) {
if (cp->c_fileid != inum)
continue;
/* Wait if cnode is being created or reclaimed. */
if (ISSET(cp->c_hflag, H_ALLOC | H_TRANSIT | H_ATTACH)) {
SET(cp->c_hflag, H_WAITING);
(void) msleep(cp, &hfsmp->hfs_chash_mutex, PDROP | PINOD,
"hfs_chash_getvnode", 0);
goto loop;
}
/* Obtain the desired vnode. */
vp = wantrsrc ? cp->c_rsrc_vp : cp->c_vp;
if (vp == NULLVP)
goto exit;
vid = vnode_vid(vp);
hfs_chash_unlock(hfsmp);
if ((error = vnode_getwithvid(vp, vid))) {
/*
* If vnode is being reclaimed, or has
* already changed identity, no need to wait
*/
return (NULL);
}
if (!skiplock && hfs_lock(cp, HFS_EXCLUSIVE_LOCK) != 0) {
vnode_put(vp);
return (NULL);
}
/*
* Skip cnodes that are not in the name space anymore
* we need to check with the cnode lock held because
* we may have blocked acquiring the vnode ref or the
* lock on the cnode which would allow the node to be
* unlinked
*/
if (!allow_deleted) {
if (cp->c_flag & (C_NOEXISTS | C_DELETED)) {
if (!skiplock) {
hfs_unlock(cp);
}
vnode_put(vp);
return (NULL);
}
}
return (vp);
}
exit:
hfs_chash_unlock(hfsmp);
return (NULL);
}
static int
vdev_file_open(vdev_t *vd, uint64_t *psize, uint64_t *max_psize,
uint64_t *ashift)
{
#if _KERNEL
static vattr_t vattr;
#endif
vdev_file_t *vf;
struct vnode *vp;
int error = 0;
struct vnode *rootdir;
dprintf("vdev_file_open %p\n", vd->vdev_tsd);
/* Rotational optimizations only make sense on block devices */
vd->vdev_nonrot = B_TRUE;
/*
* We must have a pathname, and it must be absolute.
*/
if (vd->vdev_path == NULL || vd->vdev_path[0] != '/') {
vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
return (SET_ERROR(EINVAL));
}
/*
* Reopen the device if it's not currently open. Otherwise,
* just update the physical size of the device.
*/
#ifdef _KERNEL
if (vd->vdev_tsd != NULL) {
ASSERT(vd->vdev_reopening);
vf = vd->vdev_tsd;
vnode_getwithvid(vf->vf_vnode, vf->vf_vid);
dprintf("skip to open\n");
goto skip_open;
}
#endif
vf = vd->vdev_tsd = kmem_zalloc(sizeof (vdev_file_t), KM_SLEEP);
/*
* We always open the files from the root of the global zone, even if
* we're in a local zone. If the user has gotten to this point, the
* administrator has already decided that the pool should be available
* to local zone users, so the underlying devices should be as well.
*/
ASSERT(vd->vdev_path != NULL && vd->vdev_path[0] == '/');
/*
vn_openat(char *pnamep,
enum uio_seg seg,
int filemode,
int createmode,
struct vnode **vpp,
enum create crwhy,
mode_t umask,
struct vnode *startvp)
extern int vn_openat(char *pnamep, enum uio_seg seg, int filemode,
int createmode, struct vnode **vpp, enum create crwhy,
mode_t umask, struct vnode *startvp);
*/
rootdir = getrootdir();
error = vn_openat(vd->vdev_path + 1,
UIO_SYSSPACE,
spa_mode(vd->vdev_spa) | FOFFMAX,
0,
&vp,
0,
0,
rootdir
);
if (error) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
return (error);
}
vf->vf_vnode = vp;
#ifdef _KERNEL
vf->vf_vid = vnode_vid(vp);
dprintf("assigning vid %d\n", vf->vf_vid);
/*
* Make sure it's a regular file.
*/
if (!vnode_isreg(vp)) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
VN_RELE(vf->vf_vnode);
return (SET_ERROR(ENODEV));
}
#endif
#if _KERNEL
skip_open:
/*
* Determine the physical size of the file.
*/
vattr.va_mask = AT_SIZE;
vn_lock(vf->vf_vnode, LK_SHARED | LK_RETRY);
error = VOP_GETATTR(vf->vf_vnode, &vattr, 0, kcred, NULL);
VN_UNLOCK(vf->vf_vnode);
#endif
if (error) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
VN_RELE(vf->vf_vnode);
return (error);
}
#ifdef _KERNEL
*max_psize = *psize = vattr.va_size;
#else
/* userland's vn_open() will get the device size for us, so we can
* just look it up - there is argument for a userland VOP_GETATTR to make
* this function cleaner. */
*max_psize = *psize = vp->v_size;
#endif
*ashift = SPA_MINBLOCKSHIFT;
VN_RELE(vf->vf_vnode);
return (0);
}
/* relies on v1 paging */
static int
nullfs_pagein(struct vnop_pagein_args * ap)
{
int error = EIO;
struct vnode *vp, *lvp;
NULLFSDEBUG("%s %p\n", __FUNCTION__, ap->a_vp);
vp = ap->a_vp;
lvp = NULLVPTOLOWERVP(vp);
if (vnode_vtype(vp) != VREG) {
return ENOTSUP;
}
/*
* Ask VM/UBC/VFS to do our bidding
*/
if (vnode_getwithvid(lvp, NULLVPTOLOWERVID(vp)) == 0) {
vm_offset_t ioaddr;
uio_t auio;
kern_return_t kret;
off_t bytes_to_commit;
off_t lowersize;
upl_t upl = ap->a_pl;
user_ssize_t bytes_remaining = 0;
auio = uio_create(1, ap->a_f_offset, UIO_SYSSPACE, UIO_READ);
if (auio == NULL) {
error = EIO;
goto exit_no_unmap;
}
kret = ubc_upl_map(upl, &ioaddr);
if (KERN_SUCCESS != kret) {
panic("nullfs_pagein: ubc_upl_map() failed with (%d)", kret);
}
ioaddr += ap->a_pl_offset;
error = uio_addiov(auio, (user_addr_t)ioaddr, ap->a_size);
if (error) {
goto exit;
}
lowersize = ubc_getsize(lvp);
if (lowersize != ubc_getsize(vp)) {
(void)ubc_setsize(vp, lowersize); /* ignore failures, nothing can be done */
}
error = VNOP_READ(lvp, auio, ((ap->a_flags & UPL_IOSYNC) ? IO_SYNC : 0), ap->a_context);
bytes_remaining = uio_resid(auio);
if (bytes_remaining > 0 && bytes_remaining <= (user_ssize_t)ap->a_size)
{
/* zero bytes that weren't read in to the upl */
bzero((void*)((uintptr_t)(ioaddr + ap->a_size - bytes_remaining)), (size_t) bytes_remaining);
}
exit:
kret = ubc_upl_unmap(upl);
if (KERN_SUCCESS != kret) {
panic("nullfs_pagein: ubc_upl_unmap() failed with (%d)", kret);
}
if (auio != NULL) {
uio_free(auio);
}
exit_no_unmap:
if ((ap->a_flags & UPL_NOCOMMIT) == 0) {
if (!error && (bytes_remaining >= 0) && (bytes_remaining <= (user_ssize_t)ap->a_size)) {
/* only commit what was read in (page aligned)*/
bytes_to_commit = ap->a_size - bytes_remaining;
if (bytes_to_commit)
{
/* need to make sure bytes_to_commit and byte_remaining are page aligned before calling ubc_upl_commit_range*/
if (bytes_to_commit & PAGE_MASK)
{
bytes_to_commit = (bytes_to_commit & (~PAGE_MASK)) + (PAGE_MASK + 1);
assert(bytes_to_commit <= (off_t)ap->a_size);
bytes_remaining = ap->a_size - bytes_to_commit;
}
ubc_upl_commit_range(upl, ap->a_pl_offset, (upl_size_t)bytes_to_commit, UPL_COMMIT_FREE_ON_EMPTY);
}
/* abort anything thats left */
if (bytes_remaining) {
ubc_upl_abort_range(upl, ap->a_pl_offset + bytes_to_commit, (upl_size_t)bytes_remaining, UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
}
} else {
ubc_upl_abort_range(upl, ap->a_pl_offset, (upl_size_t)ap->a_size, UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
}
}
vnode_put(lvp);
} else if((ap->a_flags & UPL_NOCOMMIT) == 0) {
ubc_upl_abort_range(ap->a_pl, ap->a_pl_offset, (upl_size_t)ap->a_size, UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
}
return error;
}
static int
nullfs_special_readdir(struct vnop_readdir_args * ap)
{
struct vnode * vp = ap->a_vp;
struct uio * uio = ap->a_uio;
struct null_mount * null_mp = MOUNTTONULLMOUNT(vnode_mount(vp));
off_t offset = uio_offset(uio);
int error = ERANGE;
int items = 0;
ino_t ino = 0;
const char * name = NULL;
if (ap->a_flags & (VNODE_READDIR_EXTENDED | VNODE_READDIR_REQSEEKOFF))
return (EINVAL);
if (offset == 0) {
/* . case */
if (vp == null_mp->nullm_rootvp) {
ino = NULL_ROOT_INO;
} else /* only get here if vp matches nullm_rootvp or nullm_secondvp */
{
ino = NULL_SECOND_INO;
}
error = store_entry_special(ino, ".", uio);
if (error) {
goto out;
}
offset++;
items++;
}
if (offset == 1) {
/* .. case */
/* only get here if vp matches nullm_rootvp or nullm_secondvp */
ino = NULL_ROOT_INO;
error = store_entry_special(ino, "..", uio);
if (error) {
goto out;
}
offset++;
items++;
}
if (offset == 2) {
/* the directory case */
if (vp == null_mp->nullm_rootvp) {
ino = NULL_SECOND_INO;
name = "d";
} else /* only get here if vp matches nullm_rootvp or nullm_secondvp */
{
ino = NULL_THIRD_INO;
if (vnode_getwithvid(null_mp->nullm_lowerrootvp, null_mp->nullm_lowerrootvid)) {
/* In this case the lower file system has been ripped out from under us,
but we don't want to error out
Instead we just want d to look empty. */
error = 0;
goto out;
}
name = vnode_getname_printable(null_mp->nullm_lowerrootvp);
}
error = store_entry_special(ino, name, uio);
if (ino == NULL_THIRD_INO) {
vnode_putname_printable(name);
vnode_put(null_mp->nullm_lowerrootvp);
}
if (error) {
goto out;
}
offset++;
items++;
}
out:
if (error == EMSGSIZE) {
error = 0; /* return success if we ran out of space, but we wanted to make
sure that we didn't update offset and items incorrectly */
}
uio_setoffset(uio, offset);
if (ap->a_numdirent) {
*ap->a_numdirent = items;
}
return error;
}
/* the mountpoint lock should be held going into this function */
static int
null_special_lookup(struct vnop_lookup_args * ap)
{
struct componentname * cnp = ap->a_cnp;
struct vnode * dvp = ap->a_dvp;
struct vnode * ldvp = NULL;
struct vnode * lvp = NULL;
struct vnode * vp = NULL;
struct mount * mp = vnode_mount(dvp);
struct null_mount * null_mp = MOUNTTONULLMOUNT(mp);
int error = ENOENT;
if (dvp == null_mp->nullm_rootvp) {
/* handle . and .. */
if (cnp->cn_nameptr[0] == '.') {
if (cnp->cn_namelen == 1 || (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.')) {
/* this is the root so both . and .. give back the root */
vp = dvp;
error = vnode_get(vp);
goto end;
}
}
/* our virtual wrapper directory should be d but D is acceptable if the
* lower file system is case insensitive */
if (cnp->cn_namelen == 1 &&
(cnp->cn_nameptr[0] == 'd' || (null_mp->nullm_flags & NULLM_CASEINSENSITIVE ? cnp->cn_nameptr[0] == 'D' : 0))) {
error = 0;
if (null_mp->nullm_secondvp == NULL) {
error = null_getnewvnode(mp, NULL, dvp, &vp, cnp, 0);
if (error) {
goto end;
}
null_mp->nullm_secondvp = vp;
} else {
vp = null_mp->nullm_secondvp;
error = vnode_get(vp);
}
}
} else if (dvp == null_mp->nullm_secondvp) {
/* handle . and .. */
if (cnp->cn_nameptr[0] == '.') {
if (cnp->cn_namelen == 1) {
vp = dvp;
error = vnode_get(vp);
goto end;
} else if (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.') {
/* parent here is the root vp */
vp = null_mp->nullm_rootvp;
error = vnode_get(vp);
goto end;
}
}
/* nullmp->nullm_lowerrootvp was set at mount time so don't need to lock to
* access it */
/* v_name should be null terminated but cn_nameptr is not necessarily.
cn_namelen is the number of characters before the null in either case */
error = vnode_getwithvid(null_mp->nullm_lowerrootvp, null_mp->nullm_lowerrootvid);
if (error) {
goto end;
}
/* We don't want to mess with case insensitivity and unicode, so the plan to
check here is
1. try to get the lower root's parent
2. If we get a parent, then perform a lookup on the lower file system
using the parent and the passed in cnp
3. If that worked and we got a vp, then see if the vp is lowerrootvp. If
so we got a match
4. Anything else results in ENOENT.
*/
error = null_get_lowerparent(null_mp->nullm_lowerrootvp, &ldvp, ap->a_context);
if (error == 0) {
error = VNOP_LOOKUP(ldvp, &lvp, cnp, ap->a_context);
vnode_put(ldvp);
if (error == 0) {
if (lvp == null_mp->nullm_lowerrootvp) {
/* always check the hashmap for a vnode for this, the root of the
* mirrored system */
error = null_nodeget(mp, lvp, dvp, &vp, cnp, 0);
if (error == 0 && null_mp->nullm_thirdcovervp == NULL) {
/* if nodeget succeeded then vp has an iocount*/
null_mp->nullm_thirdcovervp = vp;
}
} else {
error = ENOENT;
}
vnode_put(lvp);
}
}
vnode_put(null_mp->nullm_lowerrootvp);
}
end:
if (error == 0) {
*ap->a_vpp = vp;
}
return error;
}
static int
nullfs_special_getattr(struct vnop_getattr_args * args)
{
mount_t mp = vnode_mount(args->a_vp);
struct null_mount * null_mp = MOUNTTONULLMOUNT(mp);
ino_t ino = NULL_ROOT_INO;
struct vnode_attr covered_rootattr;
vnode_t checkvp = null_mp->nullm_lowerrootvp;
VATTR_INIT(&covered_rootattr);
VATTR_WANTED(&covered_rootattr, va_uid);
VATTR_WANTED(&covered_rootattr, va_gid);
VATTR_WANTED(&covered_rootattr, va_create_time);
VATTR_WANTED(&covered_rootattr, va_modify_time);
VATTR_WANTED(&covered_rootattr, va_access_time);
/* prefer to get this from the lower root vp, but if not (i.e. forced unmount
* of lower fs) try the mount point covered vnode */
if (vnode_getwithvid(checkvp, null_mp->nullm_lowerrootvid)) {
checkvp = vfs_vnodecovered(mp);
if (checkvp == NULL) {
return EIO;
}
}
int error = vnode_getattr(checkvp, &covered_rootattr, args->a_context);
vnode_put(checkvp);
if (error) {
/* we should have been able to get attributes fore one of the two choices so
* fail if we didn't */
return error;
}
/* we got the attributes of the vnode we cover so plow ahead */
if (args->a_vp == null_mp->nullm_secondvp) {
ino = NULL_SECOND_INO;
}
VATTR_RETURN(args->a_vap, va_type, vnode_vtype(args->a_vp));
VATTR_RETURN(args->a_vap, va_rdev, 0);
VATTR_RETURN(args->a_vap, va_nlink, 3); /* always just ., .., and the child */
VATTR_RETURN(args->a_vap, va_total_size, 0); // hoping this is ok
VATTR_RETURN(args->a_vap, va_data_size, 0); // hoping this is ok
VATTR_RETURN(args->a_vap, va_data_alloc, 0);
VATTR_RETURN(args->a_vap, va_iosize, vfs_statfs(mp)->f_iosize);
VATTR_RETURN(args->a_vap, va_fileid, ino);
VATTR_RETURN(args->a_vap, va_linkid, ino);
VATTR_RETURN(args->a_vap, va_fsid, vfs_statfs(mp)->f_fsid.val[0]); // return the fsid of the mount point
VATTR_RETURN(args->a_vap, va_filerev, 0);
VATTR_RETURN(args->a_vap, va_gen, 0);
VATTR_RETURN(args->a_vap, va_flags, UF_HIDDEN); /* mark our fake directories as hidden. People
shouldn't be enocouraged to poke around in them */
if (ino == NULL_SECOND_INO) {
VATTR_RETURN(args->a_vap, va_parentid, NULL_ROOT_INO); /* no parent at the root, so
the only other vnode that
goes through this path is
second and its parent is
1.*/
}
if (VATTR_IS_ACTIVE(args->a_vap, va_mode)) {
/* force dr_xr_xr_x */
VATTR_RETURN(args->a_vap, va_mode, S_IFDIR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
}
if (VATTR_IS_ACTIVE(args->a_vap, va_uid)) {
VATTR_RETURN(args->a_vap, va_uid, covered_rootattr.va_uid);
}
if (VATTR_IS_ACTIVE(args->a_vap, va_gid)) {
VATTR_RETURN(args->a_vap, va_gid, covered_rootattr.va_gid);
}
if (VATTR_IS_ACTIVE(args->a_vap, va_create_time)) {
VATTR_SET_SUPPORTED(args->a_vap, va_create_time);
args->a_vap->va_create_time.tv_sec = covered_rootattr.va_create_time.tv_sec;
args->a_vap->va_create_time.tv_nsec = covered_rootattr.va_create_time.tv_nsec;
}
if (VATTR_IS_ACTIVE(args->a_vap, va_modify_time)) {
VATTR_SET_SUPPORTED(args->a_vap, va_modify_time);
args->a_vap->va_modify_time.tv_sec = covered_rootattr.va_modify_time.tv_sec;
args->a_vap->va_modify_time.tv_nsec = covered_rootattr.va_modify_time.tv_nsec;
}
if (VATTR_IS_ACTIVE(args->a_vap, va_access_time)) {
VATTR_SET_SUPPORTED(args->a_vap, va_access_time);
args->a_vap->va_modify_time.tv_sec = covered_rootattr.va_access_time.tv_sec;
args->a_vap->va_modify_time.tv_nsec = covered_rootattr.va_access_time.tv_nsec;
}
return 0;
}
/*
* Use the device, fileid pair to find the incore cnode.
* If no cnode if found one is created
*
* If it is in core, but locked, wait for it.
*
* If the cnode is C_DELETED, then return NULL since that
* inum is no longer valid for lookups (open-unlinked file).
*
* If the cnode is C_DELETED but also marked C_RENAMED, then that means
* the cnode was renamed over and a new entry exists in its place. The caller
* should re-drive the lookup to get the newer entry. In that case, we'll still
* return NULL for the cnode, but also return GNV_CHASH_RENAMED in the output flags
* of this function to indicate the caller that they should re-drive.
*/
struct cnode *
hfs_chash_getcnode(struct hfsmount *hfsmp, ino_t inum, struct vnode **vpp,
int wantrsrc, int skiplock, int *out_flags, int *hflags)
{
struct cnode *cp;
struct cnode *ncp = NULL;
vnode_t vp;
u_int32_t vid;
/*
* Go through the hash list
* If a cnode is in the process of being cleaned out or being
* allocated, wait for it to be finished and then try again.
*/
loop:
hfs_chash_lock_spin(hfsmp);
loop_with_lock:
for (cp = CNODEHASH(hfsmp, inum)->lh_first; cp; cp = cp->c_hash.le_next) {
if (cp->c_fileid != inum)
continue;
/*
* Wait if cnode is being created, attached to or reclaimed.
*/
if (ISSET(cp->c_hflag, H_ALLOC | H_ATTACH | H_TRANSIT)) {
SET(cp->c_hflag, H_WAITING);
(void) msleep(cp, &hfsmp->hfs_chash_mutex, PINOD,
"hfs_chash_getcnode", 0);
goto loop_with_lock;
}
vp = wantrsrc ? cp->c_rsrc_vp : cp->c_vp;
if (vp == NULL) {
/*
* The desired vnode isn't there so tag the cnode.
*/
SET(cp->c_hflag, H_ATTACH);
*hflags |= H_ATTACH;
hfs_chash_unlock(hfsmp);
} else {
vid = vnode_vid(vp);
hfs_chash_unlock(hfsmp);
if (vnode_getwithvid(vp, vid))
goto loop;
}
if (ncp) {
/*
* someone else won the race to create
* this cnode and add it to the hash
* just dump our allocation
*/
FREE_ZONE(ncp, sizeof(struct cnode), M_HFSNODE);
ncp = NULL;
}
if (!skiplock) {
hfs_lock(cp, HFS_FORCE_LOCK);
}
/*
* Skip cnodes that are not in the name space anymore
* we need to check with the cnode lock held because
* we may have blocked acquiring the vnode ref or the
* lock on the cnode which would allow the node to be
* unlinked.
*
* Don't return a cnode in this case since the inum
* is no longer valid for lookups.
*/
if ((cp->c_flag & (C_NOEXISTS | C_DELETED)) && !wantrsrc) {
int renamed = 0;
if (cp->c_flag & C_RENAMED) {
renamed = 1;
}
if (!skiplock)
hfs_unlock(cp);
if (vp != NULLVP) {
vnode_put(vp);
} else {
hfs_chash_lock_spin(hfsmp);
CLR(cp->c_hflag, H_ATTACH);
*hflags &= ~H_ATTACH;
if (ISSET(cp->c_hflag, H_WAITING)) {
CLR(cp->c_hflag, H_WAITING);
wakeup((caddr_t)cp);
}
hfs_chash_unlock(hfsmp);
}
vp = NULL;
cp = NULL;
if (renamed) {
*out_flags = GNV_CHASH_RENAMED;
}
}
*vpp = vp;
return (cp);
}
/*
* Allocate a new cnode
*/
if (skiplock && !wantrsrc)
panic("%s - should never get here when skiplock is set \n", __FUNCTION__);
if (ncp == NULL) {
hfs_chash_unlock(hfsmp);
MALLOC_ZONE(ncp, struct cnode *, sizeof(struct cnode), M_HFSNODE, M_WAITOK);
/*
* since we dropped the chash lock,
* we need to go back and re-verify
* that this node hasn't come into
* existence...
*/
goto loop;
}
int
mremap_encrypted(__unused struct proc *p, struct mremap_encrypted_args *uap, __unused int32_t *retval)
{
mach_vm_offset_t user_addr;
mach_vm_size_t user_size;
kern_return_t result;
vm_map_t user_map;
uint32_t cryptid;
cpu_type_t cputype;
cpu_subtype_t cpusubtype;
pager_crypt_info_t crypt_info;
const char * cryptname = 0;
char *vpath;
int len, ret;
struct proc_regioninfo_internal pinfo;
vnode_t vp;
uintptr_t vnodeaddr;
uint32_t vid;
AUDIT_ARG(addr, uap->addr);
AUDIT_ARG(len, uap->len);
user_map = current_map();
user_addr = (mach_vm_offset_t) uap->addr;
user_size = (mach_vm_size_t) uap->len;
cryptid = uap->cryptid;
cputype = uap->cputype;
cpusubtype = uap->cpusubtype;
if (user_addr & vm_map_page_mask(user_map)) {
/* UNIX SPEC: user address is not page-aligned, return EINVAL */
return EINVAL;
}
switch(cryptid) {
case 0:
/* not encrypted, just an empty load command */
return 0;
case 1:
cryptname="com.apple.unfree";
break;
case 0x10:
/* some random cryptid that you could manually put into
* your binary if you want NULL */
cryptname="com.apple.null";
break;
default:
return EINVAL;
}
if (NULL == text_crypter_create) return ENOTSUP;
ret = fill_procregioninfo_onlymappedvnodes( proc_task(p), user_addr, &pinfo, &vnodeaddr, &vid);
if (ret == 0 || !vnodeaddr) {
/* No really, this returns 0 if the memory address is not backed by a file */
return (EINVAL);
}
vp = (vnode_t)vnodeaddr;
if ((vnode_getwithvid(vp, vid)) == 0) {
MALLOC_ZONE(vpath, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
if(vpath == NULL) {
vnode_put(vp);
return (ENOMEM);
}
len = MAXPATHLEN;
ret = vn_getpath(vp, vpath, &len);
if(ret) {
FREE_ZONE(vpath, MAXPATHLEN, M_NAMEI);
vnode_put(vp);
return (ret);
}
vnode_put(vp);
} else {
return (EINVAL);
}
#if 0
kprintf("%s vpath %s cryptid 0x%08x cputype 0x%08x cpusubtype 0x%08x range 0x%016llx size 0x%016llx\n",
__FUNCTION__, vpath, cryptid, cputype, cpusubtype, (uint64_t)user_addr, (uint64_t)user_size);
#endif
/* set up decrypter first */
crypt_file_data_t crypt_data = {
.filename = vpath,
.cputype = cputype,
.cpusubtype = cpusubtype };
result = text_crypter_create(&crypt_info, cryptname, (void*)&crypt_data);
#if VM_MAP_DEBUG_APPLE_PROTECT
if (vm_map_debug_apple_protect) {
printf("APPLE_PROTECT: %d[%s] map %p [0x%llx:0x%llx] %s(%s) -> 0x%x\n",
p->p_pid, p->p_comm,
user_map,
(uint64_t) user_addr,
(uint64_t) (user_addr + user_size),
__FUNCTION__, vpath, result);
}
#endif /* VM_MAP_DEBUG_APPLE_PROTECT */
FREE_ZONE(vpath, MAXPATHLEN, M_NAMEI);
if(result) {
printf("%s: unable to create decrypter %s, kr=%d\n",
__FUNCTION__, cryptname, result);
if (result == kIOReturnNotPrivileged) {
/* text encryption returned decryption failure */
return (EPERM);
} else {
return (ENOMEM);
}
}
/* now remap using the decrypter */
vm_object_offset_t crypto_backing_offset;
crypto_backing_offset = -1; /* i.e. use map entry's offset */
result = vm_map_apple_protected(user_map,
user_addr,
user_addr+user_size,
crypto_backing_offset,
&crypt_info);
if (result) {
printf("%s: mapping failed with %d\n", __FUNCTION__, result);
}
if (result) {
return (EPERM);
}
return 0;
}
/**
* ntfs_inode_hash_get - find or allocate, and return a loaded ntfs inode
*
* Search the ntfs inode hash for the ntfs inode matching @na and if present
* return it.
*
* If the found ntfs inode has a vnode attached, then get an iocount reference
* on the vnode.
*
* If not present, allocate the ntfs inode, add it to the hash, and initialize
* it before returning it. The inode will be marked NInoAlloc() and no vnode
* will be attached yet.
*/
ntfs_inode *ntfs_inode_hash_get(ntfs_volume *vol, const ntfs_attr *na)
{
ntfs_inode_list_head *list;
ntfs_inode *ni, *nni;
ntfs_debug("Entering for mft_no 0x%llx, type 0x%x, name_len 0x%x.",
(unsigned long long)na->mft_no,
(unsigned)le32_to_cpu(na->type), na->name_len);
list = ntfs_inode_hash_list(vol, na->mft_no);
ni = ntfs_inode_hash_list_find(vol, list, na);
if (ni) {
ntfs_debug("Done (ntfs_inode found in cache).");
return ni;
}
/* Not found, allocate a new ntfs_inode and initialize it. */
nni = malloc(sizeof(ntfs_inode), M_NTFS, M_WAITOK);
if (!nni) {
ntfs_error(vol->mp, "Failed to allocate new ntfs_inode.");
return nni;
}
if (ntfs_inode_init(vol, nni, na)) {
free(nni, M_NTFS);
ntfs_error(vol->mp, "Failed to initialize new ntfs_inode.");
return NULL;
}
/*
* Take the hash lock and ensure a racing process did not already
* allocate the inode by searching for it again in the cache.
*/
retry:
mtx_lock(&ntfs_inode_hash_lock);
ni = ntfs_inode_hash_list_find_nolock(vol, list, na);
if (ni) {
/*
* Someone else already added the ntfs inode so return that and
* throw away ours.
*/
vnode_t vn;
u32 vn_id = 0;
vn = ni->vn;
if (vn)
vn_id = vnode_vid(vn);
/* Drops the hash lock. */
ntfs_inode_wait_locked(ni, &ntfs_inode_hash_lock);
if (vn && vnode_getwithvid(vn, vn_id))
goto retry;
free(nni, M_NTFS);
ntfs_debug("Done (ntfs_inode found in cache - lost race)).");
return ni;
}
/*
* We have allocated a new ntfs inode, it is NInoLocked() and
* NInoAlloc() and we hold the hash lock so we can now add our inode to
* the hash list bucket and drop the hash lock.
*/
LIST_INSERT_HEAD(list, nni, hash);
mtx_unlock(&ntfs_inode_hash_lock);
/* Add the inode to the list of inodes in the volume. */
mtx_lock(&vol->inodes_lock);
LIST_INSERT_HEAD(&vol->inodes, nni, inodes);
mtx_unlock(&vol->inodes_lock);
ntfs_debug("Done (new ntfs_inode added to cache).");
return nni;
}
__private_extern__ int
nget_9p(mount_9p *nmp, fid_9p fid, qid_9p qid, vnode_t dvp, vnode_t *vpp, struct componentname *cnp, vfs_context_t ctx)
{
#pragma unused(ctx)
struct vnode_fsparam fsp;
struct hnode_9p *nhp;
node_9p *np;
uint32_t vid;
int e, i;
TRACE();
nhp = HASH9P(nmp, qid.path);
loop:
lck_mtx_lock(nmp->nodelck);
LIST_FOREACH (np, nhp, next) {
if(np->dir.qid.path != qid.path)
continue;
if (ISSET(np->flags, NODE_INIT)) {
SET(np->flags, NODE_WAITINIT);
msleep(np, nmp->nodelck, PINOD|PDROP, "nget_9p_init", NULL);
goto loop;
}
if (ISSET(np->flags, NODE_RECL)) {
SET(np->flags, NODE_WAITRECL);
msleep(np, nmp->nodelck, PINOD|PDROP, "nget_9p_reclaim", NULL);
goto loop;
}
vid = vnode_vid(np->vp);
lck_mtx_unlock(nmp->nodelck);
if (vnode_getwithvid(np->vp, vid))
goto loop;
nlock_9p(np, NODE_LCK_EXCLUSIVE);
if (dvp && cnp && ISSET(cnp->cn_flags, MAKEENTRY) && np->dir.qid.vers!=0) {
// DEBUG("caching %s", np->dir->name);
cache_enter(dvp, np->vp, cnp);
} else {
// DEBUG("not in cache qid=%d %s", qid.vers, np->dir->name);
}
*vpp = np->vp;
return 0;
}
if (fid == NOFID)
return EFAULT;
np = malloc_9p(sizeof(*np));
if (np == NULL) {
err0:
lck_mtx_unlock(nmp->nodelck);
return ENOMEM;
}
np->lck = lck_rw_alloc_init(lck_grp_9p, LCK_ATTR_NULL);
if (np->lck == NULL) {
free_9p(np);
goto err0;
}
np->nmp = nmp;
np->fid = fid;
np->dir.qid = qid;
for (i=0; i<3; i++)
np->openfid[i].fid = NOFID;
SET(np->flags, NODE_INIT);
LIST_INSERT_HEAD(nhp, np, next);
nlock_9p(np, NODE_LCK_EXCLUSIVE);
lck_mtx_unlock(nmp->nodelck);
if ((e=ngetdir_9p(np))) {
err1:
nunlock_9p(np);
lck_mtx_lock(nmp->nodelck);
LIST_REMOVE(np, next);
CLR(np->flags, NODE_INIT);
if (ISSET(np->flags, NODE_WAITINIT)) {
CLR(np->flags, NODE_WAITINIT);
wakeup(np);
}
lck_mtx_unlock(nmp->nodelck);
lck_rw_free(np->lck, lck_grp_9p);
free_9p(np);
return e;
}
fsp.vnfs_mp = nmp->mp;
fsp.vnfs_str = fsname;
fsp.vnfs_dvp = dvp;
fsp.vnfs_fsnode = np;
fsp.vnfs_vops = vnode_op_9p;
fsp.vnfs_markroot = dvp==NULL? TRUE: FALSE;
fsp.vnfs_marksystem = FALSE;
fsp.vnfs_filesize = np->dir.length;
fsp.vnfs_cnp = cnp;
fsp.vnfs_flags = VNFS_ADDFSREF;
dirvtype_9p(&np->dir, ISSET(nmp->flags, F_DOTU), &fsp.vnfs_vtype, &fsp.vnfs_rdev);
if (!dvp || !cnp || !ISSET(cnp->cn_flags, MAKEENTRY) || qid.vers==0)
SET(fsp.vnfs_flags, VNFS_NOCACHE);
if ((e=vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &fsp, &np->vp)))
goto err1;
vnode_settag(np->vp, VT_OTHER);
lck_mtx_lock(nmp->nodelck);
CLR(np->flags, NODE_INIT);
if (ISSET(np->flags, NODE_WAITINIT)) {
CLR(np->flags, NODE_WAITINIT);
wakeup(np);
}
lck_mtx_unlock(nmp->nodelck);
*vpp = np->vp;
return 0;
}
/*
* Look up a vnode/nfsnode by file handle.
* Callers must check for mount points!!
* In all cases, a pointer to a
* nfsnode structure is returned.
*/
int
nfs_nget(
mount_t mp,
nfsnode_t dnp,
struct componentname *cnp,
u_char *fhp,
int fhsize,
struct nfs_vattr *nvap,
u_int64_t *xidp,
uint32_t auth,
int flags,
nfsnode_t *npp)
{
nfsnode_t np;
struct nfsnodehashhead *nhpp;
vnode_t vp;
int error, nfsvers;
mount_t mp2;
struct vnode_fsparam vfsp;
uint32_t vid;
FSDBG_TOP(263, mp, dnp, flags, npp);
/* Check for unmount in progress */
if (!mp || vfs_isforce(mp)) {
*npp = NULL;
error = ENXIO;
FSDBG_BOT(263, mp, dnp, 0xd1e, error);
return (error);
}
nfsvers = VFSTONFS(mp)->nm_vers;
nhpp = NFSNOHASH(nfs_hash(fhp, fhsize));
loop:
lck_mtx_lock(nfs_node_hash_mutex);
for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
mp2 = (np->n_hflag & NHINIT) ? np->n_mount : NFSTOMP(np);
if (mp != mp2 || np->n_fhsize != fhsize ||
bcmp(fhp, np->n_fhp, fhsize))
continue;
if (nvap && (nvap->nva_flags & NFS_FFLAG_TRIGGER_REFERRAL) &&
cnp && (cnp->cn_namelen > (fhsize - (int)sizeof(dnp)))) {
/* The name was too long to fit in the file handle. Check it against the node's name. */
int namecmp = 0;
const char *vname = vnode_getname(NFSTOV(np));
if (vname) {
if (cnp->cn_namelen != (int)strlen(vname))
namecmp = 1;
else
namecmp = strncmp(vname, cnp->cn_nameptr, cnp->cn_namelen);
vnode_putname(vname);
}
if (namecmp) /* full name didn't match */
continue;
}
FSDBG(263, dnp, np, np->n_flag, 0xcace0000);
/* if the node is locked, sleep on it */
if ((np->n_hflag & NHLOCKED) && !(flags & NG_NOCREATE)) {
np->n_hflag |= NHLOCKWANT;
FSDBG(263, dnp, np, np->n_flag, 0xcace2222);
msleep(np, nfs_node_hash_mutex, PDROP | PINOD, "nfs_nget", NULL);
FSDBG(263, dnp, np, np->n_flag, 0xcace3333);
goto loop;
}
vp = NFSTOV(np);
vid = vnode_vid(vp);
lck_mtx_unlock(nfs_node_hash_mutex);
if ((error = vnode_getwithvid(vp, vid))) {
/*
* If vnode is being reclaimed or has already
* changed identity, no need to wait.
*/
FSDBG_BOT(263, dnp, *npp, 0xcace0d1e, error);
return (error);
}
if ((error = nfs_node_lock(np))) {
/* this only fails if the node is now unhashed */
/* so let's see if we can find/create it again */
FSDBG(263, dnp, *npp, 0xcaced1e2, error);
vnode_put(vp);
if (flags & NG_NOCREATE) {
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0xcaced1e0, ENOENT);
return (ENOENT);
}
goto loop;
}
/* update attributes */
if (nvap)
error = nfs_loadattrcache(np, nvap, xidp, 0);
if (error) {
nfs_node_unlock(np);
vnode_put(vp);
} else {
if (dnp && cnp && (flags & NG_MAKEENTRY))
cache_enter(NFSTOV(dnp), vp, cnp);
/*
* Update the vnode if the name/and or the parent has
* changed. We need to do this so that if getattrlist is
* called asking for ATTR_CMN_NAME, that the "most"
* correct name is being returned. In addition for
* monitored vnodes we need to kick the vnode out of the
* name cache. We do this so that if there are hard
* links in the same directory the link will not be
* found and a lookup will get us here to return the
* name of the current link. In addition by removing the
* name from the name cache the old name will not be
* found after a rename done on another client or the
* server. The principle reason to do this is because
* Finder is asking for notifications on a directory.
* The directory changes, Finder gets notified, reads
* the directory (which we have purged) and for each
* entry returned calls getattrlist with the name
* returned from readdir. gettattrlist has to call
* namei/lookup to resolve the name, because its not in
* the cache we end up here. We need to update the name
* so Finder will get the name it called us with.
*
* We had an imperfect solution with respect to case
* sensitivity. There is a test that is run in
* FileBuster that does renames from some name to
* another name differing only in case. It then reads
* the directory looking for the new name, after it
* finds that new name, it ask gettattrlist to verify
* that the name is the new name. Usually that works,
* but renames generate fsevents and fseventsd will do a
* lookup on the name via lstat. Since that test renames
* old name to new name back and forth there is a race
* that an fsevent will be behind and will access the
* file by the old name, on a case insensitive file
* system that will work. Problem is if we do a case
* sensitive compare, we're going to change the name,
* which the test's getattrlist verification step is
* going to fail. So we will check the case sensitivity
* of the file system and do the appropriate compare. In
* a rare instance for non homogeneous file systems
* w.r.t. pathconf we will use case sensitive compares.
* That could break if the file system is actually case
* insensitive.
*
* Note that V2 does not know the case, so we just
* assume case sensitivity.
*
* This is clearly not perfect due to races, but this is
* as good as its going to get. You can defeat the
* handling of hard links simply by doing:
*
* while :; do ls -l > /dev/null; done
*
* in a terminal window. Even a single ls -l can cause a
* race.
*
* <rant>What we really need is for the caller, that
* knows the name being used is valid since it got it
* from a readdir to use that name and not ask for the
* ATTR_CMN_NAME</rant>
*/
if (dnp && cnp && (vp != NFSTOV(dnp))) {
int update_flags = (vnode_ismonitored((NFSTOV(dnp)))) ? VNODE_UPDATE_CACHE : 0;
int (*cmp)(const char *s1, const char *s2, size_t n);
cmp = nfs_case_insensitive(mp) ? strncasecmp : strncmp;
if (vp->v_name && cnp->cn_namelen && (*cmp)(cnp->cn_nameptr, vp->v_name, cnp->cn_namelen))
update_flags |= VNODE_UPDATE_NAME;
if ((vp->v_name == NULL && cnp->cn_namelen != 0) || (vp->v_name != NULL && cnp->cn_namelen == 0))
update_flags |= VNODE_UPDATE_NAME;
if (vnode_parent(vp) != NFSTOV(dnp))
update_flags |= VNODE_UPDATE_PARENT;
if (update_flags) {
NFS_NODE_DBG("vnode_update_identity old name %s new name %.*s update flags = %x\n",
vp->v_name, cnp->cn_namelen, cnp->cn_nameptr ? cnp->cn_nameptr : "", update_flags);
vnode_update_identity(vp, NFSTOV(dnp), cnp->cn_nameptr, cnp->cn_namelen, 0, update_flags);
}
}
*npp = np;
}
FSDBG_BOT(263, dnp, *npp, 0xcace0000, error);
return(error);
}
FSDBG(263, mp, dnp, npp, 0xaaaaaaaa);
if (flags & NG_NOCREATE) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOENT);
return (ENOENT);
}
/*
* allocate and initialize nfsnode and stick it in the hash
* before calling getnewvnode(). Anyone finding it in the
* hash before initialization is complete will wait for it.
*/
MALLOC_ZONE(np, nfsnode_t, sizeof *np, M_NFSNODE, M_WAITOK);
if (!np) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOMEM);
return (ENOMEM);
}
bzero(np, sizeof *np);
np->n_hflag |= (NHINIT | NHLOCKED);
np->n_mount = mp;
np->n_auth = auth;
TAILQ_INIT(&np->n_opens);
TAILQ_INIT(&np->n_lock_owners);
TAILQ_INIT(&np->n_locks);
np->n_dlink.tqe_next = NFSNOLIST;
np->n_dreturn.tqe_next = NFSNOLIST;
np->n_monlink.le_next = NFSNOLIST;
/* ugh... need to keep track of ".zfs" directories to workaround server bugs */
if ((nvap->nva_type == VDIR) && cnp && (cnp->cn_namelen == 4) &&
(cnp->cn_nameptr[0] == '.') && (cnp->cn_nameptr[1] == 'z') &&
(cnp->cn_nameptr[2] == 'f') && (cnp->cn_nameptr[3] == 's'))
np->n_flag |= NISDOTZFS;
if (dnp && (dnp->n_flag & NISDOTZFS))
np->n_flag |= NISDOTZFSCHILD;
if (dnp && cnp && ((cnp->cn_namelen != 2) ||
(cnp->cn_nameptr[0] != '.') || (cnp->cn_nameptr[1] != '.'))) {
vnode_t dvp = NFSTOV(dnp);
if (!vnode_get(dvp)) {
if (!vnode_ref(dvp))
np->n_parent = dvp;
vnode_put(dvp);
}
}
/* setup node's file handle */
if (fhsize > NFS_SMALLFH) {
MALLOC_ZONE(np->n_fhp, u_char *,
fhsize, M_NFSBIGFH, M_WAITOK);
if (!np->n_fhp) {
lck_mtx_unlock(nfs_node_hash_mutex);
FREE_ZONE(np, sizeof *np, M_NFSNODE);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000002, ENOMEM);
return (ENOMEM);
}
} else {
/**
* Get VBoxVFS root vnode.
*
* Handle three cases here:
* - vnode does not exist yet: create a new one
* - currently creating vnode: wait till the end, increment usage count and return existing one
* - vnode already created: increment usage count and return existing one
* - vnode was failed to create: give a chance to try to re-create it later
*
* @param mp Mount data provided by VFS layer.
* @param ppVnode vnode to return.
* @param pContext kAuth context needed in order to authentificate mount operation.
*
* @return 0 on success or BSD error code otherwise.
*/
static int
vboxvfs_root(struct mount *mp, struct vnode **ppVnode, vfs_context_t pContext)
{
NOREF(pContext);
vboxvfs_mount_t *pMount;
int rc = 0;
uint32_t vid;
PDEBUG("Getting root vnode...");
AssertReturn(mp, EINVAL);
AssertReturn(ppVnode, EINVAL);
pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp);
AssertReturn(pMount, EINVAL);
/* Check case when vnode does not exist yet */
if (ASMAtomicCmpXchgU8(&pMount->fRootVnodeState, VBOXVFS_OBJECT_INITIALIZING, VBOXVFS_OBJECT_UNINITIALIZED))
{
PDEBUG("Create new root vnode");
/* Allocate empty SHFLSTRING to indicate path to root vnode within Shared Folder */
char szEmpty[1];
SHFLSTRING *pSFVnodePath;
pSFVnodePath = vboxvfs_construct_shflstring((char *)szEmpty, 0);
if (pSFVnodePath)
{
int rc2;
rc2 = vboxvfs_create_vnode_internal(mp, VDIR, NULL, TRUE, pSFVnodePath, &pMount->pRootVnode);
if (rc2 != 0)
{
RTMemFree(pSFVnodePath);
rc = ENOTSUP;
}
}
else
rc = ENOMEM;
/* Notify other threads about result */
if (rc == 0)
ASMAtomicWriteU8(&pMount->fRootVnodeState, VBOXVFS_OBJECT_INITIALIZED);
else
ASMAtomicWriteU8(&pMount->fRootVnodeState, VBOXVFS_OBJECT_INVALID);
}
else
{
/* Check case if we are currently creating vnode. Wait while other thread to finish allocation. */
uint8_t fRootVnodeState = VBOXVFS_OBJECT_UNINITIALIZED;
while (fRootVnodeState != VBOXVFS_OBJECT_INITIALIZED
&& fRootVnodeState != VBOXVFS_OBJECT_INVALID)
{
/* @todo: Currently, we are burning CPU cycles while waiting. This is for a short
* time but we should relax here! */
fRootVnodeState = ASMAtomicReadU8(&pMount->fRootVnodeState);
}
/* Check if the other thread initialized root vnode and it is ready to be returned */
if (fRootVnodeState == VBOXVFS_OBJECT_INITIALIZED)
{
/* Take care about iocount */
vid = vnode_vid(pMount->pRootVnode);
rc = vnode_getwithvid(pMount->pRootVnode, vid);
}
else
{
/* Other thread reported initialization failure.
* Set vnode state VBOXVFS_OBJECT_UNINITIALIZED in order to try recreate root
* vnode in other attempt */
ASMAtomicWriteU8(&pMount->fRootVnodeState, VBOXVFS_OBJECT_UNINITIALIZED);
}
}
/* Only return vnode if we got success */
if (rc == 0)
{
PDEBUG("Root vnode can be returned");
*ppVnode = pMount->pRootVnode;
}
else
PDEBUG("Root vnode cannot be returned: 0x%X", rc);
return rc;
}
