lib/libkvm/kvm_vnet.c

   1 /*-
   2  * Copyright (c) 2009 Robert N. M. Watson
   3  * Copyright (c) 2009 Bjoern A. Zeeb <bz@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32
  33 #define _WANT_PRISON
  34 #define _WANT_UCRED
  35 #define _WANT_VNET
  36
  37 #include <sys/_lock.h>
  38 #include <sys/_mutex.h>
  39 #include <sys/_task.h>
  40 #include <sys/jail.h>
  41 #include <sys/proc.h>
  42 #include <sys/types.h>
  43
  44 #include <net/vnet.h>
  45
  46 #include <nlist.h>
  47 #include <kvm.h>
  48 #include <limits.h>
  49 #include <stdlib.h>
  50 #include <unistd.h>
  51
  52 #include "kvm_private.h"
  53
  54 /*
  55  * Set up libkvm to handle virtual network stack symbols by selecting a
  56  * starting pid.
  57  */
  58 int
  59 _kvm_vnet_selectpid(kvm_t *kd, pid_t pid)
  60 {
  61         struct proc proc;
  62         struct thread td;
  63         struct ucred cred;
  64         struct prison prison;
  65         struct vnet vnet;
  66         struct nlist nl[] = {
  67                 /*
  68                  * Note: kvm_nlist strips the first '_' so add an extra one
  69                  * here to __{start,stop}_set_vnet.
  70                  */
  71 #define NLIST_START_VNET        0
  72                 { .n_name = "___start_" VNET_SETNAME },
  73 #define NLIST_STOP_VNET         1
  74                 { .n_name = "___stop_" VNET_SETNAME },
  75 #define NLIST_VNET_HEAD         2
  76                 { .n_name = "vnet_head" },
  77 #define NLIST_ALLPROC           3
  78                 { .n_name = "allproc" },
  79 #define NLIST_DUMPTID           4
  80                 { .n_name = "dumptid" },
  81 #define NLIST_PROC0             5
  82                 { .n_name = "proc0" },
  83                 { .n_name = NULL },
  84         };
  85         uintptr_t procp, tdp, credp;
  86         lwpid_t dumptid;
  87
  88         /*
  89          * Locate and cache locations of important symbols
  90          * using the internal version of _kvm_nlist, turning
  91          * off initialization to avoid recursion in case of
  92          * unresolveable symbols.
  93          */
  94         if (_kvm_nlist(kd, nl, 0) != 0) {
  95                 /*
  96                  * XXX-BZ: ___start_/___stop_VNET_SETNAME may fail.
  97                  * For now do not report an error here as we are called
  98                  * internally and in `void context' until we merge the
  99                  * functionality to optionally activate this into programs.
 100                  * By that time we can properly fail and let the callers
 101                  * handle the error.
 102                  */
 103                 /* _kvm_err(kd, kd->program, "%s: no namelist", __func__); */
 104                 return (-1);
 105         }
 106
 107         /*
 108          * Auto-detect if this is a crashdump by reading dumptid.
 109          */
 110         dumptid = 0;
 111         if (nl[NLIST_DUMPTID].n_value) {
 112                 if (kvm_read(kd, nl[NLIST_DUMPTID].n_value, &dumptid,
 113                     sizeof(dumptid)) != sizeof(dumptid)) {
 114                         _kvm_err(kd, kd->program, "%s: dumptid", __func__);
 115                         return (-1);
 116                 }
 117         }
 118
 119         /*
 120          * First, find the process for this pid.  If we are working on a
 121          * dump, either locate the thread dumptid is refering to or proc0.
 122          * Based on either, take the address of the ucred.
 123          */
 124         credp = 0;
 125
 126         procp = nl[NLIST_ALLPROC].n_value;
 127 #define VMCORE_VNET_OF_PROC0
 128 #ifdef VMCORE_VNET_OF_PROC0
 129         if (dumptid > 0) {
 130                 procp = nl[NLIST_PROC0].n_value;
 131                 pid = 0;
 132         }
 133 #endif
 134         while (procp != 0) {
 135                 if (kvm_read(kd, procp, &proc, sizeof(proc)) != sizeof(proc)) {
 136                         _kvm_err(kd, kd->program, "%s: proc", __func__);
 137                         return (-1);
 138                 }
 139 #ifndef VMCORE_VNET_OF_PROC0
 140                 if (dumptid > 0) {
 141                         tdp = (uintptr_t)TAILQ_FIRST(&proc.p_threads);
 142                         while (tdp != 0) {
 143                                 if (kvm_read(kd, tdp, &td, sizeof(td)) !=
 144                                     sizeof(td)) {
 145                                         _kvm_err(kd, kd->program, "%s: thread",
 146                                             __func__);
 147                                         return (-1);
 148                                 }
 149                                 if (td.td_tid == dumptid) {
 150                                         credp = (uintptr_t)td.td_ucred;
 151                                         break;
 152                                 }
 153                                 tdp = (uintptr_t)TAILQ_NEXT(&td, td_plist);
 154                         }
 155                 } else
 156 #endif
 157                 if (proc.p_pid == pid)
 158                         credp = (uintptr_t)proc.p_ucred;
 159                 if (credp != 0)
 160                         break;
 161                 procp = (uintptr_t)LIST_NEXT(&proc, p_list);
 162         }
 163         if (credp == 0) {
 164                 _kvm_err(kd, kd->program, "%s: pid/tid not found", __func__);
 165                 return (-1);
 166         }
 167         if (kvm_read(kd, (uintptr_t)credp, &cred, sizeof(cred)) !=
 168             sizeof(cred)) {
 169                 _kvm_err(kd, kd->program, "%s: cred", __func__);
 170                 return (-1);
 171         }
 172         if (cred.cr_prison == NULL) {
 173                 _kvm_err(kd, kd->program, "%s: no jail", __func__);
 174                 return (-1);
 175         }
 176         if (kvm_read(kd, (uintptr_t)cred.cr_prison, &prison, sizeof(prison)) !=
 177             sizeof(prison)) {
 178                 _kvm_err(kd, kd->program, "%s: prison", __func__);
 179                 return (-1);
 180         }
 181         if (prison.pr_vnet == NULL) {
 182                 _kvm_err(kd, kd->program, "%s: no vnet", __func__);
 183                 return (-1);
 184         }
 185         if (kvm_read(kd, (uintptr_t)prison.pr_vnet, &vnet, sizeof(vnet)) !=
 186             sizeof(vnet)) {
 187                 _kvm_err(kd, kd->program, "%s: vnet", __func__);
 188                 return (-1);
 189         }
 190         if (vnet.vnet_magic_n != VNET_MAGIC_N) {
 191                 _kvm_err(kd, kd->program, "%s: invalid vnet magic#", __func__);
 192                 return (-1);
 193         }
 194         kd->vnet_initialized = 1;
 195         kd->vnet_start = nl[NLIST_START_VNET].n_value;
 196         kd->vnet_stop = nl[NLIST_STOP_VNET].n_value;
 197         kd->vnet_current = (uintptr_t)prison.pr_vnet;
 198         kd->vnet_base = vnet.vnet_data_base;
 199         return (0);
 200 }
 201
 202 /*
 203  * Check whether the vnet module has been initialized sucessfully
 204  * or not, intialize it if permitted.
 205  */
 206 int
 207 _kvm_vnet_initialized(kvm_t *kd, int intialize)
 208 {
 209
 210         if (kd->vnet_initialized || !intialize)
 211                 return (kd->vnet_initialized);
 212
 213         (void) _kvm_vnet_selectpid(kd, getpid());
 214
 215         return (kd->vnet_initialized);
 216 }
 217
 218 /*
 219  * Check whether the value is within the vnet symbol range and
 220  * only if so adjust the offset relative to the current base.
 221  */
 222 uintptr_t
 223 _kvm_vnet_validaddr(kvm_t *kd, uintptr_t value)
 224 {
 225
 226         if (value == 0)
 227                 return (value);
 228
 229         if (!kd->vnet_initialized)
 230                 return (value);
 231
 232         if (value < kd->vnet_start || value >= kd->vnet_stop)
 233                 return (value);
 234
 235         return (kd->vnet_base + value);
 236 }