/*
- * Copyright (c) 2000-2001 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/ubc.h>
+#include <sys/conf.h>
+#include <sys/disk.h>
+
+#include <vm/vm_kern.h>
+
+#include <miscfs/specfs/specdev.h>
+
+static int vn_closefile __P((struct file *fp, struct proc *p));
+static int vn_ioctl __P((struct file *fp, u_long com, caddr_t data,
+ struct proc *p));
+static int vn_read __P((struct file *fp, struct uio *uio,
+ struct ucred *cred, int flags, struct proc *p));
+static int vn_write __P((struct file *fp, struct uio *uio,
+ struct ucred *cred, int flags, struct proc *p));
+static int vn_select __P(( struct file *fp, int which, void * wql,
+ struct proc *p));
+static int vn_kqfilt_add __P((struct file *fp, struct knote *kn, struct proc *p));
+static int vn_kqfilt_remove __P((struct vnode *vp, uintptr_t ident, struct proc *p));
struct fileops vnops =
- { vn_read, vn_write, vn_ioctl, vn_select, vn_closefile };
+ { vn_read, vn_write, vn_ioctl, vn_select, vn_closefile, vn_kqfilt_add };
/*
* Common code for vnode open operations.
* Check permissions, and call the VOP_OPEN or VOP_CREATE routine.
*/
+int
vn_open(ndp, fmode, cmode)
register struct nameidata *ndp;
int fmode, cmode;
+{
+ return vn_open_modflags(ndp,&fmode,cmode);
+}
+
+__private_extern__ int
+vn_open_modflags(ndp, fmodep, cmode)
+ register struct nameidata *ndp;
+ int *fmodep;
+ int cmode;
{
register struct vnode *vp;
register struct proc *p = ndp->ni_cnd.cn_proc;
struct vattr vat;
struct vattr *vap = &vat;
int error;
+ int didhold = 0;
+ char *nameptr;
+ int fmode = *fmodep;
if (fmode & O_CREAT) {
ndp->ni_cnd.cn_nameiop = CREATE;
- ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF;
+ ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | AUDITVNPATH1;
if ((fmode & O_EXCL) == 0)
ndp->ni_cnd.cn_flags |= FOLLOW;
+ bwillwrite();
if (error = namei(ndp))
return (error);
if (ndp->ni_vp == NULL) {
+ nameptr = add_name(ndp->ni_cnd.cn_nameptr,
+ ndp->ni_cnd.cn_namelen,
+ ndp->ni_cnd.cn_hash, 0);
+
VATTR_NULL(vap);
vap->va_type = VREG;
vap->va_mode = cmode;
vap->va_vaflags |= VA_EXCLUSIVE;
VOP_LEASE(ndp->ni_dvp, p, cred, LEASE_WRITE);
if (error = VOP_CREATE(ndp->ni_dvp, &ndp->ni_vp,
- &ndp->ni_cnd, vap))
+ &ndp->ni_cnd, vap)) {
+ remove_name(nameptr);
return (error);
+ }
fmode &= ~O_TRUNC;
vp = ndp->ni_vp;
+
+ VNAME(vp) = nameptr;
+ if (vget(ndp->ni_dvp, 0, p) == 0) {
+ VPARENT(vp) = ndp->ni_dvp;
+ }
} else {
VOP_ABORTOP(ndp->ni_dvp, &ndp->ni_cnd);
if (ndp->ni_dvp == ndp->ni_vp)
}
} else {
ndp->ni_cnd.cn_nameiop = LOOKUP;
- ndp->ni_cnd.cn_flags = FOLLOW | LOCKLEAF;
+ ndp->ni_cnd.cn_flags = FOLLOW | LOCKLEAF | AUDITVNPATH1;
if (error = namei(ndp))
return (error);
vp = ndp->ni_vp;
error = EOPNOTSUPP;
goto bad;
}
+
+#if DIAGNOSTIC
+ if (UBCINFOMISSING(vp))
+ panic("vn_open: ubc_info_init");
+#endif /* DIAGNOSTIC */
+
+ if (UBCINFOEXISTS(vp) && ((didhold = ubc_hold(vp)) == 0)) {
+ error = ENOENT;
+ goto bad;
+ }
+
if ((fmode & O_CREAT) == 0) {
if (fmode & FREAD && fmode & (FWRITE | O_TRUNC)) {
int err = 0;
goto bad;
}
}
- if (fmode & O_TRUNC) {
- VOP_UNLOCK(vp, 0, p); /* XXX */
- VOP_LEASE(vp, p, cred, LEASE_WRITE);
- (void)vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p); /* XXX */
- VATTR_NULL(vap);
- vap->va_size = 0;
- if (error = VOP_SETATTR(vp, vap, cred, p))
- goto bad;
- }
-
-#if DIAGNOSTIC
- if (UBCINFOMISSING(vp))
- panic("vn_open: ubc_info_init");
-#endif /* DIAGNOSTIC */
-
- if (UBCINFOEXISTS(vp) && !ubc_hold(vp)) {
- error = ENOENT;
- goto bad;
- }
if (error = VOP_OPEN(vp, fmode, cred, p)) {
- ubc_rele(vp);
goto bad;
}
if (fmode & FWRITE)
if (++vp->v_writecount <= 0)
panic("vn_open: v_writecount");
+ *fmodep = fmode;
return (0);
bad:
- vput(vp);
+ VOP_UNLOCK(vp, 0, p);
+ if (didhold)
+ ubc_rele(vp);
+ vrele(vp);
+ ndp->ni_vp = NULL;
return (error);
}
* Check for write permissions on the specified vnode.
* Prototype text segments cannot be written.
*/
+int
vn_writechk(vp)
register struct vnode *vp;
{
/*
* Vnode close call
*/
+int
vn_close(vp, flags, cred, p)
register struct vnode *vp;
int flags;
{
int error;
- if (flags & FWRITE)
+ if (flags & FWRITE) {
+
vp->v_writecount--;
+
+ {
+ extern void notify_filemod_watchers(struct vnode *vp, struct proc *p);
+
+ notify_filemod_watchers(vp, p);
+ }
+ }
+
error = VOP_CLOSE(vp, flags, cred, p);
ubc_rele(vp);
vrele(vp);
/*
* Package up an I/O request on a vnode into a uio and do it.
*/
+int
vn_rdwr(rw, vp, base, len, offset, segflg, ioflg, cred, aresid, p)
enum uio_rw rw;
struct vnode *vp;
/*
* File table vnode read routine.
*/
-vn_read(fp, uio, cred)
+static int
+vn_read(fp, uio, cred, flags, p)
struct file *fp;
struct uio *uio;
struct ucred *cred;
+ int flags;
+ struct proc *p;
{
- struct vnode *vp = (struct vnode *)fp->f_data;
- struct proc *p = uio->uio_procp;
- int error;
+ struct vnode *vp;
+ int error, ioflag;
off_t count;
+ if (p != uio->uio_procp)
+ panic("vn_read: uio_procp does not match p");
+
+ vp = (struct vnode *)fp->f_data;
+ ioflag = 0;
+ if (fp->f_flag & FNONBLOCK)
+ ioflag |= IO_NDELAY;
VOP_LEASE(vp, p, cred, LEASE_READ);
- (void)vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
- uio->uio_offset = fp->f_offset;
+ error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ if (error)
+ return (error);
+ if ((flags & FOF_OFFSET) == 0)
+ uio->uio_offset = fp->f_offset;
count = uio->uio_resid;
- error = VOP_READ(vp, uio, (fp->f_flag & FNONBLOCK) ? IO_NDELAY : 0, cred);
-
- fp->f_offset += count - uio->uio_resid;
+ if(UBCINFOEXISTS(vp)) {
+ memory_object_t pager;
+ struct iovec *iov;
+ off_t file_off;
+ kern_return_t kr = KERN_SUCCESS;
+ kern_return_t ret = KERN_SUCCESS;
+ int count;
+
+ pager = (memory_object_t)ubc_getpager(vp);
+ file_off = uio->uio_offset;
+ iov = uio->uio_iov;
+ count = uio->uio_iovcnt;
+ while(count) {
+ kr = vm_conflict_check(current_map(),
+ (vm_offset_t)iov->iov_base, iov->iov_len,
+ pager, file_off);
+ if(kr == KERN_ALREADY_WAITING) {
+ if((count != uio->uio_iovcnt) &&
+ (ret != KERN_ALREADY_WAITING)) {
+ error = EINVAL;
+ goto done;
+ }
+ ret = KERN_ALREADY_WAITING;
+ } else if (kr != KERN_SUCCESS) {
+ error = EINVAL;
+ goto done;
+ }
+ if(kr != ret) {
+ error = EINVAL;
+ goto done;
+ }
+ file_off += iov->iov_len;
+ iov++;
+ count--;
+ }
+ if(ret == KERN_ALREADY_WAITING) {
+ uio->uio_resid = 0;
+ if ((flags & FOF_OFFSET) == 0)
+ fp->f_offset +=
+ count - uio->uio_resid;
+ error = 0;
+ goto done;
+ }
+ }
+ error = VOP_READ(vp, uio, ioflag, cred);
+ if ((flags & FOF_OFFSET) == 0)
+ fp->f_offset += count - uio->uio_resid;
+done:
VOP_UNLOCK(vp, 0, p);
return (error);
}
/*
* File table vnode write routine.
*/
-vn_write(fp, uio, cred)
+static int
+vn_write(fp, uio, cred, flags, p)
struct file *fp;
struct uio *uio;
struct ucred *cred;
+ int flags;
+ struct proc *p;
{
- struct vnode *vp = (struct vnode *)fp->f_data;
- struct proc *p = uio->uio_procp;
- int error, ioflag = IO_UNIT;
+ struct vnode *vp;
+ int error, ioflag;
off_t count;
+ if (p != uio->uio_procp)
+ panic("vn_write: uio_procp does not match p");
+
+ vp = (struct vnode *)fp->f_data;
+ ioflag = IO_UNIT;
+ if (vp->v_type == VREG)
+ bwillwrite();
if (vp->v_type == VREG && (fp->f_flag & O_APPEND))
ioflag |= IO_APPEND;
if (fp->f_flag & FNONBLOCK)
(vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS)))
ioflag |= IO_SYNC;
VOP_LEASE(vp, p, cred, LEASE_WRITE);
- (void)vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
- uio->uio_offset = fp->f_offset;
- count = uio->uio_resid;
+ error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ if (error)
+ return (error);
+ if ((flags & FOF_OFFSET) == 0) {
+ uio->uio_offset = fp->f_offset;
+ count = uio->uio_resid;
+ }
+ if(UBCINFOEXISTS(vp)) {
+ memory_object_t pager;
+ struct iovec *iov;
+ off_t file_off;
+ kern_return_t kr = KERN_SUCCESS;
+ kern_return_t ret = KERN_SUCCESS;
+ int count;
+
+ pager = (memory_object_t)ubc_getpager(vp);
+ file_off = uio->uio_offset;
+ iov = uio->uio_iov;
+ count = uio->uio_iovcnt;
+ while(count) {
+ kr = vm_conflict_check(current_map(),
+ (vm_offset_t)iov->iov_base,
+ iov->iov_len, pager, file_off);
+ if(kr == KERN_ALREADY_WAITING) {
+ if((count != uio->uio_iovcnt) &&
+ (ret != KERN_ALREADY_WAITING)) {
+ error = EINVAL;
+ goto done;
+ }
+ ret = KERN_ALREADY_WAITING;
+ } else if (kr != KERN_SUCCESS) {
+ error = EINVAL;
+ goto done;
+ }
+ if(kr != ret) {
+ error = EINVAL;
+ goto done;
+ }
+ file_off += iov->iov_len;
+ iov++;
+ count--;
+ }
+ if(ret == KERN_ALREADY_WAITING) {
+ uio->uio_resid = 0;
+ if ((flags & FOF_OFFSET) == 0)
+ fp->f_offset +=
+ count - uio->uio_resid;
+ error = 0;
+ goto done;
+ }
+ }
error = VOP_WRITE(vp, uio, ioflag, cred);
- if (ioflag & IO_APPEND)
- fp->f_offset = uio->uio_offset;
- else
- fp->f_offset += count - uio->uio_resid;
+ if ((flags & FOF_OFFSET) == 0) {
+ if (ioflag & IO_APPEND)
+ fp->f_offset = uio->uio_offset;
+ else
+ fp->f_offset += count - uio->uio_resid;
+ }
+
/*
* Set the credentials on successful writes
*/
ubc_setcred(vp, p);
}
+done:
VOP_UNLOCK(vp, 0, p);
return (error);
}
/*
* File table vnode stat routine.
*/
+int
vn_stat(vp, sb, p)
struct vnode *vp;
register struct stat *sb;
sb->st_blksize = vap->va_blocksize;
sb->st_flags = vap->va_flags;
/* Do not give the generation number out to unpriviledged users */
- if (suser(p->p_ucred, &p->p_acflag))
+ if (vap->va_gen && suser(p->p_ucred, &p->p_acflag))
sb->st_gen = 0;
else
sb->st_gen = vap->va_gen;
/*
* File table vnode ioctl routine.
*/
+static int
vn_ioctl(fp, com, data, p)
struct file *fp;
u_long com;
struct vattr vattr;
int error;
struct vnode *ttyvp;
-
+
switch (vp->v_type) {
case VREG:
case VFIFO:
case VCHR:
case VBLK:
- error = VOP_IOCTL(vp, com, data, fp->f_flag, p->p_ucred, p);
- if (error == 0 && com == TIOCSCTTY) {
- VREF(vp);
- ttyvp = p->p_session->s_ttyvp;
- p->p_session->s_ttyvp = vp;
- if (ttyvp)
- vrele(ttyvp);
- }
- return (error);
+
+ /* Should not be able to set block size from user space */
+ if(com == DKIOCSETBLOCKSIZE)
+ return (EPERM);
+
+ if (com == FIODTYPE) {
+ if (vp->v_type == VBLK) {
+ if (major(vp->v_rdev) >= nblkdev)
+ return (ENXIO);
+ *(int *)data = bdevsw[major(vp->v_rdev)].d_type;
+ } else if (vp->v_type == VCHR) {
+ if (major(vp->v_rdev) >= nchrdev)
+ return (ENXIO);
+ *(int *)data = cdevsw[major(vp->v_rdev)].d_type;
+ } else {
+ return (ENOTTY);
+ }
+ return (0);
+ }
+ error = VOP_IOCTL(vp, com, data, fp->f_flag, p->p_ucred, p);
+ if (error == 0 && com == TIOCSCTTY) {
+ VREF(vp);
+ ttyvp = p->p_session->s_ttyvp;
+ p->p_session->s_ttyvp = vp;
+ if (ttyvp)
+ vrele(ttyvp);
+ }
+ return (error);
}
}
/*
* File table vnode select routine.
*/
+static int
vn_select(fp, which, wql, p)
struct file *fp;
int which;
/*
* File table vnode close routine.
*/
+static int
vn_closefile(fp, p)
struct file *fp;
struct proc *p;
return (vn_close(((struct vnode *)fp->f_data), fp->f_flag,
fp->f_cred, p));
}
+
+static int
+vn_kqfilt_add(fp, kn, p)
+ struct file *fp;
+ struct knote *kn;
+ struct proc *p;
+{
+ struct vnode *vp = (struct vnode *)fp->f_data;
+ int error;
+
+ error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ if (error) return (error);
+ error = VOP_KQFILT_ADD(vp, kn, p);
+ (void)VOP_UNLOCK(vp, 0, p);
+ return (error);
+}
+
+static int
+vn_kqfilt_remove(vp, ident, p)
+ struct vnode *vp;
+ uintptr_t ident;
+ struct proc *p;
+{
+ int error;
+
+ error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+ if (error) return (error);
+ error = VOP_KQFILT_REMOVE(vp, ident, p);
+ (void)VOP_UNLOCK(vp, 0, p);
+ return (error);
+}
projects / apple / xnu.git / blobdiff