void bpf_stats(char *ifname) { struct xbpf_d *d, *bd, zerostat; char *pname, flagbuf[12]; size_t size; if (zflag) { bzero(&zerostat, sizeof(zerostat)); if (sysctlbyname("net.bpf.stats", NULL, NULL, &zerostat, sizeof(zerostat)) < 0) xo_warn("failed to zero bpf counters"); return; } if (sysctlbyname("net.bpf.stats", NULL, &size, NULL, 0) < 0) { xo_warn("net.bpf.stats"); return; } if (size == 0) return; bd = malloc(size); if (bd == NULL) { xo_warn("malloc failed"); return; } if (sysctlbyname("net.bpf.stats", bd, &size, NULL, 0) < 0) { xo_warn("net.bpf.stats"); free(bd); return; } xo_emit("{T:/%5s} {T:/%6s} {T:/%7s} {T:/%9s} {T:/%9s} {T:/%9s} " "{T:/%5s} {T:/%5s} {T:/%s}\n", "Pid", "Netif", "Flags", "Recv", "Drop", "Match", "Sblen", "Hblen", "Command"); xo_open_container("bpf-statistics"); xo_open_list("bpf-entry"); for (d = &bd[0]; d < &bd[size / sizeof(*d)]; d++) { if (d->bd_structsize != sizeof(*d)) { xo_warnx("bpf_stats_extended: version mismatch"); return; } if (ifname && strcmp(ifname, d->bd_ifname) != 0) continue; xo_open_instance("bpf-entry"); pname = bpf_pidname(d->bd_pid); xo_emit("{k:pid/%5d} {k:interface-name/%6s} ", d->bd_pid, d->bd_ifname); bpf_flags(d, flagbuf); xo_emit("{d:flags/%7s} {:received-packets/%9ju} " "{:dropped-packets/%9ju} {:filter-packets/%9ju} " "{:store-buffer-length/%5d} {:hold-buffer-length/%5d} " "{:process/%s}\n", flagbuf, (uintmax_t)d->bd_rcount, (uintmax_t)d->bd_dcount, (uintmax_t)d->bd_fcount, d->bd_slen, d->bd_hlen, pname); free(pname); xo_close_instance("bpf-entry"); } xo_close_list("bpf-entry"); xo_close_container("bpf-statistics"); free(bd); }
static int pass2check(struct inodesc *idesc) { struct direct *dirp = idesc->id_dirp; char dirname[MAXPATHLEN + 1]; struct inoinfo *inp; int n, entrysize, ret = 0; union dinode *dp; const char *errmsg; struct direct proto; /* * check for "." */ if (dirp->d_ino > maxino) goto chk2; if (idesc->id_entryno != 0) goto chk1; if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) { if (dirp->d_ino != idesc->id_number) { direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'"); dirp->d_ino = idesc->id_number; if (reply("FIX") == 1) ret |= ALTERED; } if (dirp->d_type != DT_DIR) { direrror(idesc->id_number, "BAD TYPE VALUE FOR '.'"); dirp->d_type = DT_DIR; if (reply("FIX") == 1) ret |= ALTERED; } goto chk1; } direrror(idesc->id_number, "MISSING '.'"); proto.d_ino = idesc->id_number; proto.d_type = DT_DIR; proto.d_namlen = 1; (void)strcpy(proto.d_name, "."); entrysize = DIRSIZ(0, &proto); if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) { pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n", dirp->d_name); } else if (dirp->d_reclen < entrysize) { pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n"); } else if (dirp->d_reclen < 2 * entrysize) { proto.d_reclen = dirp->d_reclen; memmove(dirp, &proto, (size_t)entrysize); if (reply("FIX") == 1) ret |= ALTERED; } else { n = dirp->d_reclen - entrysize; proto.d_reclen = entrysize; memmove(dirp, &proto, (size_t)entrysize); idesc->id_entryno++; inoinfo(dirp->d_ino)->ino_linkcnt--; dirp = (struct direct *)((char *)(dirp) + entrysize); memset(dirp, 0, (size_t)n); dirp->d_reclen = n; if (reply("FIX") == 1) ret |= ALTERED; } chk1: if (idesc->id_entryno > 1) goto chk2; inp = getinoinfo(idesc->id_number); proto.d_ino = inp->i_parent; proto.d_type = DT_DIR; proto.d_namlen = 2; (void)strcpy(proto.d_name, ".."); entrysize = DIRSIZ(0, &proto); if (idesc->id_entryno == 0) { n = DIRSIZ(0, dirp); if (dirp->d_reclen < n + entrysize) goto chk2; proto.d_reclen = dirp->d_reclen - n; dirp->d_reclen = n; idesc->id_entryno++; inoinfo(dirp->d_ino)->ino_linkcnt--; dirp = (struct direct *)((char *)(dirp) + n); memset(dirp, 0, (size_t)proto.d_reclen); dirp->d_reclen = proto.d_reclen; } if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) { inp->i_dotdot = dirp->d_ino; if (dirp->d_type != DT_DIR) { direrror(idesc->id_number, "BAD TYPE VALUE FOR '..'"); dirp->d_type = DT_DIR; if (reply("FIX") == 1) ret |= ALTERED; } goto chk2; } if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) { fileerror(inp->i_parent, idesc->id_number, "MISSING '..'"); pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n", dirp->d_name); inp->i_dotdot = (ino_t)-1; } else if (dirp->d_reclen < entrysize) { fileerror(inp->i_parent, idesc->id_number, "MISSING '..'"); pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n"); inp->i_dotdot = (ino_t)-1; } else if (inp->i_parent != 0) { /* * We know the parent, so fix now. */ inp->i_dotdot = inp->i_parent; fileerror(inp->i_parent, idesc->id_number, "MISSING '..'"); proto.d_reclen = dirp->d_reclen; memmove(dirp, &proto, (size_t)entrysize); if (reply("FIX") == 1) ret |= ALTERED; } idesc->id_entryno++; if (dirp->d_ino != 0) inoinfo(dirp->d_ino)->ino_linkcnt--; return (ret|KEEPON); chk2: if (dirp->d_ino == 0) return (ret|KEEPON); if (dirp->d_namlen <= 2 && dirp->d_name[0] == '.' && idesc->id_entryno >= 2) { if (dirp->d_namlen == 1) { direrror(idesc->id_number, "EXTRA '.' ENTRY"); dirp->d_ino = 0; if (reply("FIX") == 1) ret |= ALTERED; return (KEEPON | ret); } if (dirp->d_name[1] == '.') { direrror(idesc->id_number, "EXTRA '..' ENTRY"); dirp->d_ino = 0; if (reply("FIX") == 1) ret |= ALTERED; return (KEEPON | ret); } } idesc->id_entryno++; n = 0; if (dirp->d_ino > maxino) { fileerror(idesc->id_number, dirp->d_ino, "I OUT OF RANGE"); n = reply("REMOVE"); } else if (((dirp->d_ino == WINO && dirp->d_type != DT_WHT) || (dirp->d_ino != WINO && dirp->d_type == DT_WHT))) { fileerror(idesc->id_number, dirp->d_ino, "BAD WHITEOUT ENTRY"); dirp->d_ino = WINO; dirp->d_type = DT_WHT; if (reply("FIX") == 1) ret |= ALTERED; } else { again: switch (inoinfo(dirp->d_ino)->ino_state) { case USTATE: if (idesc->id_entryno <= 2) break; fileerror(idesc->id_number, dirp->d_ino, "UNALLOCATED"); n = reply("REMOVE"); break; case DCLEAR: case FCLEAR: if (idesc->id_entryno <= 2) break; if (inoinfo(dirp->d_ino)->ino_state == FCLEAR) errmsg = "DUP/BAD"; else if (!preen && !usedsoftdep) errmsg = "ZERO LENGTH DIRECTORY"; else if (cursnapshot == 0) { n = 1; break; } else { getpathname(dirname, idesc->id_number, dirp->d_ino); pwarn("ZERO LENGTH DIRECTORY %s I=%ju", dirname, (uintmax_t)dirp->d_ino); /* * We need to: * setcwd(idesc->id_parent); * rmdir(dirp->d_name); */ cmd.value = idesc->id_number; if (sysctlbyname("vfs.ffs.setcwd", 0, 0, &cmd, sizeof cmd) == -1) { /* kernel lacks support */ printf(" (IGNORED)\n"); n = 1; break; } if (rmdir(dirp->d_name) == -1) { printf(" (REMOVAL FAILED: %s)\n", strerror(errno)); n = 1; break; } /* ".." reference to parent is removed */ inoinfo(idesc->id_number)->ino_linkcnt--; printf(" (REMOVED)\n"); break; } fileerror(idesc->id_number, dirp->d_ino, errmsg); if ((n = reply("REMOVE")) == 1) break; dp = ginode(dirp->d_ino); inoinfo(dirp->d_ino)->ino_state = (DIP(dp, di_mode) & IFMT) == IFDIR ? DSTATE : FSTATE; inoinfo(dirp->d_ino)->ino_linkcnt = DIP(dp, di_nlink); goto again; case DSTATE: case DZLINK: if (inoinfo(idesc->id_number)->ino_state == DFOUND) inoinfo(dirp->d_ino)->ino_state = DFOUND; /* FALLTHROUGH */ case DFOUND: inp = getinoinfo(dirp->d_ino); if (idesc->id_entryno > 2) { if (inp->i_parent == 0) inp->i_parent = idesc->id_number; else if ((n = fix_extraneous(inp, idesc)) == 1) break; } /* FALLTHROUGH */ case FSTATE: case FZLINK: if (dirp->d_type != inoinfo(dirp->d_ino)->ino_type) { fileerror(idesc->id_number, dirp->d_ino, "BAD TYPE VALUE"); dirp->d_type = inoinfo(dirp->d_ino)->ino_type; if (reply("FIX") == 1) ret |= ALTERED; } inoinfo(dirp->d_ino)->ino_linkcnt--; break; default: errx(EEXIT, "BAD STATE %d FOR INODE I=%ju", inoinfo(dirp->d_ino)->ino_state, (uintmax_t)dirp->d_ino); } } if (n == 0) return (ret|KEEPON); dirp->d_ino = 0; return (ret|KEEPON|ALTERED); }
static int fix_extraneous(struct inoinfo *inp, struct inodesc *idesc) { char *cp; struct inodesc dotdesc; char oldname[MAXPATHLEN + 1]; char newname[MAXPATHLEN + 1]; /* * If we have not yet found "..", look it up now so we know * which inode the directory itself believes is its parent. */ if (inp->i_dotdot == 0) { memset(&dotdesc, 0, sizeof(struct inodesc)); dotdesc.id_type = DATA; dotdesc.id_number = idesc->id_dirp->d_ino; dotdesc.id_func = findino; dotdesc.id_name = strdup(".."); if ((ckinode(ginode(dotdesc.id_number), &dotdesc) & FOUND)) inp->i_dotdot = dotdesc.id_parent; } /* * We have the previously found old name (inp->i_parent) and the * just found new name (idesc->id_number). We have five cases: * 1) ".." is missing - can remove either name, choose to delete * new one and let fsck create ".." pointing to old name. * 2) Both new and old are in same directory, choose to delete * the new name and let fsck fix ".." if it is wrong. * 3) ".." does not point to the new name, so delete it and let * fsck fix ".." to point to the old one if it is wrong. * 4) ".." points to the old name only, so delete the new one. * 5) ".." points to the new name only, so delete the old one. * * For cases 1-4 we eliminate the new name; * for case 5 we eliminate the old name. */ if (inp->i_dotdot == 0 || /* Case 1 */ idesc->id_number == inp->i_parent || /* Case 2 */ inp->i_dotdot != idesc->id_number || /* Case 3 */ inp->i_dotdot == inp->i_parent) { /* Case 4 */ getpathname(newname, idesc->id_number, idesc->id_number); if (strcmp(newname, "/") != 0) strcat (newname, "/"); strcat(newname, idesc->id_dirp->d_name); getpathname(oldname, inp->i_number, inp->i_number); pwarn("%s IS AN EXTRANEOUS HARD LINK TO DIRECTORY %s", newname, oldname); if (cursnapshot != 0) { /* * We need to * setcwd(idesc->id_number); * unlink(idesc->id_dirp->d_name); */ cmd.value = idesc->id_number; if (sysctlbyname("vfs.ffs.setcwd", 0, 0, &cmd, sizeof cmd) == -1) { printf(" (IGNORED)\n"); return (0); } cmd.value = (intptr_t)idesc->id_dirp->d_name; cmd.size = inp->i_number; /* verify same name */ if (sysctlbyname("vfs.ffs.unlink", 0, 0, &cmd, sizeof cmd) == -1) { printf(" (UNLINK FAILED: %s)\n", strerror(errno)); return (0); } printf(" (REMOVED)\n"); return (0); } if (preen) { printf(" (REMOVED)\n"); return (1); } return (reply("REMOVE")); } /* * None of the first four cases above, so must be case (5). * Eliminate the old name and make the new the name the parent. */ getpathname(oldname, inp->i_parent, inp->i_number); getpathname(newname, inp->i_number, inp->i_number); pwarn("%s IS AN EXTRANEOUS HARD LINK TO DIRECTORY %s", oldname, newname); if (cursnapshot != 0) { /* * We need to * setcwd(inp->i_parent); * unlink(last component of oldname pathname); */ cmd.value = inp->i_parent; if (sysctlbyname("vfs.ffs.setcwd", 0, 0, &cmd, sizeof cmd) == -1) { printf(" (IGNORED)\n"); return (0); } if ((cp = strchr(oldname, '/')) == NULL) { printf(" (IGNORED)\n"); return (0); } cmd.value = (intptr_t)(cp + 1); cmd.size = inp->i_number; /* verify same name */ if (sysctlbyname("vfs.ffs.unlink", 0, 0, &cmd, sizeof cmd) == -1) { printf(" (UNLINK FAILED: %s)\n", strerror(errno)); return (0); } printf(" (REMOVED)\n"); inp->i_parent = idesc->id_number; /* reparent to correct dir */ return (0); } if (!preen && !reply("REMOVE")) return (0); memset(&dotdesc, 0, sizeof(struct inodesc)); dotdesc.id_type = DATA; dotdesc.id_number = inp->i_parent; /* directory in which name appears */ dotdesc.id_parent = inp->i_number; /* inode number in entry to delete */ dotdesc.id_func = deleteentry; if ((ckinode(ginode(dotdesc.id_number), &dotdesc) & FOUND) && preen) printf(" (REMOVED)\n"); inp->i_parent = idesc->id_number; /* reparent to correct directory */ inoinfo(inp->i_number)->ino_linkcnt++; /* name gone, return reference */ return (0); }
ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle) { char *red_zone, *zone; size_t len; ngx_int_t i; struct sigaction sa; max_threads = n + 1; for (i = 0; i < n; i++) { ngx_memzero(&sa, sizeof(struct sigaction)); sa.sa_handler = SIG_IGN; sigemptyset(&sa.sa_mask); if (sigaction(NGX_CV_SIGNAL, &sa, NULL) == -1) { ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "sigaction(%d, SIG_IGN) failed", NGX_CV_SIGNAL); return NGX_ERROR; } } len = sizeof(ngx_freebsd_kern_usrstack); if (sysctlbyname("kern.usrstack", &ngx_freebsd_kern_usrstack, &len, NULL, 0) == -1) { ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "sysctlbyname(kern.usrstack) failed"); return NGX_ERROR; } /* the main thread stack red zone */ rz_size = ngx_pagesize; red_zone = ngx_freebsd_kern_usrstack - (size + rz_size); ngx_log_debug2(NGX_LOG_DEBUG_CORE, cycle->log, 0, "usrstack: %p red zone: %p", ngx_freebsd_kern_usrstack, red_zone); zone = mmap(red_zone, rz_size, PROT_NONE, MAP_ANON, -1, 0); if (zone == MAP_FAILED) { ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "mmap(%p:%uz, PROT_NONE, MAP_ANON) red zone failed", red_zone, rz_size); return NGX_ERROR; } if (zone != red_zone) { ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "red zone %p address was changed to %p", red_zone, zone); return NGX_ERROR; } /* create the thread errno' array */ errnos = ngx_calloc(n * sizeof(int), cycle->log); if (errnos == NULL) { return NGX_ERROR; } /* create the thread tids array */ tids = ngx_calloc((n + 1) * sizeof(ngx_tid_t), cycle->log); if (tids == NULL) { return NGX_ERROR; } tids[0] = ngx_pid; /* create the thread tls' array */ ngx_tls = ngx_calloc(NGX_THREAD_KEYS_MAX * (n + 1) * sizeof(void *), cycle->log); if (ngx_tls == NULL) { return NGX_ERROR; } nthreads = 1; last_stack = zone + rz_size; usable_stack_size = size; ngx_thread_stack_size = size + rz_size; /* allow the spinlock in libc malloc() */ __isthreaded = 1; ngx_threaded = 1; return NGX_OK; }
ngx_int_t ngx_os_specific_init(ngx_log_t *log) { size_t size; ngx_err_t err; ngx_uint_t i; size = sizeof(ngx_darwin_kern_ostype); if (sysctlbyname("kern.ostype", ngx_darwin_kern_ostype, &size, NULL, 0) == -1) { err = ngx_errno; if (err != NGX_ENOENT) { ngx_log_error(NGX_LOG_ALERT, log, err, "sysctlbyname(kern.ostype) failed"); if (err != NGX_ENOMEM) { return NGX_ERROR; } ngx_darwin_kern_ostype[size - 1] = '\0'; } } size = sizeof(ngx_darwin_kern_osrelease); if (sysctlbyname("kern.osrelease", ngx_darwin_kern_osrelease, &size, NULL, 0) == -1) { err = ngx_errno; if (err != NGX_ENOENT) { ngx_log_error(NGX_LOG_ALERT, log, err, "sysctlbyname(kern.osrelease) failed"); if (err != NGX_ENOMEM) { return NGX_ERROR; } ngx_darwin_kern_osrelease[size - 1] = '\0'; } } for (i = 0; sysctls[i].name; i++) { size = sysctls[i].size; if (sysctlbyname(sysctls[i].name, sysctls[i].value, &size, NULL, 0) == 0) { sysctls[i].exists = 1; continue; } err = ngx_errno; if (err == NGX_ENOENT) { continue; } ngx_log_error(NGX_LOG_ALERT, log, err, "sysctlbyname(%s) failed", sysctls[i].name); return NGX_ERROR; } ngx_ncpu = ngx_darwin_hw_ncpu; if (ngx_darwin_kern_ipc_somaxconn > 32767) { ngx_log_error(NGX_LOG_ALERT, log, 0, "sysctl kern.ipc.somaxconn must be less than 32768"); return NGX_ERROR; } ngx_tcp_nodelay_and_tcp_nopush = 1; ngx_os_io = ngx_darwin_io; return NGX_OK; }
void updatestat(void) { int i, hz; struct clockinfo clockrate; struct vmmeter cnt; struct ifmibdata ifmd; double avrun[3]; struct timeval tm, btm; int mib[6]; size_t len; int ifcount; #ifdef DEBUG fprintf(stderr, "entering updatestat\n"); #endif if (sincelastreq >= closedown) { #ifdef DEBUG fprintf(stderr, "about to closedown\n"); #endif if (from_inetd) exit(0); else { stat_is_init = 0; return; } } sincelastreq++; mib[0] = CTL_KERN; mib[1] = KERN_CLOCKRATE; len = sizeof clockrate; if (sysctl(mib, 2, &clockrate, &len, 0, 0) < 0) { syslog(LOG_ERR, "sysctl(kern.clockrate): %m"); exit(1); } hz = clockrate.hz; len = sizeof(bsd_cp_time); if (sysctlbyname("kern.cp_time", bsd_cp_time, &len, 0, 0) < 0) { syslog(LOG_ERR, "sysctl(kern.cp_time): %m"); exit(1); } for(i = 0; i < RSTAT_CPUSTATES ; i++) stats_all.s1.cp_time[i] = bsd_cp_time[cp_time_xlat[i]]; (void)getloadavg(avrun, sizeof(avrun) / sizeof(avrun[0])); stats_all.s2.avenrun[0] = avrun[0] * FSCALE; stats_all.s2.avenrun[1] = avrun[1] * FSCALE; stats_all.s2.avenrun[2] = avrun[2] * FSCALE; mib[0] = CTL_KERN; mib[1] = KERN_BOOTTIME; len = sizeof btm; if (sysctl(mib, 2, &btm, &len, 0, 0) < 0) { syslog(LOG_ERR, "sysctl(kern.boottime): %m"); exit(1); } stats_all.s2.boottime.tv_sec = btm.tv_sec; stats_all.s2.boottime.tv_usec = btm.tv_usec; #ifdef DEBUG fprintf(stderr, "%d %d %d %d\n", stats_all.s1.cp_time[0], stats_all.s1.cp_time[1], stats_all.s1.cp_time[2], stats_all.s1.cp_time[3]); #endif #define FETCH_CNT(stat, cnt) do { \ len = sizeof((stat)); \ if (sysctlbyname("vm.stats." #cnt , &(stat), &len, 0, 0) < 0) { \ syslog(LOG_ERR, "sysctl(vm.stats." #cnt "): %m"); \ exit(1); \ } \ } while (0) FETCH_CNT(stats_all.s1.v_pgpgin, vm.v_vnodepgsin); FETCH_CNT(stats_all.s1.v_pgpgout, vm.v_vnodepgsout); FETCH_CNT(stats_all.s1.v_pswpin, vm.v_swappgsin); FETCH_CNT(stats_all.s1.v_pswpout, vm.v_swappgsout); FETCH_CNT(stats_all.s1.v_intr, sys.v_intr); FETCH_CNT(stats_all.s2.v_swtch, sys.v_swtch); (void)gettimeofday(&tm, NULL); stats_all.s1.v_intr -= hz*(tm.tv_sec - btm.tv_sec) + hz*(tm.tv_usec - btm.tv_usec)/1000000; /* update disk transfers */ updatexfers(RSTAT_DK_NDRIVE, stats_all.s1.dk_xfer); mib[0] = CTL_NET; mib[1] = PF_LINK; mib[2] = NETLINK_GENERIC; mib[3] = IFMIB_SYSTEM; mib[4] = IFMIB_IFCOUNT; len = sizeof ifcount; if (sysctl(mib, 5, &ifcount, &len, 0, 0) < 0) { syslog(LOG_ERR, "sysctl(net.link.generic.system.ifcount): %m"); exit(1); } stats_all.s1.if_ipackets = 0; stats_all.s1.if_opackets = 0; stats_all.s1.if_ierrors = 0; stats_all.s1.if_oerrors = 0; stats_all.s1.if_collisions = 0; for (i = 1; i <= ifcount; i++) { len = sizeof ifmd; mib[3] = IFMIB_IFDATA; mib[4] = i; mib[5] = IFDATA_GENERAL; if (sysctl(mib, 6, &ifmd, &len, 0, 0) < 0) { if (errno == ENOENT) continue; syslog(LOG_ERR, "sysctl(net.link.ifdata.%d.general)" ": %m", i); exit(1); } stats_all.s1.if_ipackets += ifmd.ifmd_data.ifi_ipackets; stats_all.s1.if_opackets += ifmd.ifmd_data.ifi_opackets; stats_all.s1.if_ierrors += ifmd.ifmd_data.ifi_ierrors; stats_all.s1.if_oerrors += ifmd.ifmd_data.ifi_oerrors; stats_all.s1.if_collisions += ifmd.ifmd_data.ifi_collisions; } (void)gettimeofday(&tm, NULL); stats_all.s3.curtime.tv_sec = tm.tv_sec; stats_all.s3.curtime.tv_usec = tm.tv_usec; alarm(1); }
static ACPI_STATUS OslTableInitialize ( void) { #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) char Buffer[32]; #endif ACPI_TABLE_HEADER *MappedTable; UINT8 *TableAddress; UINT8 *RsdpAddress; ACPI_PHYSICAL_ADDRESS RsdpBase; ACPI_SIZE RsdpSize; ACPI_STATUS Status; u_long Address = 0; size_t Length = sizeof (Address); /* Get main ACPI tables from memory on first invocation of this function */ if (Gbl_MainTableObtained) { return (AE_OK); } /* Attempt to use kenv or sysctl to find RSD PTR record. */ if (Gbl_RsdpBase) { Address = Gbl_RsdpBase; } #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) else if (kenv (KENV_GET, SYSTEM_KENV, Buffer, sizeof (Buffer)) > 0) { Address = ACPI_STRTOUL (Buffer, NULL, 0); } #endif if (!Address) { if (sysctlbyname (SYSTEM_SYSCTL, &Address, &Length, NULL, 0) != 0) { Address = 0; } } if (Address) { RsdpBase = Address; RsdpSize = sizeof (Gbl_Rsdp); } else { RsdpBase = ACPI_HI_RSDP_WINDOW_BASE; RsdpSize = ACPI_HI_RSDP_WINDOW_SIZE; } /* Get RSDP from memory */ RsdpAddress = AcpiOsMapMemory (RsdpBase, RsdpSize); if (!RsdpAddress) { return (AE_BAD_ADDRESS); } /* Search low memory for the RSDP */ TableAddress = AcpiTbScanMemoryForRsdp (RsdpAddress, RsdpSize); if (!TableAddress) { AcpiOsUnmapMemory (RsdpAddress, RsdpSize); return (AE_ERROR); } ACPI_MEMCPY (&Gbl_Rsdp, TableAddress, sizeof (Gbl_Rsdp)); AcpiOsUnmapMemory (RsdpAddress, RsdpSize); /* Get XSDT from memory */ if (Gbl_Rsdp.Revision) { Status = OslMapTable (Gbl_Rsdp.XsdtPhysicalAddress, ACPI_SIG_XSDT, &MappedTable); if (ACPI_FAILURE (Status)) { return (Status); } Gbl_Revision = 2; Gbl_Xsdt = calloc (1, MappedTable->Length); if (!Gbl_Xsdt) { fprintf (stderr, "XSDT: Could not allocate buffer for table of length %X\n", MappedTable->Length); AcpiOsUnmapMemory (MappedTable, MappedTable->Length); return (AE_NO_MEMORY); } ACPI_MEMCPY (Gbl_Xsdt, MappedTable, MappedTable->Length); AcpiOsUnmapMemory (MappedTable, MappedTable->Length); } /* Get RSDT from memory */ if (Gbl_Rsdp.RsdtPhysicalAddress) { Status = OslMapTable (Gbl_Rsdp.RsdtPhysicalAddress, ACPI_SIG_RSDT, &MappedTable); if (ACPI_FAILURE (Status)) { return (Status); } Gbl_Rsdt = calloc (1, MappedTable->Length); if (!Gbl_Rsdt) { fprintf (stderr, "RSDT: Could not allocate buffer for table of length %X\n", MappedTable->Length); AcpiOsUnmapMemory (MappedTable, MappedTable->Length); return (AE_NO_MEMORY); } ACPI_MEMCPY (Gbl_Rsdt, MappedTable, MappedTable->Length); AcpiOsUnmapMemory (MappedTable, MappedTable->Length); } /* Get FADT from memory */ if (Gbl_Revision) { Gbl_FadtAddress = Gbl_Xsdt->TableOffsetEntry[0]; } else { Gbl_FadtAddress = Gbl_Rsdt->TableOffsetEntry[0]; } if (!Gbl_FadtAddress) { fprintf(stderr, "FADT: Table could not be found\n"); return (AE_ERROR); } Status = OslMapTable (Gbl_FadtAddress, ACPI_SIG_FADT, &MappedTable); if (ACPI_FAILURE (Status)) { return (Status); } Gbl_Fadt = calloc (1, MappedTable->Length); if (!Gbl_Fadt) { fprintf (stderr, "FADT: Could not allocate buffer for table of length %X\n", MappedTable->Length); AcpiOsUnmapMemory (MappedTable, MappedTable->Length); return (AE_NO_MEMORY); } ACPI_MEMCPY (Gbl_Fadt, MappedTable, MappedTable->Length); AcpiOsUnmapMemory (MappedTable, MappedTable->Length); Gbl_MainTableObtained = TRUE; return (AE_OK); }
static int conn_read (void) { int status; char *buffer; size_t buffer_len;; struct xinpgen *in_orig; struct xinpgen *in_ptr; conn_reset_port_entry (); buffer_len = 0; status = sysctlbyname ("net.inet.tcp.pcblist", NULL, &buffer_len, 0, 0); if (status < 0) { ERROR ("tcpconns plugin: sysctlbyname failed."); return (-1); } buffer = malloc (buffer_len); if (buffer == NULL) { ERROR ("tcpconns plugin: malloc failed."); return (-1); } status = sysctlbyname ("net.inet.tcp.pcblist", buffer, &buffer_len, 0, 0); if (status < 0) { ERROR ("tcpconns plugin: sysctlbyname failed."); sfree (buffer); return (-1); } if (buffer_len <= sizeof (struct xinpgen)) { ERROR ("tcpconns plugin: (buffer_len <= sizeof (struct xinpgen))"); sfree (buffer); return (-1); } in_orig = (struct xinpgen *) buffer; for (in_ptr = (struct xinpgen *) (((char *) in_orig) + in_orig->xig_len); in_ptr->xig_len > sizeof (struct xinpgen); in_ptr = (struct xinpgen *) (((char *) in_ptr) + in_ptr->xig_len)) { struct tcpcb *tp = &((struct xtcpcb *) in_ptr)->xt_tp; struct inpcb *inp = &((struct xtcpcb *) in_ptr)->xt_inp; struct xsocket *so = &((struct xtcpcb *) in_ptr)->xt_socket; /* Ignore non-TCP sockets */ if (so->xso_protocol != IPPROTO_TCP) continue; /* Ignore PCBs which were freed during copyout. */ if (inp->inp_gencnt > in_orig->xig_gen) continue; if (((inp->inp_vflag & INP_IPV4) == 0) && ((inp->inp_vflag & INP_IPV6) == 0)) continue; conn_handle_ports (ntohs (inp->inp_lport), ntohs (inp->inp_fport), tp->t_state); } /* for (in_ptr) */ in_orig = NULL; in_ptr = NULL; sfree (buffer); conn_submit_all (); return (0); } /* int conn_read */
void kget(int idx, void *addr, size_t size) { const char *symn; /* symbol name */ size_t tsiz; int rv; unsigned long kaddr; const char *sym2sysctl[] = { /* symbol to sysctl name table */ "kern.ipc.sema", "kern.ipc.seminfo", "kern.ipc.msginfo", "kern.ipc.msqids", "kern.ipc.shminfo", "kern.ipc.shmsegs" }; assert((unsigned)idx <= sizeof(sym2sysctl) / sizeof(*sym2sysctl)); if (!use_sysctl) { symn = symbols[idx].n_name; if (*symn == '_') symn++; if (symbols[idx].n_type == 0 || symbols[idx].n_value == 0) errx(1, "symbol %s undefined", symn); /* * For some symbols, the value we retrieve is * actually a pointer; since we want the actual value, * we have to manually dereference it. */ switch (idx) { case X_MSQIDS: tsiz = sizeof(msqids); rv = kvm_read(kd, symbols[idx].n_value, &msqids, tsiz); kaddr = (u_long)msqids; break; case X_SHMSEGS: tsiz = sizeof(shmsegs); rv = kvm_read(kd, symbols[idx].n_value, &shmsegs, tsiz); kaddr = (u_long)shmsegs; break; case X_SEMA: tsiz = sizeof(sema); rv = kvm_read(kd, symbols[idx].n_value, &sema, tsiz); kaddr = (u_long)sema; break; default: rv = tsiz = 0; kaddr = symbols[idx].n_value; break; } if ((unsigned)rv != tsiz) errx(1, "%s: %s", symn, kvm_geterr(kd)); if ((unsigned)kvm_read(kd, kaddr, addr, size) != size) errx(1, "%s: %s", symn, kvm_geterr(kd)); } else { switch (idx) { case X_SHMINFO: sysctlgatherstruct(addr, size, shminfo_scgsv); break; case X_SEMINFO: sysctlgatherstruct(addr, size, seminfo_scgsv); break; case X_MSGINFO: sysctlgatherstruct(addr, size, msginfo_scgsv); break; default: tsiz = size; rv = sysctlbyname(sym2sysctl[idx], addr, &tsiz, NULL, 0); if (rv == -1) err(1, "sysctlbyname: %s", sym2sysctl[idx]); if (tsiz != size) errx(1, "%s size mismatch " "(expected %zu, got %zu)", sym2sysctl[idx], size, tsiz); break; } } }
bool CCPUInfo::readProcStat(unsigned long long& user, unsigned long long& nice, unsigned long long& system, unsigned long long& idle, unsigned long long& io) { #ifdef TARGET_WINDOWS FILETIME idleTime; FILETIME kernelTime; FILETIME userTime; if (GetSystemTimes(&idleTime, &kernelTime, &userTime) == 0) return false; idle = (uint64_t(idleTime.dwHighDateTime) << 32) + uint64_t(idleTime.dwLowDateTime); // returned "kernelTime" includes "idleTime" system = (uint64_t(kernelTime.dwHighDateTime) << 32) + uint64_t(kernelTime.dwLowDateTime) - idle; user = (uint64_t(userTime.dwHighDateTime) << 32) + uint64_t(userTime.dwLowDateTime); nice = 0; io = 0; if (m_cpuFreqCounter && PdhCollectQueryData(m_cpuQueryLoad) == ERROR_SUCCESS) { for (std::map<int, CoreInfo>::iterator it = m_cores.begin(); it != m_cores.end(); ++it) { CoreInfo& curCore = it->second; // simplify usage PDH_RAW_COUNTER cnt; DWORD cntType; if (curCore.m_coreCounter && PdhGetRawCounterValue(curCore.m_coreCounter, &cntType, &cnt) == ERROR_SUCCESS && (cnt.CStatus == PDH_CSTATUS_VALID_DATA || cnt.CStatus == PDH_CSTATUS_NEW_DATA)) { const LONGLONG coreTotal = cnt.SecondValue, coreIdle = cnt.FirstValue; const LONGLONG deltaTotal = coreTotal - curCore.m_total, deltaIdle = coreIdle - curCore.m_idle; const double load = (double(deltaTotal - deltaIdle) * 100.0) / double(deltaTotal); // win32 has some problems with calculation of load if load close to zero curCore.m_fPct = (load < 0) ? 0 : load; if (load >= 0 || deltaTotal > 5 * 10 * 1000 * 1000) // do not update (smooth) values for 5 seconds on negative loads { curCore.m_total = coreTotal; curCore.m_idle = coreIdle; } } else curCore.m_fPct = double(m_lastUsedPercentage); // use CPU average as fallback } } else for (std::map<int, CoreInfo>::iterator it = m_cores.begin(); it != m_cores.end(); ++it) it->second.m_fPct = double(m_lastUsedPercentage); // use CPU average as fallback #elif defined(TARGET_FREEBSD) long *cptimes; size_t len; int i; len = sizeof(long) * 32 * CPUSTATES; if (sysctlbyname("kern.cp_times", NULL, &len, NULL, 0) != 0) return false; cptimes = (long*)malloc(len); if (cptimes == NULL) return false; if (sysctlbyname("kern.cp_times", cptimes, &len, NULL, 0) != 0) { free(cptimes); return false; } user = 0; nice = 0; system = 0; idle = 0; io = 0; for (i = 0; i < m_cpuCount; i++) { long coreUser, coreNice, coreSystem, coreIdle, coreIO; double total; coreUser = cptimes[i * CPUSTATES + CP_USER]; coreNice = cptimes[i * CPUSTATES + CP_NICE]; coreSystem = cptimes[i * CPUSTATES + CP_SYS]; coreIO = cptimes[i * CPUSTATES + CP_INTR]; coreIdle = cptimes[i * CPUSTATES + CP_IDLE]; std::map<int, CoreInfo>::iterator iter = m_cores.find(i); if (iter != m_cores.end()) { coreUser -= iter->second.m_user; coreNice -= iter->second.m_nice; coreSystem -= iter->second.m_system; coreIdle -= iter->second.m_idle; coreIO -= iter->second.m_io; total = (double)(coreUser + coreNice + coreSystem + coreIdle + coreIO); if(total != 0.0f) iter->second.m_fPct = ((double)(coreUser + coreNice + coreSystem) * 100.0) / total; iter->second.m_user += coreUser; iter->second.m_nice += coreNice; iter->second.m_system += coreSystem; iter->second.m_idle += coreIdle; iter->second.m_io += coreIO; user += coreUser; nice += coreNice; system += coreSystem; idle += coreIdle; io += coreIO; } } free(cptimes); #else if (m_fProcStat == NULL) return false; #ifdef TARGET_ANDROID // Just another (vanilla) NDK quirk: // rewind + fflush do not actually flush the buffers, // the same initial content is returned rather than re-read fclose(m_fProcStat); m_fProcStat = fopen("/proc/stat", "r"); #else rewind(m_fProcStat); fflush(m_fProcStat); #endif char buf[256]; if (!fgets(buf, sizeof(buf), m_fProcStat)) return false; int num = sscanf(buf, "cpu %llu %llu %llu %llu %llu %*s\n", &user, &nice, &system, &idle, &io); if (num < 5) io = 0; while (fgets(buf, sizeof(buf), m_fProcStat) && num >= 4) { unsigned long long coreUser, coreNice, coreSystem, coreIdle, coreIO; int nCpu=0; num = sscanf(buf, "cpu%d %llu %llu %llu %llu %llu %*s\n", &nCpu, &coreUser, &coreNice, &coreSystem, &coreIdle, &coreIO); if (num < 6) coreIO = 0; std::map<int, CoreInfo>::iterator iter = m_cores.find(nCpu); if (num > 4 && iter != m_cores.end()) { coreUser -= iter->second.m_user; coreNice -= iter->second.m_nice; coreSystem -= iter->second.m_system; coreIdle -= iter->second.m_idle; coreIO -= iter->second.m_io; double total = (double)(coreUser + coreNice + coreSystem + coreIdle + coreIO); if(total == 0.0f) iter->second.m_fPct = 0.0f; else iter->second.m_fPct = ((double)(coreUser + coreNice + coreSystem) * 100.0) / total; iter->second.m_user += coreUser; iter->second.m_nice += coreNice; iter->second.m_system += coreSystem; iter->second.m_idle += coreIdle; iter->second.m_io += coreIO; } } #endif return true; }
void CCPUInfo::ReadCPUFeatures() { #ifdef TARGET_WINDOWS int CPUInfo[4]; // receives EAX, EBX, ECD and EDX in that order __cpuid(CPUInfo, 0); int MaxStdInfoType = CPUInfo[0]; if (MaxStdInfoType >= CPUID_INFOTYPE_STANDARD) { __cpuid(CPUInfo, CPUID_INFOTYPE_STANDARD); if (CPUInfo[CPUINFO_EDX] & CPUID_00000001_EDX_MMX) m_cpuFeatures |= CPU_FEATURE_MMX; if (CPUInfo[CPUINFO_EDX] & CPUID_00000001_EDX_SSE) m_cpuFeatures |= CPU_FEATURE_SSE; if (CPUInfo[CPUINFO_EDX] & CPUID_00000001_EDX_SSE2) m_cpuFeatures |= CPU_FEATURE_SSE2; if (CPUInfo[CPUINFO_ECX] & CPUID_00000001_ECX_SSE3) m_cpuFeatures |= CPU_FEATURE_SSE3; if (CPUInfo[CPUINFO_ECX] & CPUID_00000001_ECX_SSSE3) m_cpuFeatures |= CPU_FEATURE_SSSE3; if (CPUInfo[CPUINFO_ECX] & CPUID_00000001_ECX_SSE4) m_cpuFeatures |= CPU_FEATURE_SSE4; if (CPUInfo[CPUINFO_ECX] & CPUID_00000001_ECX_SSE42) m_cpuFeatures |= CPU_FEATURE_SSE42; } __cpuid(CPUInfo, 0x80000000); int MaxExtInfoType = CPUInfo[0]; if (MaxExtInfoType >= CPUID_INFOTYPE_EXTENDED) { __cpuid(CPUInfo, CPUID_INFOTYPE_EXTENDED); if (CPUInfo[CPUINFO_EDX] & CPUID_80000001_EDX_MMX) m_cpuFeatures |= CPU_FEATURE_MMX; if (CPUInfo[CPUINFO_EDX] & CPUID_80000001_EDX_MMX2) m_cpuFeatures |= CPU_FEATURE_MMX2; if (CPUInfo[CPUINFO_EDX] & CPUID_80000001_EDX_3DNOW) m_cpuFeatures |= CPU_FEATURE_3DNOW; if (CPUInfo[CPUINFO_EDX] & CPUID_80000001_EDX_3DNOWEXT) m_cpuFeatures |= CPU_FEATURE_3DNOWEXT; } #elif defined(TARGET_DARWIN) #if defined(__ppc__) m_cpuFeatures |= CPU_FEATURE_ALTIVEC; #elif defined(TARGET_DARWIN_IOS) #else size_t len = 512 - 1; // '-1' for trailing space char buffer[512] ={0}; if (sysctlbyname("machdep.cpu.features", &buffer, &len, NULL, 0) == 0) { strcat(buffer, " "); if (strstr(buffer,"MMX ")) m_cpuFeatures |= CPU_FEATURE_MMX; if (strstr(buffer,"MMXEXT ")) m_cpuFeatures |= CPU_FEATURE_MMX2; if (strstr(buffer,"SSE ")) m_cpuFeatures |= CPU_FEATURE_SSE; if (strstr(buffer,"SSE2 ")) m_cpuFeatures |= CPU_FEATURE_SSE2; if (strstr(buffer,"SSE3 ")) m_cpuFeatures |= CPU_FEATURE_SSE3; if (strstr(buffer,"SSSE3 ")) m_cpuFeatures |= CPU_FEATURE_SSSE3; if (strstr(buffer,"SSE4.1 ")) m_cpuFeatures |= CPU_FEATURE_SSE4; if (strstr(buffer,"SSE4.2 ")) m_cpuFeatures |= CPU_FEATURE_SSE42; if (strstr(buffer,"3DNOW ")) m_cpuFeatures |= CPU_FEATURE_3DNOW; if (strstr(buffer,"3DNOWEXT ")) m_cpuFeatures |= CPU_FEATURE_3DNOWEXT; } else m_cpuFeatures |= CPU_FEATURE_MMX; #endif #elif defined(LINUX) // empty on purpose, the implementation is in the constructor #elif !defined(__powerpc__) && !defined(__ppc__) && !defined(__arm__) m_cpuFeatures |= CPU_FEATURE_MMX; #elif defined(__powerpc__) || defined(__ppc__) m_cpuFeatures |= CPU_FEATURE_ALTIVEC; #endif }
float CCPUInfo::getCPUFrequency() { // Get CPU frequency, scaled to MHz. #if defined(TARGET_DARWIN) long long hz = 0; size_t len = sizeof(hz); if (sysctlbyname("hw.cpufrequency", &hz, &len, NULL, 0) == -1) return 0.f; return hz / 1000000.0; #elif defined TARGET_WINDOWS if (m_cpuFreqCounter && PdhCollectQueryData(m_cpuQueryFreq) == ERROR_SUCCESS) { PDH_RAW_COUNTER cnt; DWORD cntType; if (PdhGetRawCounterValue(m_cpuFreqCounter, &cntType, &cnt) == ERROR_SUCCESS && (cnt.CStatus == PDH_CSTATUS_VALID_DATA || cnt.CStatus == PDH_CSTATUS_NEW_DATA)) { return float(cnt.FirstValue); } } if (!m_cores.empty()) return float(m_cores.begin()->second.m_fSpeed); else return 0.f; #elif defined(TARGET_FREEBSD) int hz = 0; size_t len = sizeof(hz); if (sysctlbyname("dev.cpu.0.freq", &hz, &len, NULL, 0) != 0) hz = 0; return (float)hz; #else int value = 0; if (m_fCPUFreq && !m_cpuInfoForFreq) { rewind(m_fCPUFreq); fflush(m_fCPUFreq); fscanf(m_fCPUFreq, "%d", &value); value /= 1000.0; } if (m_fCPUFreq && m_cpuInfoForFreq) { rewind(m_fCPUFreq); fflush(m_fCPUFreq); float mhz, avg=0.0; int n, cpus=0; while(EOF!=(n=fscanf(m_fCPUFreq," MHz : %f ", &mhz))) { if (n>0) { cpus++; avg += mhz; } fscanf(m_fCPUFreq,"%*s"); } if (cpus > 0) value = avg/cpus; } return value; #endif }
CCPUInfo::CCPUInfo(void) { #ifdef TARGET_POSIX m_fProcStat = m_fProcTemperature = m_fCPUFreq = NULL; m_cpuInfoForFreq = false; #elif defined(TARGET_WINDOWS) m_cpuQueryFreq = NULL; m_cpuQueryLoad = NULL; #endif m_lastUsedPercentage = 0; m_cpuFeatures = 0; #if defined(TARGET_DARWIN) size_t len = 4; std::string cpuVendor; // The number of cores. if (sysctlbyname("hw.activecpu", &m_cpuCount, &len, NULL, 0) == -1) m_cpuCount = 1; // The model. #if defined(__ppc__) || defined (TARGET_DARWIN_IOS) const NXArchInfo *info = NXGetLocalArchInfo(); if (info != NULL) m_cpuModel = info->description; #else // NXGetLocalArchInfo is ugly for intel so keep using this method char buffer[512]; len = 512; if (sysctlbyname("machdep.cpu.brand_string", &buffer, &len, NULL, 0) == 0) m_cpuModel = buffer; // The CPU vendor len = 512; if (sysctlbyname("machdep.cpu.vendor", &buffer, &len, NULL, 0) == 0) cpuVendor = buffer; #endif // Go through each core. for (int i=0; i<m_cpuCount; i++) { CoreInfo core; core.m_id = i; core.m_strModel = m_cpuModel; core.m_strVendor = cpuVendor; m_cores[core.m_id] = core; } #elif defined(TARGET_WINDOWS) HKEY hKeyCpuRoot; if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor", 0, KEY_READ, &hKeyCpuRoot) == ERROR_SUCCESS) { DWORD num = 0; std::vector<CoreInfo> cpuCores; wchar_t subKeyName[200]; // more than enough DWORD subKeyNameLen = sizeof(subKeyName) / sizeof(wchar_t); while (RegEnumKeyExW(hKeyCpuRoot, num++, subKeyName, &subKeyNameLen, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { HKEY hCpuKey; if (RegOpenKeyExW(hKeyCpuRoot, subKeyName, 0, KEY_QUERY_VALUE, &hCpuKey) == ERROR_SUCCESS) { CoreInfo cpuCore; if (swscanf_s(subKeyName, L"%i", &cpuCore.m_id) != 1) cpuCore.m_id = num - 1; wchar_t buf[300]; // more than enough DWORD bufSize = sizeof(buf); DWORD valType; if (RegQueryValueExW(hCpuKey, L"ProcessorNameString", NULL, &valType, (LPBYTE)buf, &bufSize) == ERROR_SUCCESS && valType == REG_SZ) { g_charsetConverter.wToUTF8(std::wstring(buf, bufSize / sizeof(wchar_t)), cpuCore.m_strModel); cpuCore.m_strModel = cpuCore.m_strModel.substr(0, cpuCore.m_strModel.find(char(0))); // remove extra null terminations StringUtils::RemoveDuplicatedSpacesAndTabs(cpuCore.m_strModel); StringUtils::Trim(cpuCore.m_strModel); } bufSize = sizeof(buf); if (RegQueryValueExW(hCpuKey, L"VendorIdentifier", NULL, &valType, (LPBYTE)buf, &bufSize) == ERROR_SUCCESS && valType == REG_SZ) { g_charsetConverter.wToUTF8(std::wstring(buf, bufSize / sizeof(wchar_t)), cpuCore.m_strVendor); cpuCore.m_strVendor = cpuCore.m_strVendor.substr(0, cpuCore.m_strVendor.find(char(0))); // remove extra null terminations } DWORD mhzVal; bufSize = sizeof(mhzVal); if (RegQueryValueExW(hCpuKey, L"~MHz", NULL, &valType, (LPBYTE)&mhzVal, &bufSize) == ERROR_SUCCESS && valType == REG_DWORD) cpuCore.m_fSpeed = double(mhzVal); RegCloseKey(hCpuKey); if (cpuCore.m_strModel.empty()) cpuCore.m_strModel = "Unknown"; cpuCores.push_back(cpuCore); } subKeyNameLen = sizeof(subKeyName) / sizeof(wchar_t); // restore length value } RegCloseKey(hKeyCpuRoot); std::sort(cpuCores.begin(), cpuCores.end()); // sort cores by id for (size_t i = 0; i < cpuCores.size(); i++) m_cores[i] = cpuCores[i]; // add in sorted order } if (!m_cores.empty()) m_cpuModel = m_cores.begin()->second.m_strModel; else m_cpuModel = "Unknown"; SYSTEM_INFO siSysInfo; GetNativeSystemInfo(&siSysInfo); m_cpuCount = siSysInfo.dwNumberOfProcessors; if (PdhOpenQueryW(NULL, 0, &m_cpuQueryFreq) == ERROR_SUCCESS) { if (PdhAddEnglishCounterW(m_cpuQueryFreq, L"\\Processor Information(0,0)\\Processor Frequency", 0, &m_cpuFreqCounter) != ERROR_SUCCESS) m_cpuFreqCounter = NULL; } else m_cpuQueryFreq = NULL; if (PdhOpenQueryW(NULL, 0, &m_cpuQueryLoad) == ERROR_SUCCESS) { for (size_t i = 0; i < m_cores.size(); i++) { if (PdhAddEnglishCounterW(m_cpuQueryLoad, StringUtils::Format(L"\\Processor(%d)\\%% Idle Time", int(i)).c_str(), 0, &m_cores[i].m_coreCounter) != ERROR_SUCCESS) m_cores[i].m_coreCounter = NULL; } } else m_cpuQueryLoad = NULL; #elif defined(TARGET_FREEBSD) size_t len; int i; char cpumodel[512]; len = sizeof(m_cpuCount); if (sysctlbyname("hw.ncpu", &m_cpuCount, &len, NULL, 0) != 0) m_cpuCount = 1; len = sizeof(cpumodel); if (sysctlbyname("hw.model", &cpumodel, &len, NULL, 0) != 0) (void)strncpy(cpumodel, "Unknown", 8); m_cpuModel = cpumodel; for (i = 0; i < m_cpuCount; i++) { CoreInfo core; core.m_id = i; core.m_strModel = m_cpuModel; m_cores[core.m_id] = core; } #else m_fProcStat = fopen("/proc/stat", "r"); m_fProcTemperature = fopen("/proc/acpi/thermal_zone/THM0/temperature", "r"); if (m_fProcTemperature == NULL) m_fProcTemperature = fopen("/proc/acpi/thermal_zone/THRM/temperature", "r"); if (m_fProcTemperature == NULL) m_fProcTemperature = fopen("/proc/acpi/thermal_zone/THR0/temperature", "r"); if (m_fProcTemperature == NULL) m_fProcTemperature = fopen("/proc/acpi/thermal_zone/TZ0/temperature", "r"); // read from the new location of the temperature data on new kernels, 2.6.39, 3.0 etc if (m_fProcTemperature == NULL) m_fProcTemperature = fopen("/sys/class/hwmon/hwmon0/temp1_input", "r"); if (m_fProcTemperature == NULL) m_fProcTemperature = fopen("/sys/class/thermal/thermal_zone0/temp", "r"); // On Raspberry PIs m_fCPUFreq = fopen ("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "r"); if (!m_fCPUFreq) { m_cpuInfoForFreq = true; m_fCPUFreq = fopen("/proc/cpuinfo", "r"); } else m_cpuInfoForFreq = false; FILE* fCPUInfo = fopen("/proc/cpuinfo", "r"); m_cpuCount = 0; if (fCPUInfo) { char buffer[512]; int nCurrId = 0; while (fgets(buffer, sizeof(buffer), fCPUInfo)) { if (strncmp(buffer, "processor", strlen("processor"))==0) { char *needle = strstr(buffer, ":"); if (needle) { CoreInfo core; core.m_id = atoi(needle+2); nCurrId = core.m_id; m_cores[core.m_id] = core; } m_cpuCount++; } else if (strncmp(buffer, "vendor_id", strlen("vendor_id"))==0) { char *needle = strstr(buffer, ":"); if (needle && strlen(needle)>3) { needle+=2; m_cores[nCurrId].m_strVendor = needle; StringUtils::Trim(m_cores[nCurrId].m_strVendor); } } else if (strncmp(buffer, "Processor", strlen("Processor"))==0) { char *needle = strstr(buffer, ":"); if (needle && strlen(needle)>3) { needle+=2; m_cpuModel = needle; m_cores[nCurrId].m_strModel = m_cpuModel; StringUtils::Trim(m_cores[nCurrId].m_strModel); } } else if (strncmp(buffer, "BogoMIPS", strlen("BogoMIPS"))==0) { char *needle = strstr(buffer, ":"); if (needle && strlen(needle)>3) { needle+=2; m_cpuBogoMips = needle; m_cores[nCurrId].m_strBogoMips = m_cpuBogoMips; StringUtils::Trim(m_cores[nCurrId].m_strBogoMips); } } else if (strncmp(buffer, "Hardware", strlen("Hardware"))==0) { char *needle = strstr(buffer, ":"); if (needle && strlen(needle)>3) { needle+=2; m_cpuHardware = needle; m_cores[nCurrId].m_strHardware = m_cpuHardware; StringUtils::Trim(m_cores[nCurrId].m_strHardware); } } else if (strncmp(buffer, "Revision", strlen("Revision"))==0) { char *needle = strstr(buffer, ":"); if (needle && strlen(needle)>3) { needle+=2; m_cpuRevision = needle; m_cores[nCurrId].m_strRevision = m_cpuRevision; StringUtils::Trim(m_cores[nCurrId].m_strRevision); } } else if (strncmp(buffer, "Serial", strlen("Serial"))==0) { char *needle = strstr(buffer, ":"); if (needle && strlen(needle)>3) { needle+=2; m_cpuSerial = needle; m_cores[nCurrId].m_strSerial = m_cpuSerial; StringUtils::Trim(m_cores[nCurrId].m_strSerial); } } else if (strncmp(buffer, "model name", strlen("model name"))==0) { char *needle = strstr(buffer, ":"); if (needle && strlen(needle)>3) { needle+=2; m_cpuModel = needle; m_cores[nCurrId].m_strModel = m_cpuModel; StringUtils::Trim(m_cores[nCurrId].m_strModel); } } else if (strncmp(buffer, "flags", 5) == 0) { char* needle = strchr(buffer, ':'); if (needle) { char* tok = NULL, * save; needle++; tok = strtok_r(needle, " ", &save); while (tok) { if (0 == strcmp(tok, "mmx")) m_cpuFeatures |= CPU_FEATURE_MMX; else if (0 == strcmp(tok, "mmxext")) m_cpuFeatures |= CPU_FEATURE_MMX2; else if (0 == strcmp(tok, "sse")) m_cpuFeatures |= CPU_FEATURE_SSE; else if (0 == strcmp(tok, "sse2")) m_cpuFeatures |= CPU_FEATURE_SSE2; else if (0 == strcmp(tok, "sse3")) m_cpuFeatures |= CPU_FEATURE_SSE3; else if (0 == strcmp(tok, "ssse3")) m_cpuFeatures |= CPU_FEATURE_SSSE3; else if (0 == strcmp(tok, "sse4_1")) m_cpuFeatures |= CPU_FEATURE_SSE4; else if (0 == strcmp(tok, "sse4_2")) m_cpuFeatures |= CPU_FEATURE_SSE42; else if (0 == strcmp(tok, "3dnow")) m_cpuFeatures |= CPU_FEATURE_3DNOW; else if (0 == strcmp(tok, "3dnowext")) m_cpuFeatures |= CPU_FEATURE_3DNOWEXT; tok = strtok_r(NULL, " ", &save); } } } } fclose(fCPUInfo); } else { m_cpuCount = 1; m_cpuModel = "Unknown"; } #endif StringUtils::Replace(m_cpuModel, '\r', ' '); StringUtils::Replace(m_cpuModel, '\n', ' '); StringUtils::RemoveDuplicatedSpacesAndTabs(m_cpuModel); StringUtils::Trim(m_cpuModel); /* Set some default for empty string variables */ if (m_cpuBogoMips.empty()) m_cpuBogoMips = "N/A"; if (m_cpuHardware.empty()) m_cpuHardware = "N/A"; if (m_cpuRevision.empty()) m_cpuRevision = "N/A"; if (m_cpuSerial.empty()) m_cpuSerial = "N/A"; readProcStat(m_userTicks, m_niceTicks, m_systemTicks, m_idleTicks, m_ioTicks); m_nextUsedReadTime.Set(MINIMUM_TIME_BETWEEN_READS); ReadCPUFeatures(); // Set MMX2 when SSE is present as SSE is a superset of MMX2 and Intel doesn't set the MMX2 cap if (m_cpuFeatures & CPU_FEATURE_SSE) m_cpuFeatures |= CPU_FEATURE_MMX2; if (HasNeon()) m_cpuFeatures |= CPU_FEATURE_NEON; }
int main(int argc, char *argv[]) { const char *cp, *tp; const char *sep; int op, i; u_int32_t debug, ndebug; size_t debuglen; char oid[256]; progname = argv[0]; setoid(oid, sizeof(oid), "wlan0"); if (argc > 1) { if (strcmp(argv[1], "-d") == 0) { setoid(oid, sizeof(oid), NULL); argc -= 1, argv += 1; } else if (strcmp(argv[1], "-i") == 0) { if (argc <= 2) errx(1, "missing interface name for -i option"); get_orig_iface_name(oid, sizeof(oid), argv[2]); argc -= 2, argv += 2; } else if (strcmp(argv[1], "-?") == 0) usage(); } debuglen = sizeof(debug); if (sysctlbyname(oid, &debug, &debuglen, NULL, 0) < 0) err(1, "sysctl-get(%s)", oid); ndebug = debug; for (; argc > 1; argc--, argv++) { cp = argv[1]; do { u_int bit; if (*cp == '-') { cp++; op = -1; } else if (*cp == '+') { cp++; op = 1; } else op = 0; for (tp = cp; *tp != '\0' && *tp != '+' && *tp != '-';) tp++; bit = getflag(cp, tp-cp); if (op < 0) ndebug &= ~bit; else if (op > 0) ndebug |= bit; else { if (bit == 0) { int c = *cp; if (isdigit(c)) bit = strtoul(cp, NULL, 0); else errx(1, "unknown flag %.*s", (int)(tp-cp), cp); } ndebug = bit; } } while (*(cp = tp) != '\0'); } if (debug != ndebug) { printf("%s: 0x%x => ", oid, debug); if (sysctlbyname(oid, NULL, NULL, &ndebug, sizeof(ndebug)) < 0) err(1, "sysctl-set(%s)", oid); printf("0x%x", ndebug); debug = ndebug; } else printf("%s: 0x%x", oid, debug); sep = "<"; for (i = 0; i < N(flags); i++) if (debug & flags[i].bit) { printf("%s%s", sep, flags[i].name); sep = ","; } printf("%s\n", *sep != '<' ? ">" : ""); return 0; }
/* * Load the latest memory usage statistics */ int netsnmp_mem_arch_load( netsnmp_cache *cache, void *magic ) { netsnmp_memory_info *mem; long pagesize; struct uvmexp uvmexp; size_t uvmexp_size = sizeof(uvmexp); struct vmtotal total; size_t total_size = sizeof(total); quad_t phys_mem; quad_t user_mem; size_t mem_size = sizeof(phys_mem); #if defined(openbsd) int phys_mem_mib[] = { CTL_HW, HW_PHYSMEM64 }; int user_mem_mib[] = { CTL_HW, HW_USERMEM64 }; int uvmexp_mib[] = { CTL_VM, VM_UVMEXP }; int total_mib[] = { CTL_VM, VM_METER }; #else unsigned int bufspace; unsigned int maxbufspace; size_t buf_size = sizeof(bufspace); #endif /* * Retrieve the memory information from the underlying O/S... */ #if defined(openbsd) sysctl(uvmexp_mib, 2, &uvmexp, &uvmexp_size, NULL, 0); sysctl(total_mib, 2, &total, &total_size, NULL, 0); sysctl(phys_mem_mib, 2, &phys_mem, &mem_size, NULL, 0); sysctl(user_mem_mib, 2, &user_mem, &mem_size, NULL, 0); #else if (sysctlbyname("vm.uvmexp", &uvmexp, &uvmexp_size, NULL, 0) == -1) { snmp_log(LOG_ERR, "sysctl vm.uvmexp failed (errno %d)\n", errno); return -1; } if (sysctlbyname("vm.vmmeter", &total, &total_size, NULL, 0) == -1) { snmp_log(LOG_ERR, "sysctl vm.vmmeter failed (errno %d)\n", errno); return -1; } if (sysctlbyname("hw.physmem64", &phys_mem, &mem_size, NULL, 0) == -1) { snmp_log(LOG_ERR, "sysctl hw.physmem64 failed (errno %d)\n", errno); return -1; } if (sysctlbyname("hw.usermem64", &user_mem, &mem_size, NULL, 0) == -1) { snmp_log(LOG_ERR, "sysctl hw.usermem64 failed (errno %d)\n", errno); return -1; } if (sysctlbyname("vm.bufmem", &bufspace, &buf_size, NULL, 0) == -1) { snmp_log(LOG_ERR, "sysctl vm.bufmem failed (errno %d)\n", errno); return -1; } if (sysctlbyname("vm.bufmem_hiwater", &maxbufspace, &buf_size, NULL, 0) == -1) { snmp_log(LOG_ERR, "sysctl vm.bufmem_hiwater failed (errno %d)\n", errno); return -1; } #endif pagesize = sysconf(_SC_PAGESIZE); /* * ... and save this in a standard form. */ mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_PHYSMEM, 1 ); if (!mem) { snmp_log_perror("No Physical Memory info entry"); } else { if (!mem->descr) mem->descr = strdup("Physical memory"); mem->units = pagesize; mem->size = phys_mem/pagesize; mem->free = total.t_free; } mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_USERMEM, 1 ); if (!mem) { snmp_log_perror("No (user) Memory info entry"); } else { if (!mem->descr) mem->descr = strdup("Real memory"); mem->units = pagesize; mem->size = user_mem/pagesize; mem->free = uvmexp.free; } #if 1 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_VIRTMEM, 1 ); if (!mem) { snmp_log_perror("No Virtual Memory info entry"); } else { if (!mem->descr) mem->descr = strdup("Virtual memory"); mem->units = pagesize; mem->size = total.t_vm; mem->free = total.t_avm; } mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SHARED, 1 ); if (!mem) { snmp_log_perror("No Shared Memory info entry"); } else { if (!mem->descr) mem->descr = strdup("Shared virtual memory"); mem->units = pagesize; mem->size = total.t_vmshr; mem->free = total.t_avmshr; } mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SHARED2, 1 ); if (!mem) { snmp_log_perror("No Shared2 Memory info entry"); } else { if (!mem->descr) mem->descr = strdup("Shared real memory"); mem->units = pagesize; mem->size = total.t_rmshr; mem->free = total.t_armshr; } #endif #ifdef SWAP_NSWAP swapinfo(pagesize); #endif mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SWAP, 1 ); if (!mem) { snmp_log_perror("No Swap info entry"); } else { if (!mem->descr) mem->descr = strdup("Swap space"); mem->units = pagesize; mem->size = uvmexp.swpages; mem->free = uvmexp.swpages - uvmexp.swpginuse; mem->other = -1; } #if defined(__NetBSD__) mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_MBUF, 1 ); if (!mem) { snmp_log_perror("No Buffer, etc info entry"); } else { if (!mem->descr) mem->descr = strdup("Memory buffers"); mem->units = 1024; mem->size = maxbufspace /1024; mem->size = (maxbufspace - bufspace)/1024; } #endif return 0; }
ngx_int_t ngx_os_specific_init(ngx_log_t *log) { int version, somaxconn; size_t size; ngx_err_t err; ngx_uint_t i; size = sizeof(ngx_freebsd_kern_ostype); if (sysctlbyname("kern.ostype", ngx_freebsd_kern_ostype, &size, NULL, 0) == -1) { ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "sysctlbyname(kern.ostype) failed"); if (ngx_errno != NGX_ENOMEM) { return NGX_ERROR; } ngx_freebsd_kern_ostype[size - 1] = '\0'; } size = sizeof(ngx_freebsd_kern_osrelease); if (sysctlbyname("kern.osrelease", ngx_freebsd_kern_osrelease, &size, NULL, 0) == -1) { ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "sysctlbyname(kern.osrelease) failed"); if (ngx_errno != NGX_ENOMEM) { return NGX_ERROR; } ngx_freebsd_kern_osrelease[size - 1] = '\0'; } size = sizeof(int); if (sysctlbyname("kern.osreldate", &ngx_freebsd_kern_osreldate, &size, NULL, 0) == -1) { ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "sysctlbyname(kern.osreldate) failed"); return NGX_ERROR; } version = ngx_freebsd_kern_osreldate; #if (NGX_HAVE_SENDFILE) /* * The determination of the sendfile() "nbytes bug" is complex enough. * There are two sendfile() syscalls: a new #393 has no bug while * an old #336 has the bug in some versions and has not in others. * Besides libc_r wrapper also emulates the bug in some versions. * There is no way to say exactly if syscall #336 in FreeBSD circa 4.6 * has the bug. We use the algorithm that is correct at least for * RELEASEs and for syscalls only (not libc_r wrapper). * * 4.6.1-RELEASE and below have the bug * 4.6.2-RELEASE and above have the new syscall * * We detect the new sendfile() syscall available at the compile time * to allow an old binary to run correctly on an updated FreeBSD system. */ #if (__FreeBSD__ == 4 && __FreeBSD_version >= 460102) \ || __FreeBSD_version == 460002 || __FreeBSD_version >= 500039 /* a new syscall without the bug */ ngx_freebsd_sendfile_nbytes_bug = 0; #else /* an old syscall that may have the bug */ ngx_freebsd_sendfile_nbytes_bug = 1; #endif #endif /* NGX_HAVE_SENDFILE */ if ((version < 500000 && version >= 440003) || version >= 500017) { ngx_freebsd_use_tcp_nopush = 1; } for (i = 0; sysctls[i].name; i++) { size = sysctls[i].size; if (sysctlbyname(sysctls[i].name, sysctls[i].value, &size, NULL, 0) == 0) { sysctls[i].exists = 1; continue; } err = ngx_errno; if (err == NGX_ENOENT) { continue; } ngx_log_error(NGX_LOG_ALERT, log, err, "sysctlbyname(%s) failed", sysctls[i].name); return NGX_ERROR; } if (ngx_freebsd_machdep_hlt_logical_cpus) { ngx_ncpu = ngx_freebsd_hw_ncpu / 2; } else { ngx_ncpu = ngx_freebsd_hw_ncpu; } somaxconn = version < 600008 ? 32676 : 65535; if (ngx_freebsd_kern_ipc_somaxconn > somaxconn) { ngx_log_error(NGX_LOG_ALERT, log, 0, "sysctl kern.ipc.somaxconn must be no more than %d", somaxconn); return NGX_ERROR; } ngx_tcp_nodelay_and_tcp_nopush = 1; ngx_os_io = ngx_freebsd_io; return NGX_OK; }
/** * Check if SSE is supported. * If not, turn off the X86_FEATURE_XMM flag in _mesa_x86_cpu_features. */ void _mesa_check_os_sse_support( void ) { #if defined(__FreeBSD__) { int ret, enabled; unsigned int len; len = sizeof(enabled); ret = sysctlbyname("hw.instruction_sse", &enabled, &len, NULL, 0); if (ret || !enabled) _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM); } #elif defined (__NetBSD__) { int ret, enabled; size_t len = sizeof(enabled); ret = sysctlbyname("machdep.sse", &enabled, &len, (void *)NULL, 0); if (ret || !enabled) _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM); } #elif defined(__OpenBSD__) { int mib[2]; int ret, enabled; size_t len = sizeof(enabled); mib[0] = CTL_MACHDEP; mib[1] = CPU_SSE; ret = sysctl(mib, 2, &enabled, &len, NULL, 0); if (ret || !enabled) _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM); } #elif defined(_WIN32) LPTOP_LEVEL_EXCEPTION_FILTER oldFilter; /* Install our ExceptionFilter */ oldFilter = SetUnhandledExceptionFilter( ExceptionFilter ); if ( cpu_has_xmm ) { _mesa_debug(NULL, "Testing OS support for SSE...\n"); _mesa_test_os_sse_support(); if ( cpu_has_xmm ) { _mesa_debug(NULL, "Yes.\n"); } else { _mesa_debug(NULL, "No!\n"); } } if ( cpu_has_xmm ) { _mesa_debug(NULL, "Testing OS support for SSE unmasked exceptions...\n"); _mesa_test_os_sse_exception_support(); if ( cpu_has_xmm ) { _mesa_debug(NULL, "Yes.\n"); } else { _mesa_debug(NULL, "No!\n"); } } /* Restore previous exception filter */ SetUnhandledExceptionFilter( oldFilter ); if ( cpu_has_xmm ) { _mesa_debug(NULL, "Tests of OS support for SSE passed.\n"); } else { _mesa_debug(NULL, "Tests of OS support for SSE failed!\n"); } #else /* Do nothing on other platforms for now. */ if (detection_debug) _mesa_debug(NULL, "Not testing OS support for SSE, leaving enabled.\n"); #endif /* __FreeBSD__ */ }
void GlobalMemoryStatusEx(LPMEMORYSTATUSEX lpBuffer) { if (!lpBuffer) return; memset(lpBuffer, 0, sizeof(MEMORYSTATUSEX)); lpBuffer->dwLength = sizeof(MEMORYSTATUSEX); #ifdef __APPLE__ uint64_t physmem; size_t len = sizeof physmem; int mib[2] = { CTL_HW, HW_MEMSIZE }; size_t miblen = sizeof(mib) / sizeof(mib[0]); // Total physical memory. if (sysctl(mib, miblen, &physmem, &len, NULL, 0) == 0 && len == sizeof (physmem)) lpBuffer->ullTotalPhys = physmem; // Virtual memory. mib[0] = CTL_VM; mib[1] = VM_SWAPUSAGE; struct xsw_usage swap; len = sizeof(struct xsw_usage); if (sysctl(mib, miblen, &swap, &len, NULL, 0) == 0) { lpBuffer->ullAvailPageFile = swap.xsu_avail; lpBuffer->ullTotalVirtual = lpBuffer->ullTotalPhys + swap.xsu_total; } // In use. mach_port_t stat_port = mach_host_self(); vm_statistics_data_t vm_stat; mach_msg_type_number_t count = sizeof(vm_stat) / sizeof(natural_t); if (host_statistics(stat_port, HOST_VM_INFO, (host_info_t)&vm_stat, &count) == 0) { // Find page size. int pageSize; mib[0] = CTL_HW; mib[1] = HW_PAGESIZE; len = sizeof(int); if (sysctl(mib, miblen, &pageSize, &len, NULL, 0) == 0) { uint64_t used = (vm_stat.active_count + vm_stat.inactive_count + vm_stat.wire_count) * pageSize; lpBuffer->ullAvailPhys = lpBuffer->ullTotalPhys - used; lpBuffer->ullAvailVirtual = lpBuffer->ullAvailPhys; // FIXME. } } #elif defined(__FreeBSD__) /* sysctl hw.physmem */ size_t physmem = 0, mem_free = 0, pagesize = 0, swap_free = 0; size_t mem_avail = 0, mem_inactive = 0, mem_cache = 0, len = 0; /* physmem */ len = sizeof(physmem); if (sysctlbyname("hw.physmem", &physmem, &len, NULL, 0) == 0) { lpBuffer->ullTotalPhys = physmem; lpBuffer->ullTotalVirtual = physmem; } /* pagesize */ len = sizeof(pagesize); if (sysctlbyname("hw.pagesize", &pagesize, &len, NULL, 0) != 0) pagesize = 4096; /* mem_inactive */ len = sizeof(mem_inactive); if (sysctlbyname("vm.stats.vm.v_inactive_count", &mem_inactive, &len, NULL, 0) == 0) mem_inactive *= pagesize; /* mem_cache */ len = sizeof(mem_cache); if (sysctlbyname("vm.stats.vm.v_cache_count", &mem_cache, &len, NULL, 0) == 0) mem_cache *= pagesize; /* mem_free */ len = sizeof(mem_free); if (sysctlbyname("vm.stats.vm.v_free_count", &mem_free, &len, NULL, 0) == 0) mem_free *= pagesize; /* mem_avail = mem_inactive + mem_cache + mem_free */ lpBuffer->ullAvailPhys = mem_inactive + mem_cache + mem_free; lpBuffer->ullAvailVirtual = mem_inactive + mem_cache + mem_free; if (sysctlbyname("vm.stats.vm.v_swappgsout", &swap_free, &len, NULL, 0) == 0) lpBuffer->ullAvailPageFile = swap_free * pagesize; #else struct sysinfo info; char name[32]; unsigned val; if (!procMeminfoFP && (procMeminfoFP = fopen("/proc/meminfo", "r")) == NULL) sysinfo(&info); else { memset(&info, 0, sizeof(struct sysinfo)); info.mem_unit = 4096; while (fscanf(procMeminfoFP, "%31s %u%*[^\n]\n", name, &val) != EOF) { if (strncmp("MemTotal:", name, 9) == 0) info.totalram = val/4; else if (strncmp("MemFree:", name, 8) == 0) info.freeram = val/4; else if (strncmp("Buffers:", name, 8) == 0) info.bufferram += val/4; else if (strncmp("Cached:", name, 7) == 0) info.bufferram += val/4; else if (strncmp("SwapTotal:", name, 10) == 0) info.totalswap = val/4; else if (strncmp("SwapFree:", name, 9) == 0) info.freeswap = val/4; else if (strncmp("HighTotal:", name, 10) == 0) info.totalhigh = val/4; else if (strncmp("HighFree:", name, 9) == 0) info.freehigh = val/4; } rewind(procMeminfoFP); fflush(procMeminfoFP); } lpBuffer->dwLength = sizeof(MEMORYSTATUSEX); lpBuffer->ullAvailPageFile = (info.freeswap * info.mem_unit); lpBuffer->ullAvailPhys = ((info.freeram + info.bufferram) * info.mem_unit); lpBuffer->ullAvailVirtual = ((info.freeram + info.bufferram) * info.mem_unit); lpBuffer->ullTotalPhys = (info.totalram * info.mem_unit); lpBuffer->ullTotalVirtual = (info.totalram * info.mem_unit); #endif }
static int hwloc_look_darwin(struct hwloc_backend *backend) { struct hwloc_topology *topology = backend->topology; int64_t _nprocs; unsigned nprocs; int64_t _npackages; unsigned i, j, cpu; struct hwloc_obj *obj; size_t size; int64_t l1dcachesize, l1icachesize; int64_t cacheways[2]; int64_t l2cachesize; int64_t cachelinesize; int64_t memsize; char cpumodel[64]; if (topology->levels[0][0]->cpuset) /* somebody discovered things */ return 0; hwloc_alloc_obj_cpusets(topology->levels[0][0]); if (hwloc_get_sysctlbyname("hw.ncpu", &_nprocs) || _nprocs <= 0) return -1; nprocs = _nprocs; topology->support.discovery->pu = 1; hwloc_debug("%u procs\n", nprocs); size = sizeof(cpumodel); if (sysctlbyname("machdep.cpu.brand_string", cpumodel, &size, NULL, 0)) cpumodel[0] = '\0'; if (!hwloc_get_sysctlbyname("hw.packages", &_npackages) && _npackages > 0) { unsigned npackages = _npackages; int64_t _cores_per_package; int64_t _logical_per_package; unsigned logical_per_package; hwloc_debug("%u packages\n", npackages); if (!hwloc_get_sysctlbyname("machdep.cpu.logical_per_package", &_logical_per_package) && _logical_per_package > 0) logical_per_package = _logical_per_package; else /* Assume the trivia. */ logical_per_package = nprocs / npackages; hwloc_debug("%u threads per package\n", logical_per_package); if (nprocs == npackages * logical_per_package) for (i = 0; i < npackages; i++) { obj = hwloc_alloc_setup_object(HWLOC_OBJ_SOCKET, i); obj->cpuset = hwloc_bitmap_alloc(); for (cpu = i*logical_per_package; cpu < (i+1)*logical_per_package; cpu++) hwloc_bitmap_set(obj->cpuset, cpu); hwloc_debug_1arg_bitmap("package %u has cpuset %s\n", i, obj->cpuset); if (cpumodel[0] != '\0') hwloc_obj_add_info(obj, "CPUModel", cpumodel); hwloc_insert_object_by_cpuset(topology, obj); } else if (cpumodel[0] != '\0') hwloc_obj_add_info(topology->levels[0][0], "CPUModel", cpumodel); if (!hwloc_get_sysctlbyname("machdep.cpu.cores_per_package", &_cores_per_package) && _cores_per_package > 0) { unsigned cores_per_package = _cores_per_package; hwloc_debug("%u cores per package\n", cores_per_package); if (!(logical_per_package % cores_per_package)) for (i = 0; i < npackages * cores_per_package; i++) { obj = hwloc_alloc_setup_object(HWLOC_OBJ_CORE, i); obj->cpuset = hwloc_bitmap_alloc(); for (cpu = i*(logical_per_package/cores_per_package); cpu < (i+1)*(logical_per_package/cores_per_package); cpu++) hwloc_bitmap_set(obj->cpuset, cpu); hwloc_debug_1arg_bitmap("core %u has cpuset %s\n", i, obj->cpuset); hwloc_insert_object_by_cpuset(topology, obj); } } } else if (cpumodel[0] != '\0') hwloc_obj_add_info(topology->levels[0][0], "CPUModel", cpumodel); if (hwloc_get_sysctlbyname("hw.l1dcachesize", &l1dcachesize)) l1dcachesize = 0; if (hwloc_get_sysctlbyname("hw.l1icachesize", &l1icachesize)) l1icachesize = 0; if (hwloc_get_sysctlbyname("hw.l2cachesize", &l2cachesize)) l2cachesize = 0; if (hwloc_get_sysctlbyname("machdep.cpu.cache.L1_associativity", &cacheways[0])) cacheways[0] = 0; else if (cacheways[0] == 0xff) cacheways[0] = -1; if (hwloc_get_sysctlbyname("machdep.cpu.cache.L2_associativity", &cacheways[1])) cacheways[1] = 0; else if (cacheways[1] == 0xff) cacheways[1] = -1; if (hwloc_get_sysctlbyname("hw.cachelinesize", &cachelinesize)) cachelinesize = 0; if (hwloc_get_sysctlbyname("hw.memsize", &memsize)) memsize = 0; if (!sysctlbyname("hw.cacheconfig", NULL, &size, NULL, 0)) { unsigned n = size / sizeof(uint32_t); uint64_t *cacheconfig = NULL; uint64_t *cachesize = NULL; uint32_t *cacheconfig32 = NULL; cacheconfig = malloc(sizeof(uint64_t) * n); if (NULL == cacheconfig) { goto out; } cachesize = malloc(sizeof(uint64_t) * n); if (NULL == cachesize) { goto out; } cacheconfig32 = malloc(sizeof(uint32_t) * n); if (NULL == cacheconfig32) { goto out; } if ((!sysctlbyname("hw.cacheconfig", cacheconfig, &size, NULL, 0))) { /* Yeech. Darwin seemingly has changed from 32bit to 64bit integers for * cacheconfig, with apparently no way for detection. Assume the machine * won't have more than 4 billion cpus */ if (cacheconfig[0] > 0xFFFFFFFFUL) { memcpy(cacheconfig32, cacheconfig, size); for (i = 0 ; i < size / sizeof(uint32_t); i++) cacheconfig[i] = cacheconfig32[i]; } memset(cachesize, 0, sizeof(uint64_t) * n); size = sizeof(uint64_t) * n; if (sysctlbyname("hw.cachesize", cachesize, &size, NULL, 0)) { if (n > 0) cachesize[0] = memsize; if (n > 1) cachesize[1] = l1dcachesize; if (n > 2) cachesize[2] = l2cachesize; } hwloc_debug("%s", "caches"); for (i = 0; i < n && cacheconfig[i]; i++) hwloc_debug(" %"PRIu64"(%"PRIu64"kB)", cacheconfig[i], cachesize[i] / 1024); cacheconfig[i] = cacheconfig32[i]; /* Now we know how many caches there are */ n = i; hwloc_debug("\n%u cache levels\n", n - 1); /* For each cache level (0 is memory) */ for (i = 0; i < n; i++) { /* cacheconfig tells us how many cpus share it, let's iterate on each cache */ for (j = 0; j < (nprocs / cacheconfig[i]); j++) { obj = hwloc_alloc_setup_object(i?HWLOC_OBJ_CACHE:HWLOC_OBJ_NODE, j); if (!i) { obj->nodeset = hwloc_bitmap_alloc(); hwloc_bitmap_set(obj->nodeset, j); } obj->cpuset = hwloc_bitmap_alloc(); for (cpu = j*cacheconfig[i]; cpu < ((j+1)*cacheconfig[i]); cpu++) hwloc_bitmap_set(obj->cpuset, cpu); if (i == 1 && l1icachesize) { /* FIXME assuming that L1i and L1d are shared the same way. Darwin * does not yet provide a way to know. */ hwloc_obj_t l1i = hwloc_alloc_setup_object(HWLOC_OBJ_CACHE, j); l1i->cpuset = hwloc_bitmap_dup(obj->cpuset); hwloc_debug_1arg_bitmap("L1icache %u has cpuset %s\n", j, l1i->cpuset); l1i->attr->cache.depth = i; l1i->attr->cache.size = l1icachesize; l1i->attr->cache.linesize = cachelinesize; l1i->attr->cache.associativity = 0; l1i->attr->cache.type = HWLOC_OBJ_CACHE_INSTRUCTION; hwloc_insert_object_by_cpuset(topology, l1i); } if (i) { hwloc_debug_2args_bitmap("L%ucache %u has cpuset %s\n", i, j, obj->cpuset); obj->attr->cache.depth = i; obj->attr->cache.size = cachesize[i]; obj->attr->cache.linesize = cachelinesize; if (i <= sizeof(cacheways) / sizeof(cacheways[0])) obj->attr->cache.associativity = cacheways[i-1]; else obj->attr->cache.associativity = 0; if (i == 1 && l1icachesize) obj->attr->cache.type = HWLOC_OBJ_CACHE_DATA; else obj->attr->cache.type = HWLOC_OBJ_CACHE_UNIFIED; } else { hwloc_debug_1arg_bitmap("node %u has cpuset %s\n", j, obj->cpuset); obj->memory.local_memory = cachesize[i]; obj->memory.page_types_len = 2; obj->memory.page_types = malloc(2*sizeof(*obj->memory.page_types)); memset(obj->memory.page_types, 0, 2*sizeof(*obj->memory.page_types)); obj->memory.page_types[0].size = getpagesize(); #ifdef HAVE__SC_LARGE_PAGESIZE obj->memory.page_types[1].size = sysconf(_SC_LARGE_PAGESIZE); #endif } hwloc_insert_object_by_cpuset(topology, obj); } } } out: if (NULL != cacheconfig) { free(cacheconfig); } if (NULL != cachesize) { free(cachesize); } if (NULL != cacheconfig32) { free(cacheconfig32); } } /* add PU objects */ hwloc_setup_pu_level(topology, nprocs); hwloc_obj_add_info(topology->levels[0][0], "Backend", "Darwin"); if (topology->is_thissystem) hwloc_add_uname_info(topology); return 1; }
// find arch const char * sysapi_translate_arch( const char *machine, const char *) { char tmp[64]; char *tmparch; #if defined(AIX) /* AIX machines have a ton of different models encoded into the uname structure, so go to some other function to decode and group the architecture together */ struct utsname buf; if( uname(&buf) < 0 ) { return NULL; } return( get_aix_arch( &buf ) ); #elif defined(HPUX) return( get_hpux_arch( ) ); #else // Get ARCH //mikeu: I modified this to also accept values from Globus' LDAP server if( !strcmp(machine, "alpha") ) { sprintf( tmp, "ALPHA" ); } else if( !strcmp(machine, "i86pc") ) { sprintf( tmp, "INTEL" ); } else if( !strcmp(machine, "i686") ) { sprintf( tmp, "INTEL" ); } else if( !strcmp(machine, "i586") ) { sprintf( tmp, "INTEL" ); } else if( !strcmp(machine, "i486") ) { sprintf( tmp, "INTEL" ); } else if( !strcmp(machine, "i386") ) { //LDAP entry #if defined(Darwin) /* Mac OS X often claims to be i386 in uname, even if the * hardware is x86_64 and the OS can run 64-bit binaries. * We'll base our architecture name on the default build * target for gcc. In 10.5 and earlier, that's i386. * On 10.6, it's x86_64. * The value we're querying is the kernel version. * 10.6 kernels have a version that starts with "10." * Older versions have a lower first number. */ int ret; char val[32]; size_t len = sizeof(val); /* assume x86 */ sprintf( tmp, "INTEL" ); ret = sysctlbyname("kern.osrelease", &val, &len, NULL, 0); if (ret == 0 && strncmp(val, "10.", 3) == 0) { /* but we could be proven wrong */ sprintf( tmp, "X86_64" ); } #else sprintf( tmp, "INTEL" ); #endif } else if( !strcmp(machine, "ia64") ) { sprintf( tmp, "IA64" ); } else if( !strcmp(machine, "x86_64") ) { sprintf( tmp, "X86_64" ); } // // FreeBSD 64-bit reports themselves as "amd64" // Andy - 01/25/2008 // else if( !strcmp(machine, "amd64") ) { sprintf( tmp, "X86_64" ); } else if( !strcmp(machine, "sun4u") ) { sprintf( tmp, "SUN4u" ); } else if( !strcmp(machine, "sun4m") ) { sprintf( tmp, "SUN4x" ); } else if( !strcmp(machine, "sun4c") ) { sprintf( tmp, "SUN4x" ); } else if( !strcmp(machine, "sparc") ) { //LDAP entry sprintf( tmp, "SUN4x" ); } else if( !strcmp(machine, "Power Macintosh") ) { //LDAP entry sprintf( tmp, "PPC" ); } else if( !strcmp(machine, "ppc") ) { sprintf( tmp, "PPC" ); } else if( !strcmp(machine, "ppc32") ) { sprintf( tmp, "PPC" ); } else if( !strcmp(machine, "ppc64") ) { sprintf( tmp, "PPC64" ); } else { // Unknown, just use what uname gave: sprintf( tmp, "%s", machine ); } tmparch = strdup( tmp ); if( !tmparch ) { EXCEPT( "Out of memory!" ); } return( tmparch ); #endif /* if HPUX else */ }
static void init_private(void) { struct rlimit rlim; size_t len; int mib[2]; char *env, *env_bigstack, *env_splitstack; _thr_umutex_init(&_mutex_static_lock); _thr_umutex_init(&_cond_static_lock); _thr_umutex_init(&_rwlock_static_lock); _thr_umutex_init(&_keytable_lock); _thr_urwlock_init(&_thr_atfork_lock); _thr_umutex_init(&_thr_event_lock); _thr_umutex_init(&_suspend_all_lock); _thr_spinlock_init(); _thr_list_init(); _thr_wake_addr_init(); _sleepq_init(); _single_thread = NULL; _suspend_all_waiters = 0; /* * Avoid reinitializing some things if they don't need to be, * e.g. after a fork(). */ if (init_once == 0) { __thr_pshared_init(); /* Find the stack top */ mib[0] = CTL_KERN; mib[1] = KERN_USRSTACK; len = sizeof (_usrstack); if (sysctl(mib, 2, &_usrstack, &len, NULL, 0) == -1) PANIC("Cannot get kern.usrstack from sysctl"); env_bigstack = getenv("LIBPTHREAD_BIGSTACK_MAIN"); env_splitstack = getenv("LIBPTHREAD_SPLITSTACK_MAIN"); if (env_bigstack != NULL || env_splitstack == NULL) { if (getrlimit(RLIMIT_STACK, &rlim) == -1) PANIC("Cannot get stack rlimit"); _thr_stack_initial = rlim.rlim_cur; } len = sizeof(_thr_is_smp); sysctlbyname("kern.smp.cpus", &_thr_is_smp, &len, NULL, 0); _thr_is_smp = (_thr_is_smp > 1); _thr_page_size = getpagesize(); _thr_guard_default = _thr_page_size; _pthread_attr_default.guardsize_attr = _thr_guard_default; _pthread_attr_default.stacksize_attr = _thr_stack_default; env = getenv("LIBPTHREAD_SPINLOOPS"); if (env) _thr_spinloops = atoi(env); env = getenv("LIBPTHREAD_YIELDLOOPS"); if (env) _thr_yieldloops = atoi(env); env = getenv("LIBPTHREAD_QUEUE_FIFO"); if (env) _thr_queuefifo = atoi(env); TAILQ_INIT(&_thr_atfork_list); } init_once = 1; }
int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK), multiplier = ((uint64_t)1000L / ticks), cpuspeed, maxcpus, cur = 0; uv_cpu_info_t* cpu_info; const char* maxcpus_key; const char* cptimes_key; char model[512]; long* cp_times; int numcpus; size_t size; int i; #if defined(__DragonFly__) /* This is not quite correct but DragonFlyBSD doesn't seem to have anything * comparable to kern.smp.maxcpus or kern.cp_times (kern.cp_time is a total, * not per CPU). At least this stops uv_cpu_info() from failing completely. */ maxcpus_key = "hw.ncpu"; cptimes_key = "kern.cp_time"; #else maxcpus_key = "kern.smp.maxcpus"; cptimes_key = "kern.cp_times"; #endif size = sizeof(model); if (sysctlbyname("hw.model", &model, &size, NULL, 0)) return -errno; size = sizeof(numcpus); if (sysctlbyname("hw.ncpu", &numcpus, &size, NULL, 0)) return -errno; *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos)); if (!(*cpu_infos)) return -ENOMEM; *count = numcpus; size = sizeof(cpuspeed); if (sysctlbyname("hw.clockrate", &cpuspeed, &size, NULL, 0)) { SAVE_ERRNO(uv__free(*cpu_infos)); return -errno; } /* kern.cp_times on FreeBSD i386 gives an array up to maxcpus instead of * ncpu. */ size = sizeof(maxcpus); if (sysctlbyname(maxcpus_key, &maxcpus, &size, NULL, 0)) { SAVE_ERRNO(uv__free(*cpu_infos)); return -errno; } size = maxcpus * CPUSTATES * sizeof(long); cp_times = uv__malloc(size); if (cp_times == NULL) { uv__free(*cpu_infos); return -ENOMEM; } if (sysctlbyname(cptimes_key, cp_times, &size, NULL, 0)) { SAVE_ERRNO(uv__free(cp_times)); SAVE_ERRNO(uv__free(*cpu_infos)); return -errno; } for (i = 0; i < numcpus; i++) { cpu_info = &(*cpu_infos)[i]; cpu_info->cpu_times.user = (uint64_t)(cp_times[CP_USER+cur]) * multiplier; cpu_info->cpu_times.nice = (uint64_t)(cp_times[CP_NICE+cur]) * multiplier; cpu_info->cpu_times.sys = (uint64_t)(cp_times[CP_SYS+cur]) * multiplier; cpu_info->cpu_times.idle = (uint64_t)(cp_times[CP_IDLE+cur]) * multiplier; cpu_info->cpu_times.irq = (uint64_t)(cp_times[CP_INTR+cur]) * multiplier; cpu_info->model = uv__strdup(model); cpu_info->speed = cpuspeed; cur+=CPUSTATES; } uv__free(cp_times); return 0; }
void hwloc_look_darwin(struct hwloc_topology *topology) { int64_t _nprocs; unsigned nprocs; int64_t _npackages; unsigned i, j, cpu; struct hwloc_obj *obj; size_t size; int64_t l1cachesize; int64_t l2cachesize; int64_t cachelinesize; int64_t memsize; if (hwloc_get_sysctlbyname("hw.ncpu", &_nprocs) || _nprocs <= 0) return; nprocs = _nprocs; topology->support.discovery->pu = 1; hwloc_debug("%u procs\n", nprocs); if (!hwloc_get_sysctlbyname("hw.packages", &_npackages) && _npackages > 0) { unsigned npackages = _npackages; int64_t _cores_per_package; int64_t _logical_per_package; unsigned logical_per_package; hwloc_debug("%u packages\n", npackages); if (!hwloc_get_sysctlbyname("machdep.cpu.logical_per_package", &_logical_per_package) && _logical_per_package > 0) logical_per_package = _logical_per_package; else /* Assume the trivia. */ logical_per_package = nprocs / npackages; hwloc_debug("%u threads per package\n", logical_per_package); if (nprocs == npackages * logical_per_package) for (i = 0; i < npackages; i++) { obj = hwloc_alloc_setup_object(HWLOC_OBJ_SOCKET, i); obj->cpuset = hwloc_bitmap_alloc(); for (cpu = i*logical_per_package; cpu < (i+1)*logical_per_package; cpu++) hwloc_bitmap_set(obj->cpuset, cpu); hwloc_debug_1arg_bitmap("package %u has cpuset %s\n", i, obj->cpuset); hwloc_insert_object_by_cpuset(topology, obj); } if (!hwloc_get_sysctlbyname("machdep.cpu.cores_per_package", &_cores_per_package) && _cores_per_package > 0) { unsigned cores_per_package = _cores_per_package; hwloc_debug("%u cores per package\n", cores_per_package); if (!(logical_per_package % cores_per_package)) for (i = 0; i < npackages * cores_per_package; i++) { obj = hwloc_alloc_setup_object(HWLOC_OBJ_CORE, i); obj->cpuset = hwloc_bitmap_alloc(); for (cpu = i*(logical_per_package/cores_per_package); cpu < (i+1)*(logical_per_package/cores_per_package); cpu++) hwloc_bitmap_set(obj->cpuset, cpu); hwloc_debug_1arg_bitmap("core %u has cpuset %s\n", i, obj->cpuset); hwloc_insert_object_by_cpuset(topology, obj); } } } if (hwloc_get_sysctlbyname("hw.l1dcachesize", &l1cachesize)) l1cachesize = 0; if (hwloc_get_sysctlbyname("hw.l2cachesize", &l2cachesize)) l2cachesize = 0; if (hwloc_get_sysctlbyname("hw.cachelinesize", &cachelinesize)) cachelinesize = 0; if (hwloc_get_sysctlbyname("hw.memsize", &memsize)) memsize = 0; if (!sysctlbyname("hw.cacheconfig", NULL, &size, NULL, 0)) { unsigned n = size / sizeof(uint32_t); uint64_t *cacheconfig = NULL; uint64_t *cachesize = NULL; uint32_t *cacheconfig32 = NULL; cacheconfig = malloc(sizeof(uint64_t) * n); if (NULL == cacheconfig) { goto out; } cachesize = malloc(sizeof(uint64_t) * n); if (NULL == cachesize) { goto out; } cacheconfig32 = malloc(sizeof(uint32_t) * n); if (NULL == cacheconfig32) { goto out; } if ((!sysctlbyname("hw.cacheconfig", cacheconfig, &size, NULL, 0))) { /* Yeech. Darwin seemingly has changed from 32bit to 64bit integers for * cacheconfig, with apparently no way for detection. Assume the machine * won't have more than 4 billion cpus */ if (cacheconfig[0] > 0xFFFFFFFFUL) { memcpy(cacheconfig32, cacheconfig, size); for (i = 0 ; i < size / sizeof(uint32_t); i++) cacheconfig[i] = cacheconfig32[i]; } memset(cachesize, 0, sizeof(uint64_t) * n); size = sizeof(uint64_t) * n; if (sysctlbyname("hw.cachesize", cachesize, &size, NULL, 0)) { if (n > 0) cachesize[0] = memsize; if (n > 1) cachesize[1] = l1cachesize; if (n > 2) cachesize[2] = l2cachesize; } hwloc_debug("%s", "caches"); for (i = 0; i < n && cacheconfig[i]; i++) hwloc_debug(" %"PRIu64"(%"PRIu64"kB)", cacheconfig[i], cachesize[i] / 1024); cacheconfig[i] = cacheconfig32[i]; /* Now we know how many caches there are */ n = i; hwloc_debug("\n%u cache levels\n", n - 1); /* For each cache level (0 is memory) */ for (i = 0; i < n; i++) { /* cacheconfig tells us how many cpus share it, let's iterate on each cache */ for (j = 0; j < (nprocs / cacheconfig[i]); j++) { obj = hwloc_alloc_setup_object(i?HWLOC_OBJ_CACHE:HWLOC_OBJ_NODE, j); if (!i) { obj->nodeset = hwloc_bitmap_alloc(); hwloc_bitmap_set(obj->nodeset, j); } obj->cpuset = hwloc_bitmap_alloc(); for (cpu = j*cacheconfig[i]; cpu < ((j+1)*cacheconfig[i]); cpu++) hwloc_bitmap_set(obj->cpuset, cpu); if (i) { hwloc_debug_2args_bitmap("L%ucache %u has cpuset %s\n", i, j, obj->cpuset); obj->attr->cache.depth = i; obj->attr->cache.size = cachesize[i]; obj->attr->cache.linesize = cachelinesize; } else { hwloc_debug_1arg_bitmap("node %u has cpuset %s\n", j, obj->cpuset); obj->memory.local_memory = cachesize[i]; obj->memory.page_types_len = 2; obj->memory.page_types = malloc(2*sizeof(*obj->memory.page_types)); memset(obj->memory.page_types, 0, 2*sizeof(*obj->memory.page_types)); obj->memory.page_types[0].size = getpagesize(); #ifdef HAVE__SC_LARGE_PAGESIZE obj->memory.page_types[1].size = sysconf(_SC_LARGE_PAGESIZE); #endif } hwloc_insert_object_by_cpuset(topology, obj); } } } out: if (NULL != cacheconfig) { free(cacheconfig); } if (NULL != cachesize) { free(cachesize); } if (NULL != cacheconfig32) { free(cacheconfig32); } } /* add PU objects */ hwloc_setup_pu_level(topology, nprocs); hwloc_add_object_info(topology->levels[0][0], "Backend", "Darwin"); }
/* * Called with the arguments, including program name because getopt * wants it to be present. * Returns 0 if successful, 1 if empty command, errx() in case of errors. * First thing we do is process parameters creating an argv[] array * which includes the program name and a NULL entry at the end. * If we are called with a single string, we split it on whitespace. * Also, arguments with a trailing ',' are joined to the next one. * The pointers (av[]) and data are in a single chunk of memory. * av[0] points to the original program name, all other entries * point into the allocated chunk. */ static int ipfw_main(int oldac, char **oldav) { int ch, ac; const char *errstr; char **av, **save_av; int do_acct = 0; /* Show packet/byte count */ int try_next = 0; /* set if pipe cmd not found */ int av_size; /* compute the av size */ char *av_p; /* used to build the av list */ #define WHITESP " \t\f\v\n\r" if (oldac < 2) return 1; /* need at least one argument */ if (oldac == 2) { /* * If we are called with one argument, try to split it into * words for subsequent parsing. Spaces after a ',' are * removed by copying the string in-place. */ char *arg = oldav[1]; /* The string is the first arg. */ int l = strlen(arg); int copy = 0; /* 1 if we need to copy, 0 otherwise */ int i, j; for (i = j = 0; i < l; i++) { if (arg[i] == '#') /* comment marker */ break; if (copy) { arg[j++] = arg[i]; copy = !strchr("," WHITESP, arg[i]); } else { copy = !strchr(WHITESP, arg[i]); if (copy) arg[j++] = arg[i]; } } if (!copy && j > 0) /* last char was a 'blank', remove it */ j--; l = j; /* the new argument length */ arg[j++] = '\0'; if (l == 0) /* empty string! */ return 1; /* * First, count number of arguments. Because of the previous * processing, this is just the number of blanks plus 1. */ for (i = 0, ac = 1; i < l; i++) if (strchr(WHITESP, arg[i]) != NULL) ac++; /* * Allocate the argument list structure as a single block * of memory, containing pointers and the argument * strings. We include one entry for the program name * because getopt expects it, and a NULL at the end * to simplify further parsing. */ ac++; /* add 1 for the program name */ av_size = (ac+1) * sizeof(char *) + l + 1; av = safe_calloc(av_size, 1); /* * Init the argument pointer to the end of the array * and copy arguments from arg[] to av[]. For each one, * j is the initial character, i is the one past the end. */ av_p = (char *)&av[ac+1]; for (ac = 1, i = j = 0; i < l; i++) { if (strchr(WHITESP, arg[i]) != NULL || i == l-1) { if (i == l-1) i++; bcopy(arg+j, av_p, i-j); av[ac] = av_p; av_p += i-j; /* the length of the string */ *av_p++ = '\0'; ac++; j = i + 1; } } } else { /* * If an argument ends with ',' join with the next one. */ int first, i, l=0; /* * Allocate the argument list structure as a single block * of memory, containing both pointers and the argument * strings. We include some space for the program name * because getopt expects it. * We add an extra pointer to the end of the array, * to make simpler further parsing. */ for (i=0; i<oldac; i++) l += strlen(oldav[i]); av_size = (oldac+1) * sizeof(char *) + l + oldac; av = safe_calloc(av_size, 1); /* * Init the argument pointer to the end of the array * and copy arguments from arg[] to av[] */ av_p = (char *)&av[oldac+1]; for (first = i = ac = 1, l = 0; i < oldac; i++) { char *arg = oldav[i]; int k = strlen(arg); l += k; if (arg[k-1] != ',' || i == oldac-1) { /* Time to copy. */ av[ac] = av_p; for (l=0; first <= i; first++) { strcat(av_p, oldav[first]); av_p += strlen(oldav[first]); } *av_p++ = '\0'; ac++; l = 0; first = i+1; } } } /* * set the progname pointer to the original string * and terminate the array with null */ av[0] = oldav[0]; av[ac] = NULL; /* Set the force flag for non-interactive processes */ if (!co.do_force) co.do_force = !isatty(STDIN_FILENO); #ifdef EMULATE_SYSCTL /* sysctl emulation */ if ( ac >= 2 && !strcmp(av[1], "sysctl")) { char *s; int i; if (ac != 3) { printf( "sysctl emulation usage:\n" " ipfw sysctl name[=value]\n" " ipfw sysctl -a\n"); return 0; } s = strchr(av[2], '='); if (s == NULL) { s = !strcmp(av[2], "-a") ? NULL : av[2]; sysctlbyname(s, NULL, NULL, NULL, 0); } else { /* ipfw sysctl x.y.z=value */ /* assume an INT value, will extend later */ if (s[1] == '\0') { printf("ipfw sysctl: missing value\n\n"); return 0; } *s = '\0'; i = strtol(s+1, NULL, 0); sysctlbyname(av[2], NULL, NULL, &i, sizeof(int)); } return 0; } #endif /* Save arguments for final freeing of memory. */ save_av = av; optind = optreset = 1; /* restart getopt() */ while ((ch = getopt(ac, av, "abcdefhinNp:qs:STtv")) != -1) switch (ch) { case 'a': do_acct = 1; break; case 'b': co.comment_only = 1; co.do_compact = 1; break; case 'c': co.do_compact = 1; break; case 'd': co.do_dynamic = 1; break; case 'e': co.do_expired = 1; break; case 'f': co.do_force = 1; break; case 'h': /* help */ free(save_av); help(); break; /* NOTREACHED */ case 'i': co.do_value_as_ip = 1; break; case 'n': co.test_only = 1; break; case 'N': co.do_resolv = 1; break; case 'p': errx(EX_USAGE, "An absolute pathname must be used " "with -p option."); /* NOTREACHED */ case 'q': co.do_quiet = 1; break; case 's': /* sort */ co.do_sort = atoi(optarg); break; case 'S': co.show_sets = 1; break; case 't': co.do_time = 1; break; case 'T': co.do_time = 2; /* numeric timestamp */ break; case 'v': /* verbose */ co.verbose = 1; break; default: free(save_av); return 1; } ac -= optind; av += optind; NEED1("bad arguments, for usage summary ``ipfw''"); /* * An undocumented behaviour of ipfw1 was to allow rule numbers first, * e.g. "100 add allow ..." instead of "add 100 allow ...". * In case, swap first and second argument to get the normal form. */ if (ac > 1 && isdigit(*av[0])) { char *p = av[0]; av[0] = av[1]; av[1] = p; } /* * Optional: pipe, queue or nat. */ co.do_nat = 0; co.do_pipe = 0; co.use_set = 0; if (!strncmp(*av, "nat", strlen(*av))) co.do_nat = 1; else if (!strncmp(*av, "pipe", strlen(*av))) co.do_pipe = 1; else if (_substrcmp(*av, "queue") == 0) co.do_pipe = 2; else if (_substrcmp(*av, "flowset") == 0) co.do_pipe = 2; else if (_substrcmp(*av, "sched") == 0) co.do_pipe = 3; else if (!strncmp(*av, "set", strlen(*av))) { if (ac > 1 && isdigit(av[1][0])) { co.use_set = strtonum(av[1], 0, resvd_set_number, &errstr); if (errstr) errx(EX_DATAERR, "invalid set number %s\n", av[1]); ac -= 2; av += 2; co.use_set++; } } if (co.do_pipe || co.do_nat) { ac--; av++; } NEED1("missing command"); /* * For pipes, queues and nats we normally say 'nat|pipe NN config' * but the code is easier to parse as 'nat|pipe config NN' * so we swap the two arguments. */ if ((co.do_pipe || co.do_nat) && ac > 1 && isdigit(*av[0])) { char *p = av[0]; av[0] = av[1]; av[1] = p; } if (co.use_set == 0) { if (_substrcmp(*av, "add") == 0) ipfw_add(av); else if (co.do_nat && _substrcmp(*av, "show") == 0) ipfw_show_nat(ac, av); else if (co.do_pipe && _substrcmp(*av, "config") == 0) ipfw_config_pipe(ac, av); else if (co.do_nat && _substrcmp(*av, "config") == 0) ipfw_config_nat(ac, av); else if (_substrcmp(*av, "set") == 0) ipfw_sets_handler(av); else if (_substrcmp(*av, "table") == 0) ipfw_table_handler(ac, av); else if (_substrcmp(*av, "enable") == 0) ipfw_sysctl_handler(av, 1); else if (_substrcmp(*av, "disable") == 0) ipfw_sysctl_handler(av, 0); else try_next = 1; } if (co.use_set || try_next) { if (_substrcmp(*av, "delete") == 0) ipfw_delete(av); else if (_substrcmp(*av, "flush") == 0) ipfw_flush(co.do_force); else if (_substrcmp(*av, "zero") == 0) ipfw_zero(ac, av, 0 /* IP_FW_ZERO */); else if (_substrcmp(*av, "resetlog") == 0) ipfw_zero(ac, av, 1 /* IP_FW_RESETLOG */); else if (_substrcmp(*av, "print") == 0 || _substrcmp(*av, "list") == 0) ipfw_list(ac, av, do_acct); else if (_substrcmp(*av, "show") == 0) ipfw_list(ac, av, 1 /* show counters */); else errx(EX_USAGE, "bad command `%s'", *av); } /* Free memory allocated in the argument parsing. */ free(save_av); return 0; }
static char * makenetvfslist(void) { char *str, *strptr, **listptr; struct xvfsconf *xvfsp, *keep_xvfsp; size_t buflen; int cnt, i, maxvfsconf; if (sysctlbyname("vfs.conflist", NULL, &buflen, NULL, 0) < 0) { warn("sysctl(vfs.conflist)"); return (NULL); } xvfsp = malloc(buflen); if (xvfsp == NULL) { warnx("malloc failed"); return (NULL); } keep_xvfsp = xvfsp; if (sysctlbyname("vfs.conflist", xvfsp, &buflen, NULL, 0) < 0) { warn("sysctl(vfs.conflist)"); free(keep_xvfsp); return (NULL); } maxvfsconf = buflen / sizeof(struct xvfsconf); if ((listptr = malloc(sizeof(char*) * maxvfsconf)) == NULL) { warnx("malloc failed"); free(keep_xvfsp); return (NULL); } for (cnt = 0, i = 0; i < maxvfsconf; i++) { if (xvfsp->vfc_flags & VFCF_NETWORK) { listptr[cnt++] = strdup(xvfsp->vfc_name); if (listptr[cnt-1] == NULL) { warnx("malloc failed"); free(listptr); free(keep_xvfsp); return (NULL); } } xvfsp++; } if (cnt == 0 || (str = malloc(sizeof(char) * (32 * cnt + cnt + 2))) == NULL) { if (cnt > 0) warnx("malloc failed"); free(listptr); free(keep_xvfsp); return (NULL); } *str = 'n'; *(str + 1) = 'o'; for (i = 0, strptr = str + 2; i < cnt; i++, strptr++) { strlcpy(strptr, listptr[i], 32); strptr += strlen(listptr[i]); *strptr = ','; free(listptr[i]); } *(--strptr) = '\0'; free(keep_xvfsp); free(listptr); return (str); }
const char zfs_arcstat[] = "kstat.zfs.misc.arcstats."; #if !defined(kstat_t) typedef void kstat_t; #endif static long long get_zfs_value(kstat_t *dummy __attribute__((unused)), char const *name) { char buffer[256]; long long value; size_t valuelen = sizeof(value); int rv; ssnprintf (buffer, sizeof (buffer), "%s%s", zfs_arcstat, name); rv = sysctlbyname (buffer, (void *) &value, &valuelen, /* new value = */ NULL, /* new length = */ (size_t) 0); if (rv == 0) return (value); return (-1); } #endif static void za_submit (const char* type, const char* type_instance, value_t* values, int values_len) { value_list_t vl = VALUE_LIST_INIT; vl.values = values; vl.values_len = values_len; sstrncpy (vl.host, hostname_g, sizeof (vl.host));
void pass2(void) { union dinode *dp; struct inoinfo **inpp, *inp; struct inoinfo **inpend; struct inodesc curino; union dinode dino; int i; char pathbuf[MAXPATHLEN + 1]; switch (inoinfo(ROOTINO)->ino_state) { case USTATE: pfatal("ROOT INODE UNALLOCATED"); if (reply("ALLOCATE") == 0) { ckfini(0); exit(EEXIT); } if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO) errx(EEXIT, "CANNOT ALLOCATE ROOT INODE"); break; case DCLEAR: pfatal("DUPS/BAD IN ROOT INODE"); if (reply("REALLOCATE")) { freeino(ROOTINO); if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO) errx(EEXIT, "CANNOT ALLOCATE ROOT INODE"); break; } if (reply("CONTINUE") == 0) { ckfini(0); exit(EEXIT); } break; case FSTATE: case FCLEAR: case FZLINK: pfatal("ROOT INODE NOT DIRECTORY"); if (reply("REALLOCATE")) { freeino(ROOTINO); if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO) errx(EEXIT, "CANNOT ALLOCATE ROOT INODE"); break; } if (reply("FIX") == 0) { ckfini(0); exit(EEXIT); } dp = ginode(ROOTINO); DIP_SET(dp, di_mode, DIP(dp, di_mode) & ~IFMT); DIP_SET(dp, di_mode, DIP(dp, di_mode) | IFDIR); inodirty(); break; case DSTATE: case DZLINK: break; default: errx(EEXIT, "BAD STATE %d FOR ROOT INODE", inoinfo(ROOTINO)->ino_state); } inoinfo(ROOTINO)->ino_state = DFOUND; inoinfo(WINO)->ino_state = FSTATE; inoinfo(WINO)->ino_type = DT_WHT; /* * Sort the directory list into disk block order. */ qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort); /* * Check the integrity of each directory. */ memset(&curino, 0, sizeof(struct inodesc)); curino.id_type = DATA; curino.id_func = pass2check; inpend = &inpsort[inplast]; for (inpp = inpsort; inpp < inpend; inpp++) { if (got_siginfo) { printf("%s: phase 2: dir %td of %d (%d%%)\n", cdevname, inpp - inpsort, (int)inplast, (int)((inpp - inpsort) * 100 / inplast)); got_siginfo = 0; } if (got_sigalarm) { setproctitle("%s p2 %d%%", cdevname, (int)((inpp - inpsort) * 100 / inplast)); got_sigalarm = 0; } inp = *inpp; if (inp->i_isize == 0) continue; if (inp->i_isize < MINDIRSIZE) { direrror(inp->i_number, "DIRECTORY TOO SHORT"); inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ); if (reply("FIX") == 1) { dp = ginode(inp->i_number); DIP_SET(dp, di_size, inp->i_isize); inodirty(); } } else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) { getpathname(pathbuf, inp->i_number, inp->i_number); if (usedsoftdep) pfatal("%s %s: LENGTH %jd NOT MULTIPLE OF %d", "DIRECTORY", pathbuf, (intmax_t)inp->i_isize, DIRBLKSIZ); else pwarn("%s %s: LENGTH %jd NOT MULTIPLE OF %d", "DIRECTORY", pathbuf, (intmax_t)inp->i_isize, DIRBLKSIZ); if (preen) printf(" (ADJUSTED)\n"); inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ); if (preen || reply("ADJUST") == 1) { dp = ginode(inp->i_number); DIP_SET(dp, di_size, roundup(inp->i_isize, DIRBLKSIZ)); inodirty(); } } dp = &dino; memset(dp, 0, sizeof(struct ufs2_dinode)); DIP_SET(dp, di_mode, IFDIR); DIP_SET(dp, di_size, inp->i_isize); for (i = 0; i < (inp->i_numblks<NDADDR ? inp->i_numblks : NDADDR); i++) DIP_SET(dp, di_db[i], inp->i_blks[i]); if (inp->i_numblks > NDADDR) for (i = 0; i < NIADDR; i++) DIP_SET(dp, di_ib[i], inp->i_blks[NDADDR + i]); curino.id_number = inp->i_number; curino.id_parent = inp->i_parent; (void)ckinode(dp, &curino); } /* * Now that the parents of all directories have been found, * make another pass to verify the value of `..' */ for (inpp = inpsort; inpp < inpend; inpp++) { inp = *inpp; if (inp->i_parent == 0 || inp->i_isize == 0) continue; if (inoinfo(inp->i_parent)->ino_state == DFOUND && INO_IS_DUNFOUND(inp->i_number)) inoinfo(inp->i_number)->ino_state = DFOUND; if (inp->i_dotdot == inp->i_parent || inp->i_dotdot == (ino_t)-1) continue; if (inp->i_dotdot == 0) { inp->i_dotdot = inp->i_parent; fileerror(inp->i_parent, inp->i_number, "MISSING '..'"); if (reply("FIX") == 0) continue; (void)makeentry(inp->i_number, inp->i_parent, ".."); inoinfo(inp->i_parent)->ino_linkcnt--; continue; } /* * Here we have: * inp->i_number is directory with bad ".." in it. * inp->i_dotdot is current value of "..". * inp->i_parent is directory to which ".." should point. */ getpathname(pathbuf, inp->i_parent, inp->i_number); printf("BAD INODE NUMBER FOR '..' in DIR I=%ju (%s)\n", (uintmax_t)inp->i_number, pathbuf); getpathname(pathbuf, inp->i_dotdot, inp->i_dotdot); printf("CURRENTLY POINTS TO I=%ju (%s), ", (uintmax_t)inp->i_dotdot, pathbuf); getpathname(pathbuf, inp->i_parent, inp->i_parent); printf("SHOULD POINT TO I=%ju (%s)", (uintmax_t)inp->i_parent, pathbuf); if (cursnapshot != 0) { /* * We need to: * setcwd(inp->i_number); * setdotdot(inp->i_dotdot, inp->i_parent); */ cmd.value = inp->i_number; if (sysctlbyname("vfs.ffs.setcwd", 0, 0, &cmd, sizeof cmd) == -1) { /* kernel lacks support for these functions */ printf(" (IGNORED)\n"); continue; } cmd.value = inp->i_dotdot; /* verify same value */ cmd.size = inp->i_parent; /* new parent */ if (sysctlbyname("vfs.ffs.setdotdot", 0, 0, &cmd, sizeof cmd) == -1) { printf(" (FIX FAILED: %s)\n", strerror(errno)); continue; } printf(" (FIXED)\n"); inoinfo(inp->i_parent)->ino_linkcnt--; inp->i_dotdot = inp->i_parent; continue; } if (preen) printf(" (FIXED)\n"); else if (reply("FIX") == 0) continue; inoinfo(inp->i_dotdot)->ino_linkcnt++; inoinfo(inp->i_parent)->ino_linkcnt--; inp->i_dotdot = inp->i_parent; (void)changeino(inp->i_number, "..", inp->i_parent); } /* * Mark all the directories that can be found from the root. */ propagate(); }
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList, uid_t userId) { FreeBSDProcessList* fpl = xCalloc(1, sizeof(FreeBSDProcessList)); ProcessList* pl = (ProcessList*) fpl; ProcessList_init(pl, Class(FreeBSDProcess), usersTable, pidWhiteList, userId); size_t len; // physical memory in system: hw.physmem // physical page size: hw.pagesize // usable pagesize : vm.stats.vm.v_page_size len = 2; sysctlnametomib("hw.physmem", MIB_hw_physmem, &len); len = sizeof(pageSize); if (sysctlbyname("vm.stats.vm.v_page_size", &pageSize, &len, NULL, 0) == -1) { pageSize = PAGE_SIZE; pageSizeKb = PAGE_SIZE_KB; } else { pageSizeKb = pageSize / ONE_K; } // usable page count vm.stats.vm.v_page_count // actually usable memory : vm.stats.vm.v_page_count * vm.stats.vm.v_page_size len = 4; sysctlnametomib("vm.stats.vm.v_page_count", MIB_vm_stats_vm_v_page_count, &len); len = 4; sysctlnametomib("vm.stats.vm.v_wire_count", MIB_vm_stats_vm_v_wire_count, &len); len = 4; sysctlnametomib("vm.stats.vm.v_active_count", MIB_vm_stats_vm_v_active_count, &len); len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", MIB_vm_stats_vm_v_cache_count, &len); len = 4; sysctlnametomib("vm.stats.vm.v_inactive_count", MIB_vm_stats_vm_v_inactive_count, &len); len = 4; sysctlnametomib("vm.stats.vm.v_free_count", MIB_vm_stats_vm_v_free_count, &len); len = 2; sysctlnametomib("vfs.bufspace", MIB_vfs_bufspace, &len); len = sizeof(fpl->memZfsArc); if (sysctlbyname("kstat.zfs.misc.arcstats.size", &fpl->memZfsArc, &len, NULL, 0) == 0 && fpl->memZfsArc != 0) { sysctlnametomib("kstat.zfs.misc.arcstats.size", MIB_kstat_zfs_misc_arcstats_size, &len); fpl->zfsArcEnabled = 1; } else { fpl->zfsArcEnabled = 0; } int smp = 0; len = sizeof(smp); if (sysctlbyname("kern.smp.active", &smp, &len, NULL, 0) != 0 || len != sizeof(smp)) { smp = 0; } int cpus = 1; len = sizeof(cpus); if (smp) { int err = sysctlbyname("kern.smp.cpus", &cpus, &len, NULL, 0); if (err) cpus = 1; } else { cpus = 1; } size_t sizeof_cp_time_array = sizeof(unsigned long) * CPUSTATES; len = 2; sysctlnametomib("kern.cp_time", MIB_kern_cp_time, &len); fpl->cp_time_o = xCalloc(cpus, sizeof_cp_time_array); fpl->cp_time_n = xCalloc(cpus, sizeof_cp_time_array); len = sizeof_cp_time_array; // fetch intial single (or average) CPU clicks from kernel sysctl(MIB_kern_cp_time, 2, fpl->cp_time_o, &len, NULL, 0); // on smp box, fetch rest of intial CPU's clicks if (cpus > 1) { len = 2; sysctlnametomib("kern.cp_times", MIB_kern_cp_times, &len); fpl->cp_times_o = xCalloc(cpus, sizeof_cp_time_array); fpl->cp_times_n = xCalloc(cpus, sizeof_cp_time_array); len = cpus * sizeof_cp_time_array; sysctl(MIB_kern_cp_times, 2, fpl->cp_times_o, &len, NULL, 0); } pl->cpuCount = MAX(cpus, 1); if (cpus == 1 ) { fpl->cpus = xRealloc(fpl->cpus, sizeof(CPUData)); } else { // on smp we need CPUs + 1 to store averages too (as kernel kindly provides that as well) fpl->cpus = xRealloc(fpl->cpus, (pl->cpuCount + 1) * sizeof(CPUData)); } len = sizeof(kernelFScale); if (sysctlbyname("kern.fscale", &kernelFScale, &len, NULL, 0) == -1) { //sane default for kernel provded CPU precentage scaling, at least on x86 machines, in case this sysctl call failed kernelFScale = 2048; } fpl->kd = kvm_open(NULL, "/dev/null", NULL, 0, NULL); assert(fpl->kd); return pl; }
int main(int argc, char *argv[]) { struct kinfo_proc *kp; struct kinfo_proc *dkp; struct stat *stp; time_t touched; int ch, i, nentries, nusers, wcmd, longidle, longattime, dropgid; const char *memf, *nlistf, *p; char *x_suffix; char buf[MAXHOSTNAMELEN], errbuf[_POSIX2_LINE_MAX]; char fn[MAXHOSTNAMELEN]; char *dot; (void)setlocale(LC_ALL, ""); use_ampm = (*nl_langinfo(T_FMT_AMPM) != '\0'); use_comma = (*nl_langinfo(RADIXCHAR) != ','); /* Are we w(1) or uptime(1)? */ if (this_is_uptime(argv[0]) == 0) { wcmd = 0; p = ""; } else { wcmd = 1; p = "dhiflM:N:nsuw"; } dropgid = 0; memf = _PATH_DEVNULL; nlistf = NULL; while ((ch = getopt(argc, argv, p)) != -1) switch (ch) { case 'd': dflag = 1; break; case 'h': header = 0; break; case 'i': sortidle = 1; break; case 'M': header = 0; memf = optarg; dropgid = 1; break; case 'N': nlistf = optarg; dropgid = 1; break; case 'n': nflag = 1; break; case 'f': case 'l': case 's': case 'u': case 'w': warnx("[-flsuw] no longer supported"); /* FALLTHROUGH */ case '?': default: usage(wcmd); } argc -= optind; argv += optind; if (!(_res.options & RES_INIT)) res_init(); _res.retrans = 2; /* resolver timeout to 2 seconds per try */ _res.retry = 1; /* only try once.. */ /* * Discard setgid privileges if not the running kernel so that bad * guys can't print interesting stuff from kernel memory. */ if (dropgid) setgid(getgid()); if ((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, errbuf)) == NULL) errx(1, "%s", errbuf); (void)time(&now); if (*argv) sel_users = argv; setutxent(); for (nusers = 0; (utmp = getutxent()) != NULL;) { if (utmp->ut_type != USER_PROCESS) continue; if (!(stp = ttystat(utmp->ut_line))) continue; /* corrupted record */ ++nusers; if (wcmd == 0) continue; if (sel_users) { int usermatch; char **user; usermatch = 0; for (user = sel_users; !usermatch && *user; user++) if (!strcmp(utmp->ut_user, *user)) usermatch = 1; if (!usermatch) continue; } if ((ep = calloc(1, sizeof(struct entry))) == NULL) errx(1, "calloc"); *nextp = ep; nextp = &ep->next; memmove(&ep->utmp, utmp, sizeof *utmp); ep->tdev = stp->st_rdev; /* * If this is the console device, attempt to ascertain * the true console device dev_t. */ if (ep->tdev == 0) { size_t size; size = sizeof(dev_t); (void)sysctlbyname("machdep.consdev", &ep->tdev, &size, NULL, 0); } touched = stp->st_atime; if (touched < ep->utmp.ut_tv.tv_sec) { /* tty untouched since before login */ touched = ep->utmp.ut_tv.tv_sec; } if ((ep->idle = now - touched) < 0) ep->idle = 0; } endutxent(); if (header || wcmd == 0) { pr_header(&now, nusers); if (wcmd == 0) { (void)kvm_close(kd); exit(0); } #define HEADER_USER "USER" #define HEADER_TTY "TTY" #define HEADER_FROM "FROM" #define HEADER_LOGIN_IDLE "LOGIN@ IDLE " #define HEADER_WHAT "WHAT\n" #define WUSED (W_DISPUSERSIZE + W_DISPLINESIZE + W_DISPHOSTSIZE + \ sizeof(HEADER_LOGIN_IDLE) + 3) /* header width incl. spaces */ (void)printf("%-*.*s %-*.*s %-*.*s %s", W_DISPUSERSIZE, W_DISPUSERSIZE, HEADER_USER, W_DISPLINESIZE, W_DISPLINESIZE, HEADER_TTY, W_DISPHOSTSIZE, W_DISPHOSTSIZE, HEADER_FROM, HEADER_LOGIN_IDLE HEADER_WHAT); } if ((kp = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nentries)) == NULL) err(1, "%s", kvm_geterr(kd)); for (i = 0; i < nentries; i++, kp++) { if (kp->ki_stat == SIDL || kp->ki_stat == SZOMB || kp->ki_tdev == NODEV) continue; for (ep = ehead; ep != NULL; ep = ep->next) { if (ep->tdev == kp->ki_tdev) { /* * proc is associated with this terminal */ if (ep->kp == NULL && kp->ki_pgid == kp->ki_tpgid) { /* * Proc is 'most interesting' */ if (proc_compare(ep->kp, kp)) ep->kp = kp; } /* * Proc debug option info; add to debug * list using kinfo_proc ki_spare[0] * as next pointer; ptr to ptr avoids the * ptr = long assumption. */ dkp = ep->dkp; ep->dkp = kp; debugproc(kp) = dkp; } } } if ((ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1 && ioctl(STDERR_FILENO, TIOCGWINSZ, &ws) == -1 && ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) == -1) || ws.ws_col == 0) ttywidth = 79; else ttywidth = ws.ws_col - 1; argwidth = ttywidth - WUSED; if (argwidth < 4) argwidth = 8; for (ep = ehead; ep != NULL; ep = ep->next) { if (ep->kp == NULL) { ep->args = strdup("-"); continue; } ep->args = fmt_argv(kvm_getargv(kd, ep->kp, argwidth), ep->kp->ki_comm, NULL, MAXCOMLEN); if (ep->args == NULL) err(1, NULL); } /* sort by idle time */ if (sortidle && ehead != NULL) { struct entry *from, *save; from = ehead; ehead = NULL; while (from != NULL) { for (nextp = &ehead; (*nextp) && from->idle >= (*nextp)->idle; nextp = &(*nextp)->next) continue; save = from; from = from->next; save->next = *nextp; *nextp = save; } } for (ep = ehead; ep != NULL; ep = ep->next) { struct addrinfo hints, *res; struct sockaddr_storage ss; struct sockaddr *sa = (struct sockaddr *)&ss; struct sockaddr_in *lsin = (struct sockaddr_in *)&ss; struct sockaddr_in6 *lsin6 = (struct sockaddr_in6 *)&ss; time_t t; int isaddr; p = *ep->utmp.ut_host ? ep->utmp.ut_host : "-"; if ((x_suffix = strrchr(p, ':')) != NULL) { if ((dot = strchr(x_suffix, '.')) != NULL && strchr(dot+1, '.') == NULL) *x_suffix++ = '\0'; else x_suffix = NULL; } isaddr = 0; memset(&ss, '\0', sizeof(ss)); if (inet_pton(AF_INET6, p, &lsin6->sin6_addr) == 1) { lsin6->sin6_len = sizeof(*lsin6); lsin6->sin6_family = AF_INET6; isaddr = 1; } else if (inet_pton(AF_INET, p, &lsin->sin_addr) == 1) { lsin->sin_len = sizeof(*lsin); lsin->sin_family = AF_INET; isaddr = 1; } if (!nflag) { /* Attempt to change an IP address into a name */ if (isaddr && realhostname_sa(fn, sizeof(fn), sa, sa->sa_len) == HOSTNAME_FOUND) p = fn; } else if (!isaddr) { /* * If a host has only one A/AAAA RR, change a * name into an IP address */ memset(&hints, 0, sizeof(hints)); hints.ai_flags = AI_PASSIVE; hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; if (getaddrinfo(p, NULL, &hints, &res) == 0) { if (res->ai_next == NULL && getnameinfo(res->ai_addr, res->ai_addrlen, fn, sizeof(fn), NULL, 0, NI_NUMERICHOST) == 0) p = fn; freeaddrinfo(res); } } if (x_suffix) { (void)snprintf(buf, sizeof(buf), "%s:%s", p, x_suffix); p = buf; } if (dflag) { for (dkp = ep->dkp; dkp != NULL; dkp = debugproc(dkp)) { const char *ptr; ptr = fmt_argv(kvm_getargv(kd, dkp, argwidth), dkp->ki_comm, NULL, MAXCOMLEN); if (ptr == NULL) ptr = "-"; (void)printf("\t\t%-9d %s\n", dkp->ki_pid, ptr); } } (void)printf("%-*.*s %-*.*s %-*.*s ", W_DISPUSERSIZE, W_DISPUSERSIZE, ep->utmp.ut_user, W_DISPLINESIZE, W_DISPLINESIZE, *ep->utmp.ut_line ? (strncmp(ep->utmp.ut_line, "tty", 3) && strncmp(ep->utmp.ut_line, "cua", 3) ? ep->utmp.ut_line : ep->utmp.ut_line + 3) : "-", W_DISPHOSTSIZE, W_DISPHOSTSIZE, *p ? p : "-"); t = ep->utmp.ut_tv.tv_sec; longattime = pr_attime(&t, &now); longidle = pr_idle(ep->idle); (void)printf("%.*s\n", argwidth - longidle - longattime, ep->args); } (void)kvm_close(kd); exit(0); }
int zfs_filestat(kvm_t *kd, struct vnode *vp, struct vnstat *vn) { znode_phys_t zphys; struct mount mount, *mountptr; uint64_t *zid; void *znodeptr, *vnodeptr; char *dataptr; void *zphys_addr; size_t len; int size; len = sizeof(size); if (sysctlbyname("debug.sizeof.znode", &size, &len, NULL, 0) == -1) { warnx("error getting sysctl"); return (1); } znodeptr = malloc(size); if (znodeptr == NULL) { warnx("error allocating memory for znode storage"); return (1); } /* Since we have problems including vnode.h, we'll use the wrappers. */ vnodeptr = getvnodedata(vp); if (!kvm_read_all(kd, (unsigned long)vnodeptr, znodeptr, (size_t)size)) { warnx("can't read znode at %p", (void *)vnodeptr); goto bad; } /* * z_id field is stored in the third pointer. We therefore skip the two * first bytes. * * Pointer to the z_phys structure is the next last pointer. Therefore * go back two bytes from the end. */ dataptr = znodeptr; zid = (uint64_t *)(dataptr + LOCATION_ZID); zphys_addr = *(void **)(dataptr + LOCATION_ZPHYS(size)); if (!kvm_read_all(kd, (unsigned long)zphys_addr, &zphys, sizeof(zphys))) { warnx("can't read znode_phys at %p", zphys_addr); goto bad; } /* Get the mount pointer, and read from the address. */ mountptr = getvnodemount(vp); if (!kvm_read_all(kd, (unsigned long)mountptr, &mount, sizeof(mount))) { warnx("can't read mount at %p", (void *)mountptr); goto bad; } vn->vn_fsid = mount.mnt_stat.f_fsid.val[0]; vn->vn_fileid = *zid; /* * XXX: Shows up wrong in output, but UFS has this error too. Could * be that we're casting mode-variables from 64-bit to 8-bit or simply * error in the mode-to-string function. */ vn->vn_mode = (mode_t)zphys.zp_mode; vn->vn_size = (u_long)zphys.zp_size; free(znodeptr); return (0); bad: free(znodeptr); return (1); }