lib/libkvm/kvm_file.c

   1 /*-
   2  * Copyright (c) 1989, 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)kvm_file.c       8.1 (Berkeley) 6/4/93
  30  * $FreeBSD: src/lib/libkvm/kvm_file.c,v 1.11 2000/02/18 16:39:00 peter Exp $
  31  */
  32
  33 /*
  34  * File list interface for kvm.
  35  */
  36
  37 #include <sys/user.h>   /* MUST BE FIRST */
  38 #include <sys/param.h>
  39 #include <sys/proc.h>
  40 #define _KERNEL
  41 #include <sys/file.h>
  42 #undef _KERNEL
  43 #include <sys/stat.h>
  44 #include <sys/ioctl.h>
  45 #include <sys/kinfo.h>
  46 #include <nlist.h>
  47
  48 #include <vm/vm.h>
  49 #include <vm/vm_param.h>
  50 #include <vm/swap_pager.h>
  51
  52 #include <sys/sysctl.h>
  53
  54 #include <limits.h>
  55 #include <ndbm.h>
  56 #include <paths.h>
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <string.h>
  60
  61 #include "kvm.h"
  62 #include "kvm_private.h"
  63
  64 #define KREAD(kd, addr, obj) \
  65         (kvm_read(kd, addr, obj, sizeof(*obj)) != sizeof(*obj))
  66
  67 /* XXX copied from sys/kern/subr_kcore.c */
  68 static void
  69 kcore_make_file(struct kinfo_file *ufile, struct file *kfile,
  70     pid_t pid, uid_t owner, int n)
  71 {
  72         bzero(ufile, sizeof(*ufile));
  73         ufile->f_size = sizeof(*ufile);
  74         ufile->f_pid = pid;
  75         ufile->f_uid = owner;
  76
  77         ufile->f_fd = n;
  78         ufile->f_file = kfile;
  79         ufile->f_data = kfile->f_data;
  80         ufile->f_type = kfile->f_type;
  81         ufile->f_count = kfile->f_count;
  82         ufile->f_msgcount = kfile->f_msgcount;
  83         ufile->f_offset = kfile->f_offset;
  84         ufile->f_flag = kfile->f_flag;
  85 }
  86
  87 /*
  88  * Get file structures.
  89  */
  90 static int
  91 kvm_deadfiles(kvm_t *kd, struct kinfo_proc *kproc, int kproc_cnt, int nfiles)
  92 {
  93         struct kinfo_file *kinfo_file = (struct kinfo_file *)kd->argspc;
  94         struct fdnode *fd_files;
  95         size_t size;
  96         int i, fd_nfiles, found = 0;
  97
  98         fd_nfiles = NDFILE;
  99         fd_files = malloc(fd_nfiles * sizeof(struct fdnode));
 100         if (fd_files == NULL) {
 101                 _kvm_err(kd, kd->program, "alloc fd_files failed");
 102                 return 0;
 103         }
 104
 105         for (i = 0; i < kproc_cnt; ++i) {
 106                 const struct kinfo_proc *kp = &kproc[i];
 107                 struct filedesc fdp;
 108                 int n, f;
 109
 110                 if (kp->kp_fd == 0)
 111                         continue;
 112                 if (KREAD(kd, kp->kp_fd, &fdp)) {
 113                         _kvm_err(kd, kd->program, "can't read fdp");
 114                         free(fd_files);
 115                         return 0;
 116                 }
 117                 if (fdp.fd_files == NULL)
 118                         continue;
 119
 120                 if (fdp.fd_nfiles > fd_nfiles) {
 121                         struct fdnode *new_fd_files;
 122
 123                         fd_nfiles = fdp.fd_nfiles;
 124                         new_fd_files =
 125                             malloc(fd_nfiles * sizeof(struct fdnode));
 126                         free(fd_files);
 127                         if (new_fd_files == NULL) {
 128                                 _kvm_err(kd, kd->program,
 129                                     "realloc fd_files failed");
 130                                 return 0;
 131                         }
 132                         fd_files = new_fd_files;
 133                 }
 134                 n = fdp.fd_nfiles * sizeof(struct fdnode);
 135
 136                 if (kvm_read(kd, (uintptr_t)fdp.fd_files, fd_files, n) != n) {
 137                         _kvm_err(kd, kd->program, "can't read fd_files");
 138                         free(fd_files);
 139                         return 0;
 140                 }
 141                 for (f = 0; f < fdp.fd_nfiles; ++f) {
 142                         struct file kf;
 143
 144                         if (fd_files[f].fp == NULL)
 145                                 continue;
 146                         if (KREAD(kd, (uintptr_t)fd_files[f].fp, &kf)) {
 147                                 _kvm_err(kd, kd->program, "can't read file");
 148                                 free(fd_files);
 149                                 return 0;
 150                         }
 151
 152                         kcore_make_file(kinfo_file, &kf,
 153                             kp->kp_pid, kp->kp_uid, f);
 154                         kinfo_file++;
 155                         found++;
 156
 157                         if (found == nfiles) {
 158                                 nfiles *= 2;
 159                                 size = nfiles * sizeof(struct kinfo_file);
 160
 161                                 kd->argspc = _kvm_realloc(kd, kd->argspc, size);
 162                                 if (kd->argspc == NULL) {
 163                                         free(fd_files);
 164                                         return 0;
 165                                 }
 166                                 kd->arglen = size;
 167
 168                                 kinfo_file = (struct kinfo_file *)kd->argspc;
 169                                 kinfo_file += found;
 170                         }
 171                 }
 172         }
 173         free(fd_files);
 174         return found;
 175 }
 176
 177 struct kinfo_file *
 178 kvm_getfiles(kvm_t *kd, int op __unused, int arg __unused, int *cnt)
 179 {
 180         int nfiles;
 181         size_t size;
 182
 183         if (kvm_ishost(kd)) {
 184                 int mib[2], st;
 185
 186                 size = 0;
 187                 mib[0] = CTL_KERN;
 188                 mib[1] = KERN_FILE;
 189                 st = sysctl(mib, 2, NULL, &size, NULL, 0);
 190                 if (st == -1) {
 191                         _kvm_syserr(kd, kd->program, "sysctl KERN_FILE failed");
 192                         return NULL;
 193                 }
 194                 if (kd->argspc == NULL)
 195                         kd->argspc = _kvm_malloc(kd, size);
 196                 else if (kd->arglen < (ssize_t)size)
 197                         kd->argspc = _kvm_realloc(kd, kd->argspc, size);
 198                 if (kd->argspc == NULL)
 199                         return NULL;
 200                 kd->arglen = size;
 201                 st = sysctl(mib, 2, kd->argspc, &size, NULL, 0);
 202                 if (st == -1 || size % sizeof(struct kinfo_file) != 0) {
 203                         _kvm_syserr(kd, kd->program, "sysctl KERN_FILE failed");
 204                         return NULL;
 205                 }
 206                 nfiles = size / sizeof(struct kinfo_file);
 207         } else {
 208                 struct kinfo_proc *kproc0, *kproc;
 209                 int kproc_cnt, kproc_len;
 210                 struct nlist nl[2];
 211
 212                 /*
 213                  * Get all processes and save them in kproc.
 214                  */
 215                 kproc0 = kvm_getprocs(kd, KERN_PROC_ALL, 0, &kproc_cnt);
 216                 if (kproc0 == NULL)
 217                         return NULL;
 218                 kproc_len = kproc_cnt * sizeof(struct kinfo_proc);
 219                 kproc = malloc(kproc_len);
 220                 if (kproc == NULL) {
 221                         _kvm_syserr(kd, kd->program,
 222                             "malloc kinfo_proc failed");
 223                         return NULL;
 224                 }
 225                 memcpy(kproc, kproc0, kproc_len);
 226
 227                 /*
 228                  * Get the # of files
 229                  */
 230                 memset(nl, 0, sizeof(nl));
 231                 nl[0].n_name = "_nfiles";
 232                 if (kvm_nlist(kd, nl) != 0) {
 233                         _kvm_err(kd, kd->program, "%s: no such symbol",
 234                             nl[0].n_name);
 235                         free(kproc);
 236                         return NULL;
 237                 }
 238                 if (KREAD(kd, nl[0].n_value, &nfiles)) {
 239                         _kvm_err(kd, kd->program, "can't read nfiles");
 240                         free(kproc);
 241                         return NULL;
 242                 }
 243
 244                 /*
 245                  * stdio/stderr/stdout are normally duplicated
 246                  * across all processes.
 247                  */
 248                 nfiles += (kproc_cnt * 3);
 249                 size = nfiles * sizeof(struct kinfo_file);
 250                 if (kd->argspc == NULL)
 251                         kd->argspc = _kvm_malloc(kd, size);
 252                 else if (kd->arglen < (ssize_t)size)
 253                         kd->argspc = _kvm_realloc(kd, kd->argspc, size);
 254                 if (kd->argspc == NULL) {
 255                         free(kproc);
 256                         return NULL;
 257                 }
 258                 kd->arglen = size;
 259
 260                 nfiles = kvm_deadfiles(kd, kproc, kproc_cnt, nfiles);
 261                 free(kproc);
 262
 263                 if (nfiles == 0)
 264                         return NULL;
 265         }
 266         *cnt = nfiles;
 267         return (struct kinfo_file *)(kd->argspc);
 268 }