* Copyright (c) 1989, 1993
* The Regents of the University of California. All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* @(#)spec_vnops.c 8.6 (Berkeley) 4/9/94
#include <sys/disklabel.h>
#include <miscfs/specfs/specdev.h>
/* symbolic sleep message strings for devices */
char devopn
[] = "devopn";
char devwait
[] = "devwait";
char devout
[] = "devout";
char devioc
[] = "devioc";
char devcls
[] = "devcls";
int (**spec_vnodeop_p
)();
struct vnodeopv_entry_desc spec_vnodeop_entries
[] = {
{ &vop_default_desc
, vn_default_error
},
{ &vop_lookup_desc
, spec_lookup
}, /* lookup */
{ &vop_create_desc
, spec_create
}, /* create */
{ &vop_mknod_desc
, spec_mknod
}, /* mknod */
{ &vop_open_desc
, spec_open
}, /* open */
{ &vop_close_desc
, spec_close
}, /* close */
{ &vop_access_desc
, spec_access
}, /* access */
{ &vop_getattr_desc
, spec_getattr
}, /* getattr */
{ &vop_setattr_desc
, spec_setattr
}, /* setattr */
{ &vop_read_desc
, spec_read
}, /* read */
{ &vop_write_desc
, spec_write
}, /* write */
{ &vop_ioctl_desc
, spec_ioctl
}, /* ioctl */
{ &vop_select_desc
, spec_select
}, /* select */
{ &vop_mmap_desc
, spec_mmap
}, /* mmap */
{ &vop_fsync_desc
, spec_fsync
}, /* fsync */
{ &vop_seek_desc
, spec_seek
}, /* seek */
{ &vop_remove_desc
, spec_remove
}, /* remove */
{ &vop_link_desc
, spec_link
}, /* link */
{ &vop_rename_desc
, spec_rename
}, /* rename */
{ &vop_mkdir_desc
, spec_mkdir
}, /* mkdir */
{ &vop_rmdir_desc
, spec_rmdir
}, /* rmdir */
{ &vop_symlink_desc
, spec_symlink
}, /* symlink */
{ &vop_readdir_desc
, spec_readdir
}, /* readdir */
{ &vop_readlink_desc
, spec_readlink
}, /* readlink */
{ &vop_abortop_desc
, spec_abortop
}, /* abortop */
{ &vop_inactive_desc
, spec_inactive
}, /* inactive */
{ &vop_reclaim_desc
, spec_reclaim
}, /* reclaim */
{ &vop_lock_desc
, spec_lock
}, /* lock */
{ &vop_unlock_desc
, spec_unlock
}, /* unlock */
{ &vop_bmap_desc
, spec_bmap
}, /* bmap */
{ &vop_strategy_desc
, spec_strategy
}, /* strategy */
{ &vop_print_desc
, spec_print
}, /* print */
{ &vop_islocked_desc
, spec_islocked
}, /* islocked */
{ &vop_pathconf_desc
, spec_pathconf
}, /* pathconf */
{ &vop_advlock_desc
, spec_advlock
}, /* advlock */
{ &vop_blkatoff_desc
, spec_blkatoff
}, /* blkatoff */
{ &vop_valloc_desc
, spec_valloc
}, /* valloc */
{ &vop_vfree_desc
, spec_vfree
}, /* vfree */
{ &vop_truncate_desc
, spec_truncate
}, /* truncate */
{ &vop_update_desc
, spec_update
}, /* update */
{ &vop_bwrite_desc
, spec_bwrite
}, /* bwrite */
{ (struct vnodeop_desc
*)NULL
, (int(*)())NULL
}
struct vnodeopv_desc spec_vnodeop_opv_desc
=
{ &spec_vnodeop_p
, spec_vnodeop_entries
};
* Trivial lookup routine that always fails.
struct vop_lookup_args
/* {
struct componentname *a_cnp;
struct vop_open_args
/* {
struct vnode
*bvp
, *vp
= ap
->a_vp
;
dev_t bdev
, dev
= (dev_t
)vp
->v_rdev
;
register int maj
= major(dev
);
* Don't allow open if fs is mounted -nodev.
if (vp
->v_mount
&& (vp
->v_mount
->mnt_flag
& MNT_NODEV
))
if ((u_int
)maj
>= nchrdev
)
if (ap
->a_cred
!= FSCRED
&& (ap
->a_mode
& FWRITE
)) {
* When running in very secure mode, do not allow
* opens for writing of any disk character devices.
if (securelevel
>= 2 && isdisk(dev
, VCHR
))
* When running in secure mode, do not allow opens
* for writing of /dev/mem, /dev/kmem, or character
* devices whose corresponding block devices are
if ((bdev
= chrtoblk(dev
)) != NODEV
&&
vfinddev(bdev
, VBLK
, &bvp
) &&
(error
= vfs_mountedon(bvp
)))
error
= (*cdevsw
[maj
].d_open
)(dev
, ap
->a_mode
, S_IFCHR
, ap
->a_p
);
if ((u_int
)maj
>= nblkdev
)
* When running in very secure mode, do not allow
* opens for writing of any disk block devices.
if (securelevel
>= 2 && ap
->a_cred
!= FSCRED
&&
(ap
->a_mode
& FWRITE
) && isdisk(dev
, VBLK
))
* Do not allow opens of block devices that are
if (error
= vfs_mountedon(vp
))
return ((*bdevsw
[maj
].d_open
)(dev
, ap
->a_mode
, S_IFBLK
, ap
->a_p
));
struct vop_read_args
/* {
register struct vnode
*vp
= ap
->a_vp
;
register struct uio
*uio
= ap
->a_uio
;
struct proc
*p
= uio
->uio_procp
;
int n
, on
, majordev
, (*ioctl
)();
if (uio
->uio_rw
!= UIO_READ
)
if (uio
->uio_segflg
== UIO_USERSPACE
&& uio
->uio_procp
!= curproc
)
error
= (*cdevsw
[major(vp
->v_rdev
)].d_read
)
(vp
->v_rdev
, uio
, ap
->a_ioflag
);
if ((majordev
= major(dev
)) < nblkdev
&&
(ioctl
= bdevsw
[majordev
].d_ioctl
) != NULL
&&
(*ioctl
)(dev
, DIOCGPART
, (caddr_t
)&dpart
, FREAD
, p
) == 0 &&
dpart
.part
->p_fstype
== FS_BSDFFS
&&
dpart
.part
->p_frag
!= 0 && dpart
.part
->p_fsize
!= 0)
bsize
= dpart
.part
->p_frag
* dpart
.part
->p_fsize
;
bscale
= bsize
/ DEV_BSIZE
;
bn
= (uio
->uio_offset
/ DEV_BSIZE
) &~ (bscale
- 1);
on
= uio
->uio_offset
% bsize
;
n
= min((unsigned)(bsize
- on
), uio
->uio_resid
);
if (vp
->v_lastr
+ bscale
== bn
) {
error
= breadn(vp
, bn
, (int)bsize
, &nextbn
,
(int *)&bsize
, 1, NOCRED
, &bp
);
error
= bread(vp
, bn
, (int)bsize
, NOCRED
, &bp
);
n
= min(n
, bsize
- bp
->b_resid
);
error
= uiomove((char *)bp
->b_data
+ on
, n
, uio
);
} while (error
== 0 && uio
->uio_resid
> 0 && n
!= 0);
struct vop_write_args
/* {
register struct vnode
*vp
= ap
->a_vp
;
register struct uio
*uio
= ap
->a_uio
;
struct proc
*p
= uio
->uio_procp
;
if (uio
->uio_rw
!= UIO_WRITE
)
panic("spec_write mode");
if (uio
->uio_segflg
== UIO_USERSPACE
&& uio
->uio_procp
!= curproc
)
panic("spec_write proc");
error
= (*cdevsw
[major(vp
->v_rdev
)].d_write
)
(vp
->v_rdev
, uio
, ap
->a_ioflag
);
if ((*bdevsw
[major(vp
->v_rdev
)].d_ioctl
)(vp
->v_rdev
, DIOCGPART
,
(caddr_t
)&dpart
, FREAD
, p
) == 0) {
if (dpart
.part
->p_fstype
== FS_BSDFFS
&&
dpart
.part
->p_frag
!= 0 && dpart
.part
->p_fsize
!= 0)
bsize
= dpart
.part
->p_frag
*
blkmask
= (bsize
/ DEV_BSIZE
) - 1;
bn
= (uio
->uio_offset
/ DEV_BSIZE
) &~ blkmask
;
on
= uio
->uio_offset
% bsize
;
n
= min((unsigned)(bsize
- on
), uio
->uio_resid
);
bp
= getblk(vp
, bn
, bsize
, 0, 0);
error
= bread(vp
, bn
, bsize
, NOCRED
, &bp
);
n
= min(n
, bsize
- bp
->b_resid
);
error
= uiomove((char *)bp
->b_data
+ on
, n
, uio
);
} while (error
== 0 && uio
->uio_resid
> 0 && n
!= 0);
panic("spec_write type");
* Device ioctl operation.
struct vop_ioctl_args
/* {
dev_t dev
= ap
->a_vp
->v_rdev
;
switch (ap
->a_vp
->v_type
) {
return ((*cdevsw
[major(dev
)].d_ioctl
)(dev
, ap
->a_command
, ap
->a_data
,
if (ap
->a_command
== 0 && (int)ap
->a_data
== B_TAPE
)
if (bdevsw
[major(dev
)].d_flags
& B_TAPE
)
return ((*bdevsw
[major(dev
)].d_ioctl
)(dev
, ap
->a_command
, ap
->a_data
,
struct vop_select_args
/* {
switch (ap
->a_vp
->v_type
) {
return (*cdevsw
[major(dev
)].d_select
)(dev
, ap
->a_which
, ap
->a_p
);
* Synch buffers associated with a block device
struct vop_fsync_args
/* {
register struct vnode
*vp
= ap
->a_vp
;
* Flush all dirty buffers associated with a block device.
for (bp
= vp
->v_dirtyblkhd
.lh_first
; bp
; bp
= nbp
) {
nbp
= bp
->b_vnbufs
.le_next
;
if ((bp
->b_flags
& B_BUSY
))
if ((bp
->b_flags
& B_DELWRI
) == 0)
panic("spec_fsync: not dirty");
if (ap
->a_waitfor
== MNT_WAIT
) {
while (vp
->v_numoutput
) {
sleep((caddr_t
)&vp
->v_numoutput
, PRIBIO
+ 1);
if (vp
->v_dirtyblkhd
.lh_first
) {
vprint("spec_fsync: dirty", vp
);
* Just call the device strategy routine
struct vop_strategy_args
/* {
(*bdevsw
[major(ap
->a_bp
->b_dev
)].d_strategy
)(ap
->a_bp
);
* This is a noop, simply returning what one has been given.
struct vop_bmap_args
/* {
* At the moment we do not do any locking.
struct vop_lock_args
/* {
struct vop_unlock_args
/* {
struct vop_close_args
/* {
register struct vnode
*vp
= ap
->a_vp
;
int (*devclose
) __P((dev_t
, int, int, struct proc
*));
* Hack: a tty device that is a controlling terminal
* has a reference from the session structure.
* We cannot easily tell that a character device is
* a controlling terminal, unless it is the closing
* process' controlling terminal. In that case,
* if the reference count is 2 (this last descriptor
* plus the session), release the reference from the session.
if (vcount(vp
) == 2 && ap
->a_p
&&
vp
== ap
->a_p
->p_session
->s_ttyvp
) {
ap
->a_p
->p_session
->s_ttyvp
= NULL
;
* If the vnode is locked, then we are in the midst
* of forcably closing the device, otherwise we only
* close on last reference.
if (vcount(vp
) > 1 && (vp
->v_flag
& VXLOCK
) == 0)
devclose
= cdevsw
[major(dev
)].d_close
;
* On last close of a block device (that isn't mounted)
* we must invalidate any in core blocks, so that
* we can, for instance, change floppy disks.
if (error
= vinvalbuf(vp
, V_SAVE
, ap
->a_cred
, ap
->a_p
, 0, 0))
* We do not want to really close the device if it
* is still in use unless we are trying to close it
* forcibly. Since every use (buffer, vnode, swap, cmap)
* holds a reference to the vnode, and because we mark
* any other vnodes that alias this device, when the
* sum of the reference counts on all the aliased
* vnodes descends to one, we are on last close.
if (vcount(vp
) > 1 && (vp
->v_flag
& VXLOCK
) == 0)
devclose
= bdevsw
[major(dev
)].d_close
;
panic("spec_close: not special");
return ((*devclose
)(dev
, ap
->a_fflag
, mode
, ap
->a_p
));
* Print out the contents of a special device vnode.
struct vop_print_args
/* {
printf("tag VT_NON, dev %d, %d\n", major(ap
->a_vp
->v_rdev
),
minor(ap
->a_vp
->v_rdev
));
* Return POSIX pathconf information applicable to special devices.
struct vop_pathconf_args
/* {
*ap
->a_retval
= LINK_MAX
;
*ap
->a_retval
= MAX_CANON
;
*ap
->a_retval
= MAX_INPUT
;
*ap
->a_retval
= PIPE_BUF
;
case _PC_CHOWN_RESTRICTED
:
*ap
->a_retval
= _POSIX_VDISABLE
;
* Special device advisory byte-level locks.
struct vop_advlock_args
/* {
* Special device failed operation
* Special device bad operation
panic("spec_badop called");