/*
* ptsname(): return the pathname of the slave pseudo-terminal device
* associated with the specified master.
*/
char*
ptsname(int fildes) {
static char slave[] = _PATH_DEV PTS_PREFIX "XY";
static char new_slave[] = _PATH_DEV NEWPTS_PREFIX "4294967295";
char* retval;
struct stat sbuf;
retval = NULL;
if (_fstat(fildes, &sbuf) == 0) {
if (!ISPTM(sbuf)) {
errno = EINVAL;
} else {
if (!is_pts(fildes)) {
(void)snprintf(slave, sizeof(slave),
_PATH_DEV PTS_PREFIX "%s",
devname(sbuf.st_rdev, S_IFCHR) +
strlen(PTM_PREFIX));
retval = slave;
} else {
(void)snprintf(new_slave, sizeof(new_slave),
_PATH_DEV NEWPTS_PREFIX "%s",
devname(sbuf.st_rdev, S_IFCHR) +
strlen(PTM_PREFIX));
retval = new_slave;
}
}
}
return (retval);
}
static int pipetapfd(struct chan *chan, struct fd_tap *tap, int cmd)
{
int ret;
Pipe *p;
int which = 1;
uint64_t kludge;
p = chan->aux;
kludge = (uint64_t)p;
#define DEVPIPE_LEGAL_DATA_TAPS (FDTAP_FILT_READABLE | FDTAP_FILT_WRITABLE | \
FDTAP_FILT_HANGUP | FDTAP_FILT_ERROR)
switch (NETTYPE(chan->qid.path)) {
case Qdata0:
which = 0;
/* fall through */
case Qdata1:
kludge |= which;
if (tap->filter & ~DEVPIPE_LEGAL_DATA_TAPS) {
set_errno(ENOSYS);
set_errstr("Unsupported #%s data tap %p, must be %p", devname(),
tap->filter, DEVPIPE_LEGAL_DATA_TAPS);
return -1;
}
spin_lock(&p->tap_lock);
switch (cmd) {
case (FDTAP_CMD_ADD):
if (SLIST_EMPTY(&p->data_taps[which]))
qio_set_wake_cb(p->q[which], pipe_wake_cb, (void *)kludge);
SLIST_INSERT_HEAD(&p->data_taps[which], tap, link);
ret = 0;
break;
case (FDTAP_CMD_REM):
SLIST_REMOVE(&p->data_taps[which], tap, fd_tap, link);
if (SLIST_EMPTY(&p->data_taps[which]))
qio_set_wake_cb(p->q[which], 0, (void *)kludge);
ret = 0;
break;
default:
set_errno(ENOSYS);
set_errstr("Unsupported #%s data tap command %p", devname(), cmd);
ret = -1;
}
spin_unlock(&p->tap_lock);
return ret;
default:
set_errno(ENOSYS);
set_errstr("Can't tap #%s file type %d", devname(),
NETTYPE(chan->qid.path));
return -1;
}
}
static int open_tun_any(char *dev_name, size_t dev_name_size)
{
int fd;
struct stat buf;
/* Open lowest unused tun device */
if ((fd = open("/dev/tun", O_RDWR)) != -1) {
fstat(fd, &buf);
printf("Using %s\n", devname(buf.st_rdev, S_IFCHR));
if (dev_name != NULL)
strlcpy(dev_name, devname(buf.st_rdev, S_IFCHR), dev_name_size);
return fd;
}
return -1;
}
static int
pipegen(struct chan *c, char *unused,
struct dirtab *tab, int ntab, int i, struct dir *dp)
{
int id, len;
struct qid qid;
Pipe *p;
if (i == DEVDOTDOT) {
devdir(c, c->qid, devname(), 0, eve, 0555, dp);
return 1;
}
i++; /* skip . */
if (tab == 0 || i >= ntab)
return -1;
tab += i;
p = c->aux;
switch (NETTYPE(tab->qid.path)) {
case Qdata0:
len = qlen(p->q[0]);
break;
case Qdata1:
len = qlen(p->q[1]);
break;
default:
len = tab->length;
break;
}
id = NETID(c->qid.path);
qid.path = NETQID(id, tab->qid.path);
qid.vers = 0;
qid.type = QTFILE;
devdir(c, qid, tab->name, len, eve, tab->perm, dp);
return 1;
}
static int CCONV AttachHandler (CPhidgetHandle device, void *userptr) {
int serialNumber;
const char *name;
LocalErrorCatcher(
CPhidget_getDeviceName(device, &name));
LocalErrorCatcher(
CPhidget_getSerialNumber(device, &serialNumber));
PhidgetsDeviceManager* obj = (PhidgetsDeviceManager*)userptr;
QString devname(name);
// If the device name contains motor control in its name then emit a motor control card signal
if(devname.contains("Motor Control"))
{
obj->pushToMotorControlCardSerials(serialNumber);
// emit obj->motorCard(serialNumber);
}
else if(devname.contains("InterfaceKit"))
{
obj->setInterfaceKitSerial(serialNumber);
}
printf("Hello Device %s, Serial Number: %d\n", name, serialNumber);
return 0;
}
int tap_open(char *ifname, int ifname_size, int *vnet_hdr, int vnet_hdr_required)
{
int fd;
char *dev;
struct stat s;
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
/* if no ifname is given, always start the search from tap0. */
int i;
char dname[100];
for (i = 0; i < 10; i++) {
if (*ifname) {
snprintf(dname, sizeof dname, "/dev/%s", ifname);
} else {
snprintf(dname, sizeof dname, "/dev/tap%d", i);
}
TFR(fd = open(dname, O_RDWR));
if (fd >= 0) {
break;
}
else if (errno == ENXIO || errno == ENOENT) {
break;
}
if (*ifname) {
break;
}
}
if (fd < 0) {
error_report("warning: could not open %s (%s): no virtual network emulation",
dname, strerror(errno));
return -1;
}
#else
TFR(fd = open("/dev/tap", O_RDWR));
if (fd < 0) {
fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
return -1;
}
#endif
fstat(fd, &s);
dev = devname(s.st_rdev, S_IFCHR);
pstrcpy(ifname, ifname_size, dev);
if (*vnet_hdr) {
/* BSD doesn't have IFF_VNET_HDR */
*vnet_hdr = 0;
if (vnet_hdr_required && !*vnet_hdr) {
error_report("vnet_hdr=1 requested, but no kernel "
"support for IFF_VNET_HDR available");
close(fd);
return -1;
}
}
fcntl(fd, F_SETFL, O_NONBLOCK);
return fd;
}
/* return 1 if it works, or 0 for failure */
static gboolean
stat2proc (pid_t pid,
CkProcessStat *P)
{
struct kinfo_proc2 p;
char *ttname;
int num;
int tty_maj;
int tty_min;
if (! get_kinfo_proc (pid, &p)) {
return FALSE;
}
num = KI_MAXCOMLEN;
if (num >= sizeof(P->cmd)) {
num = sizeof(P->cmd) - 1;
}
memcpy (P->cmd, p.p_comm, num);
P->cmd[num] = '\0';
P->pid = p.p_pid;
P->ppid = p.p_ppid;
P->pgrp = p.p__pgid;
P->session = p.p_sid;
P->rss = p.p_vm_rssize;
P->vsize = p.p_vm_dsize + p.p_vm_dsize + p.p_vm_ssize; /* XXX */
P->start_time = p.p_ustart_sec;
P->wchan = (unsigned long) p.p_wchan;
P->state = p.p_stat;
P->nice = p.p_nice;
P->flags = p.p_realflag;
P->tpgid = p.p_tpgid;
P->processor = p.p_cpuid;
P->nlwp = p.p_nlwps;
/* we like it Linux-encoded :-) */
tty_maj = major (p.p_tdev);
tty_min = minor (p.p_tdev);
P->tty = DEV_ENCODE (tty_maj,tty_min);
snprintf (P->tty_text, sizeof(P->tty_text), "%3d,%-3d", tty_maj, tty_min);
if (p.p_tdev != NODEV && (ttname = devname (p.p_tdev, S_IFCHR)) != NULL) {
memcpy (P->tty_text, ttname, sizeof(P->tty_text));
}
if (p.p_tdev == NODEV) {
/* XXXJDM nasty hack */
memcpy (P->tty_text, "/dev/ttyE4", sizeof(P->tty_text));
}
if (P->pid != pid) {
return FALSE;
}
return TRUE;
}
static struct chan *rootattach(char *spec)
{
struct chan *c;
if (*spec)
error(EINVAL, ERROR_FIXME);
c = devattach(devname(), spec);
mkqid(&c->qid, roottab[0].qid.path, roottab[0].qid.vers, QTDIR);
return c;
}
/* Get the name of the tun device using file descriptor */
void TunName(int tunfd, char *name) {
struct stat sbuf;
char *internal_buffer;
if (fstat(tunfd,&sbuf) != -1) {
internal_buffer = devname(sbuf.st_rdev, S_IFCHR);
strcpy(name,internal_buffer);
}
}
static struct chan*
kprofattach(char *spec)
{
// Did we initialise completely?
if ( !(oprof_alarms && kprof.buf && kprof.systrace) )
error(ENOMEM, NULL);
return devattach(devname(), spec);
}
int SYSTEM_SWAP_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
/*
* FreeBSD 7.0 i386
*/
#ifdef XSWDEV_VERSION /* defined in <vm/vm_param.h> */
char *swapdev, *mode;
int mib[16], *mib_dev;
size_t sz, mib_sz;
struct xswdev xsw;
zbx_uint64_t total = 0, used = 0;
if (2 < request->nparam)
return SYSINFO_RET_FAIL;
swapdev = get_rparam(request, 0);
mode = get_rparam(request, 1);
sz = ARRSIZE(mib);
if (-1 == sysctlnametomib("vm.swap_info", mib, &sz))
return FAIL;
mib_sz = sz + 1;
mib_dev = &(mib[sz]);
*mib_dev = 0;
sz = sizeof(xsw);
while (-1 != sysctl(mib, mib_sz, &xsw, &sz, NULL, 0))
{
if (NULL == swapdev || '\0' == *swapdev || 0 == strcmp(swapdev, "all") /* default parameter */
|| 0 == strcmp(swapdev, devname(xsw.xsw_dev, S_IFCHR)))
{
total += (zbx_uint64_t)xsw.xsw_nblks;
used += (zbx_uint64_t)xsw.xsw_used;
}
(*mib_dev)++;
}
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "free")) /* default parameter */
SET_UI64_RESULT(result, (total - used) * getpagesize());
else if (0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, total * getpagesize());
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, used * getpagesize());
else if (0 == strcmp(mode, "pfree"))
SET_DBL_RESULT(result, total ? ((double)(total - used) * 100.0 / (double)total) : 0.0);
else if (0 == strcmp(mode, "pused"))
SET_DBL_RESULT(result, total ? ((double)used * 100.0 / (double)total) : 0.0);
else
return SYSINFO_RET_FAIL;
return SYSINFO_RET_OK;
#else
return SYSINFO_RET_FAIL;
#endif
}
int dm_format_dev(char *buf, int bufsize, uint32_t dev_major,
uint32_t dev_minor)
{
int r;
uint32_t major, dm_major;
char *name;
mode_t mode;
dev_t dev;
size_t val_len,i;
struct kinfo_drivers *kd;
mode = 0;
nbsd_get_dm_major(&dm_major, DM_BLOCK_MAJOR);
if (bufsize < 8)
return 0;
if (sysctlbyname("kern.drivers",NULL,&val_len,NULL,0) < 0) {
printf("sysctlbyname failed");
return 0;
}
if ((kd = malloc (val_len)) == NULL){
printf("malloc kd info error\n");
return 0;
}
if (sysctlbyname("kern.drivers", kd, &val_len, NULL, 0) < 0) {
printf("sysctlbyname failed kd");
return 0;
}
for (i = 0, val_len /= sizeof(*kd); i < val_len; i++){
if (kd[i].d_cmajor == dev_major) {
major = kd[i].d_bmajor;
break;
}
}
dev = MKDEV(major,dev_minor);
mode |= S_IFBLK;
if ((name = devname(dev,mode)) == NULL)
name = get_dev_name(kd[i].d_name, major, dev_minor);
r = snprintf(buf, (size_t) bufsize, "/dev/%s",name);
free(kd);
if (r < 0 || r > bufsize - 1 || name == NULL)
return 0;
return 1;
}
static struct chan*
regressattach(char *spec)
{
uint32_t n;
regress.monitor = qopen(2 << 20, 0, 0, 0);
if (! regress.monitor) {
printk("monitor allocate failed. No monitor output\n");
}
return devattach(devname(), spec);
}
const char *
udev_device_get_devnode(struct udev_device *udev_device)
{
dev_t devnum;
devnum = udev_device_get_devnum(udev_device);
if (devnum == 0)
return 0;
return devname(devnum, S_IFCHR);
}
// --------------------------------------------------------------------------
// TunName: Get the name of the tun device using file descriptor.
//
void TunName(int tunfd, char *name, size_t name_len )
{
struct stat sbuf;
char *unsafe_buffer;
if( fstat( tunfd, &sbuf ) != -1 )
{
unsafe_buffer = devname(sbuf.st_rdev, S_IFCHR);
strncpy( name, unsafe_buffer, name_len );
}
}
int main()
{
int rssi;
char name[248];
if ( 0 == devname( BLUETOOTH_DEVICE, name, 248 ) ) {
printf( "Unit = %s Devicename = %s\n", BLUETOOTH_DEVICE, name );
}
read_rssi( BLUETOOTH_DEVICE, &rssi );
printf( "Unit = %s RSSI = %d\n", BLUETOOTH_DEVICE, rssi );
return 0;
}
const char *
getdev(dev_t dev)
{
static dev_t lastdev = (dev_t)-1;
static const char *lastname;
if (dev == NODEV) /* Special case. */
return ("__");
if (dev == lastdev) /* One-element cache. */
return (lastname);
lastdev = dev;
lastname = devname(dev, S_IFCHR);
return (lastname);
}
void
longtname(const struct kinfo_proc *kp, VARENT *ve)
{
VAR *v;
dev_t dev;
char *ttname;
v = ve->var;
dev = kp->p_tdev;
if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
(void)printf("%-*s", v->width, "??");
else
(void)printf("%-*s", v->width, ttname);
}
int
nfs_print(struct vnode *vp)
{
struct nfsnode nfsnode, *np = &nfsnode;
char flagbuf[16], *flags = flagbuf;
int flag;
char *name;
mode_t type;
KGETRET(VTONFS(vp), &nfsnode, sizeof(nfsnode), "vnode's nfsnode");
flag = np->n_flag;
if (flag & NFLUSHWANT)
*flags++ = 'W';
if (flag & NFLUSHINPROG)
*flags++ = 'P';
if (flag & NLMODIFIED)
*flags++ = 'M';
if (flag & NRMODIFIED)
*flags++ = 'R';
if (flag & NWRITEERR)
*flags++ = 'E';
if (flag & NQNFSEVICTED)
*flags++ = 'G';
if (flag & NACC)
*flags++ = 'A';
if (flag & NUPD)
*flags++ = 'U';
if (flag & NCHG)
*flags++ = 'C';
if (flag & NLOCKED)
*flags++ = 'L';
if (flag & NWANTED)
*flags++ = 'w';
if (flag == 0)
*flags++ = '-';
*flags = '\0';
#define VT np->n_vattr
printf(" %6ju %5s", (uintmax_t)VT.va_fileid, flagbuf);
type = VT.va_mode & S_IFMT;
if (S_ISCHR(VT.va_mode) || S_ISBLK(VT.va_mode))
if (usenumflag || ((name = devname((VT.va_rmajor << 8) | VT.va_rminor, type)) == NULL))
printf(" %2d,%-2d",
VT.va_rmajor, VT.va_rminor);
else
printf(" %7s", name);
else
printf(" %7ju", (uintmax_t)np->n_size);
return (0);
}
static void
show(int v, int n)
{
struct vnd_user vnu;
char *dev;
struct statvfs *mnt;
int i, nmount;
vnu.vnu_unit = n;
if (ioctl(v, VNDIOCGET, &vnu) == -1)
err(1, "VNDIOCGET");
if (vnu.vnu_ino == 0) {
printf("vnd%d: not in use\n", vnu.vnu_unit);
return;
}
printf("vnd%d: ", vnu.vnu_unit);
dev = devname(vnu.vnu_dev, S_IFBLK);
if (dev != NULL)
nmount = getmntinfo(&mnt, MNT_NOWAIT);
else {
mnt = NULL;
nmount = 0;
}
if (mnt != NULL) {
for (i = 0; i < nmount; i++) {
if (strncmp(mnt[i].f_mntfromname, "/dev/", 5) == 0 &&
strcmp(mnt[i].f_mntfromname + 5, dev) == 0)
break;
}
if (i < nmount)
printf("%s (%s) ", mnt[i].f_mntonname,
mnt[i].f_mntfromname);
else
printf("%s ", dev);
}
else if (dev != NULL)
printf("%s ", dev);
else
printf("dev %llu,%llu ",
(unsigned long long)major(vnu.vnu_dev),
(unsigned long long)minor(vnu.vnu_dev));
printf("inode %llu\n", (unsigned long long)vnu.vnu_ino);
}
void BusAssignmentManager::State::listAttachedPCIDevices(std::vector<ComPtr<IPCIDeviceAttachment> > &aAttached)
{
aAttached.resize(mPCIMap.size());
size_t i = 0;
ComObjPtr<PCIDeviceAttachment> dev;
for (PCIMap::const_iterator it = mPCIMap.begin(); it != mPCIMap.end(); ++it, ++i)
{
dev.createObject();
com::Bstr devname(it->second.szDevName);
dev->init(NULL, devname,
it->second.HostAddress.valid() ? it->second.HostAddress.asLong() : -1,
it->first.asLong(), it->second.HostAddress.valid());
dev.queryInterfaceTo(aAttached[i].asOutParam());
}
}
void
ttyprt(struct tty *tp, int line)
{
int i, j;
pid_t pgid;
char *name, state[20];
dev_t dev;
dev = (uintptr_t)tp->t_dev & 0xffff; /* XXX t_dev is really dev_t */
if (usenumflag || dev == 0 || (name = devname(dev, S_IFCHR)) == NULL)
printf("%7d ", line);
else
printf("%7s ", name);
printf("%2d %3d ", tp->t_rawq.c_cc, tp->t_canq.c_cc);
printf("%3d %5d %5d %4d %3d %7d ", tp->t_outq.c_cc,
tp->t_ihiwat, tp->t_ilowat, tp->t_ohiwat, tp->t_olowat,
tp->t_column);
for (i = j = 0; ttystates[i].flag; i++)
if (tp->t_state&ttystates[i].flag)
state[j++] = ttystates[i].val;
if (j == 0)
state[j++] = '-';
state[j] = '\0';
printf("%-6s %8lx", state, (u_long)(void *)tp->t_session);
pgid = 0;
if (tp->t_pgrp != NULL)
KGET2(&tp->t_pgrp->pg_id, &pgid, sizeof(pid_t), "pgid");
printf("%6d ", pgid);
switch (tp->t_line) {
case TTYDISC:
printf("term\n");
break;
case NTTYDISC:
printf("ntty\n");
break;
case SLIPDISC:
printf("slip\n");
break;
case PPPDISC:
printf("ppp\n");
break;
default:
printf("%d\n", tp->t_line);
break;
}
}
/*
* create a pipe, no streams are created until an open
*/
static struct chan *pipeattach(char *spec)
{
ERRSTACK(2);
Pipe *p;
struct chan *c;
c = devattach(devname(), spec);
p = kzmalloc(sizeof(Pipe), 0);
if (p == 0)
error(ENOMEM, ERROR_FIXME);
if (waserror()) {
freepipe(p);
nexterror();
}
p->pipedir = kzmalloc(sizeof(pipedir), 0);
if (p->pipedir == 0)
error(ENOMEM, ERROR_FIXME);
memmove(p->pipedir, pipedir, sizeof(pipedir));
kstrdup(&p->user, current->user);
kref_init(&p->ref, pipe_release, 1);
qlock_init(&p->qlock);
p->q[0] = qopen(pipealloc.pipeqsize, Qcoalesce, 0, 0);
if (p->q[0] == 0)
error(ENOMEM, ERROR_FIXME);
p->q[1] = qopen(pipealloc.pipeqsize, Qcoalesce, 0, 0);
if (p->q[1] == 0)
error(ENOMEM, ERROR_FIXME);
poperror();
spin_lock(&(&pipealloc)->lock);
p->path = ++pipealloc.path;
spin_unlock(&(&pipealloc)->lock);
c->qid.path = NETQID(2 * p->path, Qdir);
c->qid.vers = 0;
c->qid.type = QTDIR;
c->aux = p;
c->dev = 0;
/* taps. */
SLIST_INIT(&p->data_taps[0]); /* already = 0; set to be futureproof */
SLIST_INIT(&p->data_taps[1]);
spinlock_init(&p->tap_lock);
return c;
}
void ProcessesLocal::Private::readProcStat(struct kinfo_proc2 *p, Process *ps)
{
const char *ttname;
dev_t dev;
ps->setUserTime(p->p_uutime_sec*100+p->p_uutime_usec/10000);
ps->setSysTime(p->p_ustime_sec*100+p->p_ustime_usec/10000);
ps->setUserUsage(100.0 * ((double)(p->p_pctcpu) / FSCALE));
ps->setSysUsage(0);
ps->setNiceLevel(p->p_nice - NZERO);
ps->setVmSize((p->p_vm_tsize + p->p_vm_dsize + p->p_vm_ssize)
* getpagesize());
ps->setVmRSS(p->p_vm_rssize * getpagesize());
// "idle","run","sleep","stop","zombie"
switch( p->p_stat ) {
case LSRUN:
ps->setStatus(Process::Running);
break;
case LSSLEEP:
ps->setStatus(Process::Sleeping);
break;
case LSSTOP:
ps->setStatus(Process::Stopped);
break;
case LSZOMB:
ps->setStatus(Process::Zombie);
break;
case LSONPROC:
ps->setStatus(Process::Running);
break;
default:
ps->setStatus(Process::OtherStatus);
break;
}
dev = p->p_tdev;
if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL) {
ps->setTty(QByteArray());
} else {
ps->setTty(QByteArray(ttname));
}
}
int
getinfo(const char *vname)
{
int vd, print_all = 0;
struct vnd_user vnu;
if (vname == NULL) {
vname = DEFAULT_VND;
print_all = 1;
}
vd = opendev((char *)vname, O_RDONLY, OPENDEV_PART, NULL);
if (vd < 0)
err(1, "open: %s", vname);
vnu.vnu_unit = -1;
query:
if (ioctl(vd, VNDIOCGET, &vnu) == -1) {
if (print_all && errno == ENXIO && vnu.vnu_unit > 0) {
close(vd);
return (0);
} else {
err(1, "ioctl: %s", vname);
}
}
fprintf(stdout, "vnd%d: ", vnu.vnu_unit);
if (!vnu.vnu_ino)
fprintf(stdout, "not in use\n");
else
fprintf(stdout, "covering %s on %s, inode %llu\n",
vnu.vnu_file, devname(vnu.vnu_dev, S_IFBLK),
(unsigned long long)vnu.vnu_ino);
if (print_all) {
vnu.vnu_unit++;
goto query;
}
close(vd);
return (0);
}
void df_dev(dev_t dev)
{
unsigned int Total, Used, Free, Percent;
struct _uzifilesys fsys;
const char *dn;
dn = devname(dev);
if(_getfsys(dev, &fsys)){
fprintf(stderr, "df: _getfsys(%d): %s\n", dev, strerror(errno));
return;
}
if(iflag){
/* inodes */
Total = 8 * (fsys.s_isize - 2);
Used = Total - fsys.s_tinode;
Free = fsys.s_tinode;
}else{
/* blocks */
Total = fsys.s_fsize;
Used = Total - fsys.s_isize - fsys.s_tfree;
Free = fsys.s_tfree;
}
if (!iflag && kflag) {
Total /= 2;
Used /= 2;
Free /= 2;
}
Percent = Total / 100;
if (fflag) {
if(Percent)
Percent = Free / Percent;
} else {
if(Percent)
Percent = Used / Percent;
}
printf("%-16s %6u %6u %6u %5u%% %s\n",
dn, Total, Used, Free, Percent,
fsys.s_mntpt ? mntpoint(dn) : (const char*) "/");
}
int
ufs_print(struct vnode *vp)
{
int flag;
struct inode inode, *ip = &inode;
char flagbuf[16], *flags = flagbuf;
char *name;
mode_t type;
KGETRET(VTOI(vp), &inode, sizeof(struct inode), "vnode's inode");
flag = ip->i_flag;
if (flag & IN_ACCESS)
*flags++ = 'A';
if (flag & IN_CHANGE)
*flags++ = 'C';
if (flag & IN_UPDATE)
*flags++ = 'U';
if (flag & IN_MODIFIED)
*flags++ = 'M';
if (flag & IN_RENAME)
*flags++ = 'R';
if (flag & IN_SHLOCK)
*flags++ = 'S';
if (flag & IN_EXLOCK)
*flags++ = 'E';
if (flag & IN_HASHED)
*flags++ = 'H';
if (flag & IN_LAZYMOD)
*flags++ = 'L';
if (flag == 0)
*flags++ = '-';
*flags = '\0';
printf(" %6ju %5s", (uintmax_t)ip->i_number, flagbuf);
type = ip->i_mode & S_IFMT;
if (S_ISCHR(ip->i_mode) || S_ISBLK(ip->i_mode))
if (usenumflag || ((name = devname(ip->i_rdev, type)) == NULL))
printf(" %2d,%-2d",
major(ip->i_rdev), minor(ip->i_rdev));
else
printf(" %7s", name);
else
printf(" %7ju", (uintmax_t)ip->i_size);
return (0);
}
void
tname(const struct kinfo_proc *kp, VARENT *ve)
{
VAR *v;
dev_t dev;
char *ttname;
v = ve->var;
dev = kp->p_tdev;
if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
(void)printf("%-*s", v->width, "??");
else {
if (strncmp(ttname, "tty", 3) == 0)
ttname += 3;
(void)printf("%*.*s%c", v->width-1, v->width-1, ttname,
kp->p_eflag & EPROC_CTTY ? ' ' : '-');
}
}
void BusAssignmentManager::State::listAttachedPCIDevices(ComSafeArrayOut(IPCIDeviceAttachment*, aAttached))
{
com::SafeIfaceArray<IPCIDeviceAttachment> result(mPCIMap.size());
size_t iIndex = 0;
ComObjPtr<PCIDeviceAttachment> dev;
for (PCIMap::const_iterator it = mPCIMap.begin(); it != mPCIMap.end(); ++it)
{
dev.createObject();
com::Bstr devname(it->second.szDevName);
dev->init(NULL, devname,
it->second.HostAddress.valid() ? it->second.HostAddress.asLong() : -1,
it->first.asLong(), it->second.HostAddress.valid());
result.setElement(iIndex++, dev);
}
result.detachTo(ComSafeArrayOutArg(aAttached));
}
static char *getDevPath(dev_t target_dev) {
static char *dev = NULL;
char *name;
if (dev == NULL) {
dev = malloc(MAXPATHLEN);
if (dev == NULL)
return NULL;
}
strcpy(dev, _PATH_DEV);
/* The root device in fstab should always be a block special device */
name = devname(target_dev, S_IFBLK);
if (name == NULL) {
/* No _PATH_DEVDB. We have to search for it the slow way */
DIR *dirp;
struct dirent *ent;
dirp = opendir(_PATH_DEV);
if (dirp == NULL) {
perror("opendir");
return NULL;
}
while ((ent = readdir(dirp)) != NULL) {
/* Look for a block special device */
if (ent->d_type == DT_BLK) {
struct stat devst;
strcat(dev, ent->d_name);
if (stat(dev, &devst) >= 0) {
if (devst.st_rdev == target_dev) {
return dev;
}
}
}
/* set dev to _PATH_DEV and try again */
dev[sizeof(_PATH_DEV) - 1] = '\0';
}
} else {
/* We found the _PATH_DEVDB entry */
strcat(dev, name);
return dev;
}
return NULL;
}
