devfd
cgget(int devfd, struct fs *fs, int cg, struct cg *cgp)
if ((cnt = pread(devfd, cgp, fs->fs_cgsize,
cgput(int devfd, struct fs *fs, struct cg *cgp)
if ((cnt = pwrite(devfd, cgp, fs->fs_cgsize,
static int use_pread(void *devfd, off_t loc, void **bufp, int size);
static int use_pwrite(void *devfd, off_t loc, void *buf, int size);
sbget(int devfd, struct fs **fsp, off_t sblockloc, int flags)
error = ffs_sbget(&devfd, fsp, sblockloc, flags, "user", use_pread);
sbsearch(int devfd, struct fs **fsp, int flags)
error = ffs_sbsearch(&devfd, fsp, flags, "user", use_pread);
use_pread(void *devfd, off_t loc, void **bufp, int size)
fd = *(int *)devfd;
sbput(int devfd, struct fs *fs, int numaltwrite)
error = ffs_sbput(&devfd, fs, fs->fs_sblockactualloc, use_pwrite);
if ((error = ffs_sbput(&devfd, fs, fs->fs_sblockactualloc,
use_pwrite(void *devfd, off_t loc, void *buf, int size)
fd = *(int *)devfd;
chkrecovery(int devfd)
if (ioctl(devfd, DIOCGSECTORSIZE, &secsize) == -1 ||
blread(devfd, fsrbuf, (SBLOCK_UFS2 - rdsize) / dev_bsize,
static int chkrecovery(int devfd);
int devfd, n, cg;
if ((devfd = open(device, printonly ? O_RDONLY : O_RDWR)) < 0) {
if ((errno = sbget(devfd, &sblock, UFS_STDSB, UFS_NOCSUM)) != 0) {
if (sbput(devfd, sblock, sblock->fs_ncg) != 0) {
if (lseek(devfd, (off_t)dblk * bsize, SEEK_SET) < 0) {
} else if ((n = read(devfd, inodebuf, ibufsize)) != ibufsize) {
if (lseek(devfd, (off_t)dblk * bsize, SEEK_SET) < 0) {
} else if ((n = write(devfd, inodebuf, ibufsize)) !=
(void)close(devfd);
int c, lock = -1, devfd = -1, err = 0, rw = -1, ns = -1, set = 0;
devfd = opendevice(NULL);
devfd = opendevice(IPSTATE_NAME);
devfd = opendevice(IPNAT_NAME);
if (devfd == -1)
err = setlock(devfd, lock);
err = writenat(devfd, filename);
err = writestate(devfd, filename);
err = readnat(devfd, filename);
err = readstate(devfd, filename);
int fd, devfd;
devfd = opendevice(IPSTATE_NAME);
if (devfd == -1)
if (writestate(devfd, NULL))
close(devfd);
devfd = opendevice(IPNAT_NAME);
if (devfd == -1)
if (writenat(devfd, NULL))
close(devfd);
int fd, devfd;
devfd = opendevice(IPSTATE_NAME);
if (devfd == -1)
if (readstate(devfd, NULL))
close(devfd);
devfd = opendevice(IPNAT_NAME);
if (devfd == -1)
if (readnat(devfd, NULL))
close(devfd);
int ffs_sbget(void *devfd, struct fs **fsp, off_t sblock, int flags,
int (*readfunc)(void *devfd, off_t loc, void **bufp, int size));
ufs_use_sa_read(void *devfd, off_t loc, void **bufp, int size)
f = (struct open_file *)devfd;
g_use_g_read_data(void *devfd, off_t loc, void **bufp, int size)
cp = (struct g_consumer *)devfd;
g_use_g_write_data(void *devfd, off_t loc, void *buf, int size)
return (g_write_data((struct g_consumer *)devfd, loc, buf, size));
error = (*writefunc)(devfd, loc, fs, fs->fs_sbsize);
ffs_sbget(void *devfd, struct fs **fsp, off_t sblock, int flags,
int (*readfunc)(void *devfd, off_t loc, void **bufp, int size))
if ((error = readsuper(devfd, &fs, sblock,
if ((error = readsuper(devfd, &fs, sblock_try[i],
error = (*readfunc)(devfd,
readsuper(void *devfd, struct fs **fsp, off_t sblockloc, int flags,
int (*readfunc)(void *devfd, off_t loc, void **bufp, int size))
error = (*readfunc)(devfd, sblockloc, (void **)fsp, SBLOCKSIZE);
ffs_sbsearch(void *devfd, struct fs **fsp, int reqflags,
int (*readfunc)(void *devfd, off_t loc, void **bufp, int size))
error = ffs_sbget(devfd, fsp, UFS_STDSB, flags, filltype, readfunc);
if (ffs_sbget(devfd, fsp, UFS_STDSB, flags, filltype, readfunc) == 0)
if (ffs_sbget(devfd, &protofs, UFS_STDSB, flags, filltype,
if ((error = (*readfunc)(devfd, (SBLOCK_UFS2 - secsize),
if (ffs_sbget(devfd, fsp, dbtob(sblk), flags, filltype,
if (ffs_sbget(devfd, fsp, UFS_STDSB, flags, filltype, readfunc) != 0) {
ffs_sbput(void *devfd, struct fs *fs, off_t loc,
int (*writefunc)(void *devfd, off_t loc, void *buf, int size))
if ((error = (*writefunc)(devfd,
ffs_use_bread(void *devfd, off_t loc, void **bufp, int size)
if ((error = bread((struct vnode *)devfd, btodb(loc), size, NOCRED,
struct devfd devfd;
devfd.ump = ump;
devfd.sbbp = sbbp;
devfd.waitfor = waitfor;
devfd.suspended = suspended;
devfd.error = 0;
return (ffs_sbput(&devfd, fs, fs->fs_sblockloc, ffs_use_bwrite));
ffs_use_bwrite(void *devfd, off_t loc, void *buf, int size)
struct devfd *devfdp;
devfdp = devfd;
static int ffs_use_bread(void *devfd, off_t loc, void **bufp, int size);
static int ffs_use_bwrite(void *devfd, off_t loc, void *buf, int size);
if (term_chk(devfd, mytty, &msgsok, &atime, 1))
search_utmp(devfd, argv[0], tty, mytty, myuid);
do_write(devfd, tty, mytty, login);
if (term_chk(devfd, argv[1], &msgsok, &atime, 1))
do_write(devfd, argv[1], mytty, login);
search_utmp(int devfd, char *user, char *tty, char *mytty, uid_t myuid)
if (term_chk(devfd, u->ut_line, &msgsok, &atime, 0))
term_chk(int devfd, char *tty, int *msgsokP, time_t *atimeP, int showerror)
if (fstatat(devfd, tty, &s, 0) < 0) {
do_write(int devfd, char *tty, char *mytty, const char *login)
fd = openat(devfd, tty, O_WRONLY);
int devfd;
devfd = open(_PATH_DEV, O_RDONLY);
if (devfd < 0)
if (caph_rights_limit(devfd, &rights) < 0)
error = ioctl(devfd, CPUCTL_UPDATE, &args);
int devfd;
devfd = params->devfd;
error = ioctl(devfd, CPUCTL_CPUID, &idargs);
devfd = params->devfd;
error = ioctl(devfd, CPUCTL_CPUID, &idargs);
error = ioctl(devfd, CPUCTL_RDMSR, &msrargs);
error = ioctl(devfd, CPUCTL_UPDATE, &args);
error = ioctl(devfd, CPUCTL_RDMSR, &msrargs);
int devfd;
try_a_fw_image(const char *dev_path, int devfd, int fwdfd, const char *dpath,
parm.devfd = devfd;
int devfd; /* RDWR handle to cpucontrol device */
devfd = params->devfd;
error = ioctl(devfd, CPUCTL_WRMSR, &msrargs);
error = ioctl(devfd, CPUCTL_CPUID, &idargs);
error = ioctl(devfd, CPUCTL_RDMSR, &msrargs);
error = ioctl(devfd, CPUCTL_RDMSR, &msrargs);
error = ioctl(devfd, CPUCTL_UPDATE, &args);
int devfd;
devfd = params->devfd;
error = ioctl(devfd, CPUCTL_CPUID, &idargs);
error = ioctl(devfd, CPUCTL_RDMSR, &msrargs);
error = ioctl(devfd, CPUCTL_RDMSR, &msrargs);
error = ioctl(devfd, CPUCTL_UPDATE, &args);
int devfd;
devfd = open(_PATH_DEV _PATH_NFSLCKDEV, O_RDWR | O_NONBLOCK);
if (devfd < 0) {
if ((nr = read(devfd, &msg, sizeof(msg))) == sizeof(msg)) {
static int devfd;
return (write(devfd, ansp, sizeof *ansp) <= 0);