static int
vnop_fsync_9p(struct vnop_fsync_args *ap)
{
node_9p *np;
dir_9p d;
int e;
TRACE();
if (!vnode_isreg(ap->a_vp))
return 0;
np = NTO9P(ap->a_vp);
nlock_9p(np, NODE_LCK_EXCLUSIVE);
if (ubc_getsize(ap->a_vp)>0 && !vnode_isnocache(ap->a_vp)) {
if (ISSET(np->flags, NODE_MMAPPED))
ubc_msync(np->vp, 0, ubc_getsize(np->vp), NULL, UBC_PUSHDIRTY|UBC_SYNC);
else
cluster_push(np->vp, IO_SYNC);
}
e = 0;
/* only sync write fids */
if (np->openfid[OWRITE].fid!=NOFID || np->openfid[ORDWR].fid!=NOFID) {
nulldir(&d);
e = wstat_9p(np->nmp, np->fid, &d);
}
nunlock_9p(np);
return e;
}
__private_extern__
int
fuse_internal_remove(vnode_t dvp,
vnode_t vp,
struct componentname *cnp,
enum fuse_opcode op,
vfs_context_t context)
{
struct fuse_dispatcher fdi;
struct vnode_attr *vap = VTOVA(vp);
int need_invalidate = 0;
uint64_t target_nlink = 0;
mount_t mp = vnode_mount(vp);
int err = 0;
fdisp_init(&fdi, cnp->cn_namelen + 1);
fdisp_make_vp(&fdi, op, dvp, context);
memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
((char *)fdi.indata)[cnp->cn_namelen] = '\0';
if ((vap->va_nlink > 1) && vnode_isreg(vp)) {
need_invalidate = 1;
target_nlink = vap->va_nlink;
}
if (!(err = fdisp_wait_answ(&fdi))) {
fuse_ticket_drop(fdi.tick);
}
fuse_invalidate_attr(dvp);
fuse_invalidate_attr(vp);
/*
* XXX: M_MACFUSE_INVALIDATE_CACHED_VATTRS_UPON_UNLINK
*
* Consider the case where vap->va_nlink > 1 for the entity being
* removed. In our world, other in-memory vnodes that share a link
* count each with this one may not know right way that this one just
* got deleted. We should let them know, say, through a vnode_iterate()
* here and a callback that does fuse_invalidate_attr(vp) on each
* relevant vnode.
*/
if (need_invalidate && !err) {
if (!vfs_busy(mp, LK_NOWAIT)) {
vnode_iterate(mp, 0, fuse_internal_remove_callback,
(void *)&target_nlink);
vfs_unbusy(mp);
} else {
IOLog("MacFUSE: skipping link count fixup upon remove\n");
}
}
return err;
}
static int
fuse_internal_remove_callback(struct vnode *vp, void *cargs)
{
struct vattr *vap;
uint64_t target_nlink;
vap = VTOVA(vp);
target_nlink = *(uint64_t *)cargs;
/* somewhat lame "heuristics", but you got better ideas? */
if ((vap->va_nlink == target_nlink) && vnode_isreg(vp)) {
fuse_invalidate_attr(vp);
}
return 0;
}
bool VNodeDiskDeviceClass::setupVNode() {
int vapError = -1;
struct vnode_attr vap;
if (m_vnode != NULL)
return true;
vfs_context_t vfsContext = vfs_context_create((vfs_context_t) 0);
int vnodeError = vnode_open(m_filePath->getCStringNoCopy(), (FREAD | FWRITE), 0, 0,
&m_vnode, vfsContext);
if (vnodeError || m_vnode == NULL) {
IOLog("Error when opening file %s: error %d\n",
m_filePath->getCStringNoCopy(), vnodeError);
goto failure;
}
if (!vnode_isreg(m_vnode)) {
IOLog("Error when opening file %s: not a regular file\n",
m_filePath->getCStringNoCopy());
vnode_close(m_vnode, (FREAD | FWRITE), vfsContext);
goto failure;
}
VATTR_INIT(&vap);
VATTR_WANTED(&vap, va_data_size);
vapError = vnode_getattr(m_vnode, &vap, vfsContext);
if (vapError) {
IOLog("Error when retrieving vnode's attributes with error code %d\n", vapError);
goto failure;
}
if (vap.va_data_size < m_blockSize * m_blockNum) {
IOLog("Error file %s is too small, actual size is %llu\n",
m_filePath->getCStringNoCopy(), vap.va_data_size);
goto failure;
}
vfs_context_rele(vfsContext);
return true;
failure:
vfs_context_rele(vfsContext);
return false;
}
IOReturn FileNVRAM::write_buffer(char* aBuffer, vfs_context_t aCtx)
{
IOReturn error = 0;
int length = (int)strlen(aBuffer);
struct vnode * vp;
if (aCtx)
{
if ((error = vnode_open(FILE_NVRAM_PATH, (O_TRUNC | O_CREAT | FWRITE | O_NOFOLLOW), S_IRUSR | S_IWUSR, VNODE_LOOKUP_NOFOLLOW, &vp, aCtx)))
{
printf("FileNVRAM.kext: Error, vnode_open(%s) failed with error %d!\n", FILE_NVRAM_PATH, error);
return error;
}
else
{
if ((error = vnode_isreg(vp)) == VREG)
{
if ((error = vn_rdwr(UIO_WRITE, vp, aBuffer, length, 0, UIO_SYSSPACE, IO_NOCACHE|IO_NODELOCKED|IO_UNIT, vfs_context_ucred(aCtx), (int *) 0, vfs_context_proc(aCtx))))
{
printf("FileNVRAM.kext: Error, vn_rdwr(%s) failed with error %d!\n", FILE_NVRAM_PATH, error);
}
if ((error = vnode_close(vp, FWASWRITTEN, aCtx)))
{
printf("FileNVRAM.kext: Error, vnode_close(%s) failed with error %d!\n", FILE_NVRAM_PATH, error);
}
}
else
{
printf("FileNVRAM.kext: Error, vnode_isreg(%s) failed with error %d!\n", FILE_NVRAM_PATH, error);
}
}
}
else
{
printf("FileNVRAM.kext: aCtx == NULL!\n");
error = 0xFFFF; // EINVAL;
}
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;
}
/*
* Decide whether it is okay to remove within a sticky directory.
*
* In sticky directories, write access is not sufficient;
* you can remove entries from a directory only if:
*
* you own the directory,
* you own the entry,
* the entry is a plain file and you have write access,
* or you are privileged (checked in secpolicy...).
*
* The function returns 0 if remove access is granted.
*/
int
zfs_sticky_remove_access(znode_t *zdp, znode_t *zp, cred_t *cr)
{
uid_t uid;
if (zdp->z_zfsvfs->z_assign >= TXG_INITIAL) /* ZIL replay */
return (0);
if ((zdp->z_mode & S_ISVTX) == 0 ||
(uid = crgetuid(cr)) == zdp->z_uid ||
uid == zp->z_uid ||
(
#ifdef __APPLE__
vnode_isreg(ZTOV(zp)) &&
#else
ZTOV(zp)->v_type == VREG &&
#endif
zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr) == 0)
)
return (0);
else
return (secpolicy_vnode_remove(cr));
}
/*
* Decide whether it is okay to remove within a sticky directory.
*
* In sticky directories, write access is not sufficient;
* you can remove entries from a directory only if:
*
* you own the directory,
* you own the entry,
* the entry is a plain file and you have write access,
* or you are privileged (checked in secpolicy...).
*
* The function returns 0 if remove access is granted.
*/
int
zfs_sticky_remove_access(znode_t *zdp, znode_t *zp, cred_t *cr)
{
uid_t uid;
uid_t downer;
uid_t fowner;
zfsvfs_t *zfsvfs = zdp->z_zfsvfs;
if (zdp->z_zfsvfs->z_replay)
return (0);
if ((zdp->z_mode & S_ISVTX) == 0)
return (0);
downer = zfs_fuid_map_id(zfsvfs, zdp->z_uid, cr, ZFS_OWNER);
fowner = zfs_fuid_map_id(zfsvfs, zp->z_uid, cr, ZFS_OWNER);
if ((uid = crgetuid(cr)) == downer || uid == fowner ||
(vnode_isreg(ZTOV(zp)) &&
zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr) == 0))
return (0);
else
return (secpolicy_vnode_remove(ZTOV(zp), cr));
}
static int process_cred_label_update_execvew(kauth_cred_t old_cred,
kauth_cred_t new_cred,
struct proc *p,
struct vnode *vp,
off_t offset,
struct vnode *scriptvp,
struct label *vnodelabel,
struct label *scriptvnodelabel,
struct label *execlabel,
u_int *csflags,
void *macpolicyattr,
size_t macpolicyattrlen,
int *disjointp) {
int path_len = MAXPATHLEN;
if (!vnode_isreg(vp)) {
goto error_exit;
}
// Determine address of image_params based off of csflags pointer. (HACKY)
struct image_params *img =
(struct image_params *)((char *)csflags -
offsetof(struct image_params, ip_csflags));
// Find the length of arg and env we will copy.
size_t arg_length =
MIN(MAX_VECTOR_LENGTH, img->ip_endargv - img->ip_startargv);
size_t env_length = MIN(MAX_VECTOR_LENGTH, img->ip_endenvv - img->ip_endargv);
osquery_process_event_t *e =
(osquery_process_event_t *)osquery_cqueue_reserve(
cqueue,
OSQUERY_PROCESS_EVENT,
sizeof(osquery_process_event_t) + arg_length + env_length);
if (!e) {
goto error_exit;
}
// Copy the arg and env vectors.
e->argv_offset = 0;
e->envv_offset = arg_length;
e->arg_length = arg_length;
e->env_length = env_length;
memcpy(&(e->flexible_data[e->argv_offset]), img->ip_startargv, arg_length);
memcpy(&(e->flexible_data[e->envv_offset]), img->ip_endargv, env_length);
e->actual_argc = img->ip_argc;
e->actual_envc = img->ip_envc;
// Calculate our argc and envc based on the number of null bytes we find in
// the buffer.
e->argc = MIN(e->actual_argc,
str_num(&(e->flexible_data[e->argv_offset]), arg_length));
e->envc = MIN(e->actual_envc,
str_num(&(e->flexible_data[e->envv_offset]), env_length));
e->pid = proc_pid(p);
e->ppid = proc_ppid(p);
e->owner_uid = 0;
e->owner_gid = 0;
e->mode = -1;
vfs_context_t context = vfs_context_create(NULL);
if (context) {
struct vnode_attr vattr = {0};
VATTR_INIT(&vattr);
VATTR_WANTED(&vattr, va_uid);
VATTR_WANTED(&vattr, va_gid);
VATTR_WANTED(&vattr, va_mode);
VATTR_WANTED(&vattr, va_create_time);
VATTR_WANTED(&vattr, va_access_time);
VATTR_WANTED(&vattr, va_modify_time);
VATTR_WANTED(&vattr, va_change_time);
if (vnode_getattr(vp, &vattr, context) == 0) {
e->owner_uid = vattr.va_uid;
e->owner_gid = vattr.va_gid;
e->mode = vattr.va_mode;
e->create_time = vattr.va_create_time.tv_sec;
e->access_time = vattr.va_access_time.tv_sec;
e->modify_time = vattr.va_modify_time.tv_sec;
e->change_time = vattr.va_change_time.tv_sec;
}
vfs_context_rele(context);
}
e->uid = kauth_cred_getruid(new_cred);
e->euid = kauth_cred_getuid(new_cred);
e->gid = kauth_cred_getrgid(new_cred);
e->egid = kauth_cred_getgid(new_cred);
vn_getpath(vp, e->path, &path_len);
osquery_cqueue_commit(cqueue, e);
error_exit:
return 0;
}
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);
}
IOReturn FileNVRAM::read_buffer(char** aBuffer, uint64_t* aLength, vfs_context_t aCtx)
{
IOReturn error = 0;
struct vnode * vp;
struct vnode_attr va;
if (aCtx)
{
if ((error = vnode_open(FILE_NVRAM_PATH, (O_RDONLY | FREAD | O_NOFOLLOW), S_IRUSR, VNODE_LOOKUP_NOFOLLOW, &vp, aCtx)))
{
printf("failed opening vnode at path %s, errno %d\n", FILE_NVRAM_PATH, error);
return error;
}
else
{
if ((error = vnode_isreg(vp)) == VREG)
{
VATTR_INIT(&va);
VATTR_WANTED(&va, va_data_size); /* size in bytes of the fork managed by current vnode */
// Determine size of vnode
if ((error = vnode_getattr(vp, &va, aCtx)))
{
printf("FileNVRAM.kext: Error, failed to determine file size of %s, errno %d.\n", FILE_NVRAM_PATH, error);
}
else
{
if (aLength)
{
*aLength = va.va_data_size;
}
*aBuffer = (char *)IOMalloc((size_t)va.va_data_size);
int len = (int)va.va_data_size;
if ((error = vn_rdwr(UIO_READ, vp, *aBuffer, len, 0, UIO_SYSSPACE, IO_NOCACHE|IO_NODELOCKED|IO_UNIT, vfs_context_ucred(aCtx), (int *) 0, vfs_context_proc(aCtx))))
{
printf("FileNVRAM.kext: Error, writing to vnode(%s) failed with error %d!\n", FILE_NVRAM_PATH, error);
}
}
if ((error = vnode_close(vp, 0, aCtx)))
{
printf("FileNVRAM.kext: Error, vnode_close(%s) failed with error %d!\n", FILE_NVRAM_PATH, error);
}
}
else
{
printf("FileNVRAM.kext: Error, vnode_isreg(%s) failed with error %d!\n", FILE_NVRAM_PATH, error);
}
}
}
else
{
printf("FileNVRAM.kext: aCtx == NULL!\n");
error = 0xFFFF; // EINVAL;
}
return error;
}
static int
vnop_open_9p(struct vnop_open_args *ap)
{
openfid_9p *op;
node_9p *np;
fid_9p fid;
qid_9p qid;
uint32_t iounit;
int e, flags, mode;
TRACE();
flags = 0;
if (ap->a_mode)
flags = OFLAGS(ap->a_mode);
mode = flags & O_ACCMODE;
CLR(flags, O_ACCMODE);
CLR(flags, O_DIRECTORY|O_NONBLOCK|O_NOFOLLOW);
CLR(flags, O_APPEND);
/* locks implemented on the vfs layer */
CLR(flags, O_EXLOCK|O_SHLOCK);
if (ISSET(flags, O_TRUNC)) {
SET(mode, OTRUNC);
CLR(flags, O_TRUNC);
}
if (ISSET(flags, O_CLOEXEC)) {
SET(mode, OCEXEC);
CLR(flags, O_CLOEXEC);
}
if (ISSET(flags, O_EXCL)) {
SET(mode, OEXCL);
CLR(flags, O_EXCL);
}
/* vnop_creat just called */
CLR(flags, O_CREAT);
if (ISSET(flags, O_EVTONLY))
CLR(flags, O_EVTONLY);
if (ISSET(flags, FNOCACHE))
CLR(flags, FNOCACHE);
if (ISSET(flags, FNORDAHEAD))
CLR(flags, FNORDAHEAD);
if (flags) {
DEBUG("unexpected open mode %x", flags);
return ENOTSUP;
}
np = NTO9P(ap->a_vp);
nlock_9p(np, NODE_LCK_EXCLUSIVE);
op = ofidget(np, ap->a_mode);
if (op->fid == NOFID) {
if ((e=walk_9p(np->nmp, np->fid, NULL, 0, &fid, &qid)))
goto error;
if ((e=open_9p(np->nmp, fid, mode, &qid, &iounit)))
goto error;
np->iounit = iounit;
op->fid = fid;
}
/* no cache for dirs, .u or synthetic files */
if (!vnode_isreg(np->vp) || np->dir.qid.vers==0) {
vnode_setnocache(np->vp);
vnode_setnoreadahead(np->vp);
}
OSIncrementAtomic(&op->ref);
nunlock_9p(np);
return 0;
error:
clunk_9p(np->nmp, fid);
nunlock_9p(np);
return e;
}
/*
struct vnop_getattr_args {
struct vnode *a_vp;
struct vattr *a_vap;
struct ucred *a_cred;
struct thread *a_td;
};
*/
static int
fuse_vnop_getattr(struct vop_getattr_args *ap)
{
struct vnode *vp = ap->a_vp;
struct vattr *vap = ap->a_vap;
struct ucred *cred = ap->a_cred;
struct thread *td = curthread;
struct fuse_vnode_data *fvdat = VTOFUD(vp);
int err = 0;
int dataflags;
struct fuse_dispatcher fdi;
FS_DEBUG2G("inode=%ju\n", (uintmax_t)VTOI(vp));
dataflags = fuse_get_mpdata(vnode_mount(vp))->dataflags;
/* Note that we are not bailing out on a dead file system just yet. */
if (!(dataflags & FSESS_INITED)) {
if (!vnode_isvroot(vp)) {
fdata_set_dead(fuse_get_mpdata(vnode_mount(vp)));
err = ENOTCONN;
debug_printf("fuse_getattr b: returning ENOTCONN\n");
return err;
} else {
goto fake;
}
}
fdisp_init(&fdi, 0);
if ((err = fdisp_simple_putget_vp(&fdi, FUSE_GETATTR, vp, td, cred))) {
if ((err == ENOTCONN) && vnode_isvroot(vp)) {
/* see comment at similar place in fuse_statfs() */
fdisp_destroy(&fdi);
goto fake;
}
if (err == ENOENT) {
fuse_internal_vnode_disappear(vp);
}
goto out;
}
cache_attrs(vp, (struct fuse_attr_out *)fdi.answ);
if (vap != VTOVA(vp)) {
memcpy(vap, VTOVA(vp), sizeof(*vap));
}
if (vap->va_type != vnode_vtype(vp)) {
fuse_internal_vnode_disappear(vp);
err = ENOENT;
goto out;
}
if ((fvdat->flag & FN_SIZECHANGE) != 0)
vap->va_size = fvdat->filesize;
if (vnode_isreg(vp) && (fvdat->flag & FN_SIZECHANGE) == 0) {
/*
* This is for those cases when the file size changed without us
* knowing, and we want to catch up.
*/
off_t new_filesize = ((struct fuse_attr_out *)
fdi.answ)->attr.size;
if (fvdat->filesize != new_filesize) {
fuse_vnode_setsize(vp, cred, new_filesize);
}
}
debug_printf("fuse_getattr e: returning 0\n");
out:
fdisp_destroy(&fdi);
return err;
fake:
bzero(vap, sizeof(*vap));
vap->va_type = vnode_vtype(vp);
return 0;
}
static int
vdev_file_open(vdev_t *vd, uint64_t *psize, uint64_t *ashift)
{
vdev_file_t *vf;
#ifdef __APPLE__
struct vnode *vp, *rootdir;
struct vnode_attr vattr;
vfs_context_t context;
#else
vnode_t *vp;
vattr_t vattr;
#endif
int error;
/*
* 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);
}
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] == '/');
#ifdef __APPLE__
rootdir = getrootdir();
#endif
error = vn_openat(vd->vdev_path + 1, UIO_SYSSPACE, spa_mode | 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
/*
* Make sure it's a regular file.
*/
#ifdef __APPLE__
if (!vnode_isreg(vp)) {
#else
if (vp->v_type != VREG) {
#endif
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
return (ENODEV);
}
#endif
/*
* Determine the physical size of the file.
*/
#ifdef __APPLE__
VATTR_INIT(&vattr);
VATTR_WANTED(&vattr, va_data_size);
context = vfs_context_create((vfs_context_t)0);
error = vnode_getattr(vp, &vattr, context);
(void) vfs_context_rele(context);
if (error || !VATTR_IS_SUPPORTED(&vattr, va_data_size)) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
return (error);
}
*psize = vattr.va_data_size;
#else
vattr.va_mask = AT_SIZE;
error = VOP_GETATTR(vp, &vattr, 0, kcred);
if (error) {
vd->vdev_stat.vs_aux = VDEV_AUX_OPEN_FAILED;
return (error);
}
*psize = vattr.va_size;
#endif
*ashift = SPA_MINBLOCKSHIFT;
return (0);
}
static void
vdev_file_close(vdev_t *vd)
{
vdev_file_t *vf = vd->vdev_tsd;
if (vf == NULL)
return;
if (vf->vf_vnode != NULL) {
#ifdef __APPLE__
vfs_context_t context;
context = vfs_context_create((vfs_context_t)0);
/* ### APPLE TODO #### */
// (void) VOP_PUTPAGE(vf->vf_vnode, 0, 0, B_INVAL, kcred);
(void) vnode_close(vf->vf_vnode, spa_mode, context);
(void) vfs_context_rele(context);
#else
(void) VOP_PUTPAGE(vf->vf_vnode, 0, 0, B_INVAL, kcred);
(void) VOP_CLOSE(vf->vf_vnode, spa_mode, 1, 0, kcred);
VN_RELE(vf->vf_vnode);
#endif
}
kmem_free(vf, sizeof (vdev_file_t));
vd->vdev_tsd = 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);
}