1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 
  25 #include <mdb/mdb_modapi.h>
  26 #include <mdb/mdb_ks.h>
  27 
  28 #include <sys/types.h>
  29 #include <sys/systm.h>
  30 #include <sys/door.h>
  31 #include <sys/file.h>
  32 #include <sys/mount.h>
  33 #include <sys/proc.h>
  34 #include <sys/procfs.h>
  35 #include <sys/proc/prdata.h>
  36 #include <sys/stat.h>
  37 #include <sys/vfs.h>
  38 #include <sys/vnode.h>
  39 #include <sys/fs/snode.h>
  40 #include <sys/fs/fifonode.h>
  41 #include <sys/fs/namenode.h>
  42 #include <sys/socket.h>
  43 #include <sys/stropts.h>
  44 #include <sys/socketvar.h>
  45 #include <sys/strsubr.h>
  46 #include <sys/un.h>
  47 #include <fs/sockfs/socktpi_impl.h>
  48 #include <inet/ipclassifier.h>
  49 #include <inet/ip_if.h>
  50 #include <inet/sctp/sctp_impl.h>
  51 #include <inet/sctp/sctp_addr.h>
  52 
  53 int
  54 vfs_walk_init(mdb_walk_state_t *wsp)
  55 {
  56         if (wsp->walk_addr == NULL &&
  57             mdb_readvar(&wsp->walk_addr, "rootvfs") == -1) {
  58                 mdb_warn("failed to read 'rootvfs'");
  59                 return (WALK_ERR);
  60         }
  61 
  62         wsp->walk_data = (void *)wsp->walk_addr;
  63         return (WALK_NEXT);
  64 }
  65 
  66 int
  67 vfs_walk_step(mdb_walk_state_t *wsp)
  68 {
  69         vfs_t vfs;
  70         int status;
  71 
  72         if (mdb_vread(&vfs, sizeof (vfs), wsp->walk_addr) == -1) {
  73                 mdb_warn("failed to read vfs_t at %p", wsp->walk_addr);
  74                 return (WALK_DONE);
  75         }
  76 
  77         status = wsp->walk_callback(wsp->walk_addr, &vfs, wsp->walk_cbdata);
  78 
  79         if (vfs.vfs_next == wsp->walk_data)
  80                 return (WALK_DONE);
  81 
  82         wsp->walk_addr = (uintptr_t)vfs.vfs_next;
  83 
  84         return (status);
  85 }
  86 
  87 /*
  88  * Utility routine to read in a filesystem name given a vfs pointer.  If
  89  * no vfssw entry for the vfs is available (as is the case with some pseudo-
  90  * filesystems), we check against some known problem fs's: doorfs and
  91  * portfs.  If that fails, we try to guess the filesystem name using
  92  * symbol names.  fsname should be a buffer of size _ST_FSTYPSZ.
  93  */
  94 static int
  95 read_fsname(uintptr_t vfsp, char *fsname)
  96 {
  97         vfs_t vfs;
  98         struct vfssw vfssw_entry;
  99         GElf_Sym vfssw_sym, test_sym;
 100         char testname[MDB_SYM_NAMLEN];
 101 
 102         if (mdb_vread(&vfs, sizeof (vfs), vfsp) == -1) {
 103                 mdb_warn("failed to read vfs %p", vfsp);
 104                 return (-1);
 105         }
 106 
 107         if (mdb_lookup_by_name("vfssw", &vfssw_sym) == -1) {
 108                 mdb_warn("failed to find vfssw");
 109                 return (-1);
 110         }
 111 
 112         /*
 113          * vfssw is an array; we need vfssw[vfs.vfs_fstype].
 114          */
 115         if (mdb_vread(&vfssw_entry, sizeof (vfssw_entry),
 116             vfssw_sym.st_value + (sizeof (struct vfssw) * vfs.vfs_fstype))
 117             == -1) {
 118                 mdb_warn("failed to read vfssw index %d", vfs.vfs_fstype);
 119                 return (-1);
 120         }
 121 
 122         if (vfs.vfs_fstype != 0) {
 123                 if (mdb_readstr(fsname, _ST_FSTYPSZ,
 124                     (uintptr_t)vfssw_entry.vsw_name) == -1) {
 125                         mdb_warn("failed to find fs name %p",
 126                             vfssw_entry.vsw_name);
 127                         return (-1);
 128                 }
 129                 return (0);
 130         }
 131 
 132         /*
 133          * Do precise detection for certain filesystem types that we
 134          * know do not appear in vfssw[], and that we depend upon in other
 135          * parts of the code: doorfs and portfs.
 136          */
 137         if (mdb_lookup_by_name("door_vfs", &test_sym) != -1) {
 138                 if (test_sym.st_value == vfsp) {
 139                         strcpy(fsname, "doorfs");
 140                         return (0);
 141                 }
 142         }
 143         if (mdb_lookup_by_name("port_vfs", &test_sym) != -1) {
 144                 if (test_sym.st_value == vfsp) {
 145                         strcpy(fsname, "portfs");
 146                         return (0);
 147                 }
 148         }
 149 
 150         /*
 151          * Heuristic detection for other filesystems that don't have a
 152          * vfssw[] entry.  These tend to be named <fsname>_vfs, so we do a
 153          * lookup_by_addr and see if we find a symbol of that name.
 154          */
 155         if (mdb_lookup_by_addr(vfsp, MDB_SYM_EXACT, testname, sizeof (testname),
 156             &test_sym) != -1) {
 157                 if ((strlen(testname) > 4) &&
 158                     (strcmp(testname + strlen(testname) - 4, "_vfs") == 0)) {
 159                         testname[strlen(testname) - 4] = '\0';
 160                         strncpy(fsname, testname, _ST_FSTYPSZ);
 161                         return (0);
 162                 }
 163         }
 164 
 165         mdb_warn("unknown filesystem type for vfs %p", vfsp);
 166         return (-1);
 167 }
 168 
 169 /*
 170  * Column widths for mount point display in ::fsinfo output.
 171  */
 172 #ifdef _LP64
 173 #define FSINFO_MNTLEN   48
 174 #else
 175 #define FSINFO_MNTLEN   56
 176 #endif
 177 
 178 /* ARGSUSED */
 179 int
 180 fsinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
 181 {
 182         vfs_t vfs;
 183         int len;
 184         int opt_v = 0;
 185         char buf[MAXPATHLEN];
 186         char fsname[_ST_FSTYPSZ];
 187         mntopt_t *mntopts;
 188         size_t size;
 189         int i;
 190         int first = 1;
 191         char opt[MAX_MNTOPT_STR];
 192         uintptr_t global_zone;
 193 
 194         if (!(flags & DCMD_ADDRSPEC)) {
 195                 if (mdb_walk_dcmd("vfs", "fsinfo", argc, argv) == -1) {
 196                         mdb_warn("failed to walk file system list");
 197                         return (DCMD_ERR);
 198                 }
 199                 return (DCMD_OK);
 200         }
 201 
 202         if (mdb_getopts(argc, argv,
 203             'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
 204                 return (DCMD_USAGE);
 205 
 206         if (DCMD_HDRSPEC(flags))
 207                 mdb_printf("%<u>%?s %-15s %s%</u>\n",
 208                     "VFSP", "FS", "MOUNT");
 209 
 210         if (mdb_vread(&vfs, sizeof (vfs), addr) == -1) {
 211                 mdb_warn("failed to read vfs_t %p", addr);
 212                 return (DCMD_ERR);
 213         }
 214 
 215         if ((len = mdb_read_refstr((uintptr_t)vfs.vfs_mntpt, buf,
 216             sizeof (buf))) <= 0)
 217                 strcpy(buf, "??");
 218 
 219         else if (!opt_v && (len >= FSINFO_MNTLEN))
 220                 /*
 221                  * In normal mode, we truncate the path to keep the output
 222                  * clean.  In -v mode, we just print the full path.
 223                  */
 224                 strcpy(&buf[FSINFO_MNTLEN - 4], "...");
 225 
 226         if (read_fsname(addr, fsname) == -1)
 227                 return (DCMD_ERR);
 228 
 229         mdb_printf("%0?p %-15s %s\n", addr, fsname, buf);
 230 
 231         if (!opt_v)
 232                 return (DCMD_OK);
 233 
 234         /*
 235          * Print 'resource' string; this shows what we're mounted upon.
 236          */
 237         if (mdb_read_refstr((uintptr_t)vfs.vfs_resource, buf,
 238             MAXPATHLEN) <= 0)
 239                 strcpy(buf, "??");
 240 
 241         mdb_printf("%?s %s\n", "R:", buf);
 242 
 243         /*
 244          * Print mount options array; it sucks to be a mimic, but we copy
 245          * the same logic as in mntvnops.c for adding zone= tags, and we
 246          * don't bother with the obsolete dev= option.
 247          */
 248         size = vfs.vfs_mntopts.mo_count * sizeof (mntopt_t);
 249         mntopts = mdb_alloc(size, UM_SLEEP | UM_GC);
 250 
 251         if (mdb_vread(mntopts, size,
 252             (uintptr_t)vfs.vfs_mntopts.mo_list) == -1) {
 253                 mdb_warn("failed to read mntopts %p", vfs.vfs_mntopts.mo_list);
 254                 return (DCMD_ERR);
 255         }
 256 
 257         for (i = 0; i < vfs.vfs_mntopts.mo_count; i++) {
 258                 if (mntopts[i].mo_flags & MO_SET) {
 259                         if (mdb_readstr(opt, sizeof (opt),
 260                             (uintptr_t)mntopts[i].mo_name) == -1) {
 261                                 mdb_warn("failed to read mntopt name %p",
 262                                     mntopts[i].mo_name);
 263                                 return (DCMD_ERR);
 264                         }
 265                         if (first) {
 266                                 mdb_printf("%?s ", "O:");
 267                                 first = 0;
 268                         } else {
 269                                 mdb_printf(",");
 270                         }
 271                         mdb_printf("%s", opt);
 272                         if (mntopts[i].mo_flags & MO_HASVALUE) {
 273                                 if (mdb_readstr(opt, sizeof (opt),
 274                                     (uintptr_t)mntopts[i].mo_arg) == -1) {
 275                                         mdb_warn("failed to read mntopt "
 276                                             "value %p", mntopts[i].mo_arg);
 277                                         return (DCMD_ERR);
 278                                 }
 279                                 mdb_printf("=%s", opt);
 280                         }
 281                 }
 282         }
 283 
 284         if (mdb_readvar(&global_zone, "global_zone") == -1) {
 285                 mdb_warn("failed to locate global_zone");
 286                 return (DCMD_ERR);
 287         }
 288 
 289         if ((vfs.vfs_zone != NULL) &&
 290             ((uintptr_t)vfs.vfs_zone != global_zone)) {
 291                 zone_t z;
 292 
 293                 if (mdb_vread(&z, sizeof (z), (uintptr_t)vfs.vfs_zone) == -1) {
 294                         mdb_warn("failed to read zone");
 295                         return (DCMD_ERR);
 296                 }
 297                 /*
 298                  * zone names are much shorter than MAX_MNTOPT_STR
 299                  */
 300                 if (mdb_readstr(opt, sizeof (opt),
 301                     (uintptr_t)z.zone_name) == -1) {
 302                         mdb_warn("failed to read zone name");
 303                         return (DCMD_ERR);
 304                 }
 305                 if (first) {
 306                         mdb_printf("%?s ", "O:");
 307                 } else {
 308                         mdb_printf(",");
 309                 }
 310                 mdb_printf("zone=%s", opt);
 311         }
 312         return (DCMD_OK);
 313 }
 314 
 315 
 316 #define REALVP_DONE     0
 317 #define REALVP_ERR      1
 318 #define REALVP_CONTINUE 2
 319 
 320 static int
 321 next_realvp(uintptr_t invp, struct vnode *outvn, uintptr_t *outvp)
 322 {
 323         char fsname[_ST_FSTYPSZ];
 324 
 325         *outvp = invp;
 326         if (mdb_vread(outvn, sizeof (struct vnode), invp) == -1) {
 327                 mdb_warn("failed to read vnode at %p", invp);
 328                 return (REALVP_ERR);
 329         }
 330 
 331         if (read_fsname((uintptr_t)outvn->v_vfsp, fsname) == -1)
 332                 return (REALVP_ERR);
 333 
 334         /*
 335          * We know how to do 'realvp' for as many filesystems as possible;
 336          * for all other filesystems, we assume that the vp we are given
 337          * is the realvp.  In the kernel, a realvp operation will sometimes
 338          * dig through multiple layers.  Here, we only fetch the pointer
 339          * to the next layer down.  This allows dcmds to print out the
 340          * various layers.
 341          */
 342         if (strcmp(fsname, "fifofs") == 0) {
 343                 fifonode_t fn;
 344                 if (mdb_vread(&fn, sizeof (fn),
 345                     (uintptr_t)outvn->v_data) == -1) {
 346                         mdb_warn("failed to read fifonode");
 347                         return (REALVP_ERR);
 348                 }
 349                 *outvp = (uintptr_t)fn.fn_realvp;
 350 
 351         } else if (strcmp(fsname, "namefs") == 0) {
 352                 struct namenode nn;
 353                 if (mdb_vread(&nn, sizeof (nn),
 354                     (uintptr_t)outvn->v_data) == -1) {
 355                         mdb_warn("failed to read namenode");
 356                         return (REALVP_ERR);
 357                 }
 358                 *outvp = (uintptr_t)nn.nm_filevp;
 359 
 360         } else if (outvn->v_type == VSOCK && outvn->v_stream != NULL) {
 361                 struct stdata stream;
 362 
 363                 /*
 364                  * Sockets have a strange and different layering scheme; we
 365                  * hop over into the sockfs vnode (accessible via the stream
 366                  * head) if possible.
 367                  */
 368                 if (mdb_vread(&stream, sizeof (stream),
 369                     (uintptr_t)outvn->v_stream) == -1) {
 370                         mdb_warn("failed to read stream data");
 371                         return (REALVP_ERR);
 372                 }
 373                 *outvp = (uintptr_t)stream.sd_vnode;
 374         }
 375 
 376         if (*outvp == invp || *outvp == NULL)
 377                 return (REALVP_DONE);
 378 
 379         return (REALVP_CONTINUE);
 380 }
 381 
 382 static void
 383 pfiles_print_addr(struct sockaddr *addr)
 384 {
 385         struct sockaddr_in *s_in;
 386         struct sockaddr_un *s_un;
 387         struct sockaddr_in6 *s_in6;
 388         in_port_t port;
 389 
 390         switch (addr->sa_family) {
 391         case AF_INET:
 392                 /* LINTED: alignment */
 393                 s_in = (struct sockaddr_in *)addr;
 394                 mdb_nhconvert(&port, &s_in->sin_port, sizeof (port));
 395                 mdb_printf("AF_INET %I %d ", s_in->sin_addr.s_addr, port);
 396                 break;
 397 
 398         case AF_INET6:
 399                 /* LINTED: alignment */
 400                 s_in6 = (struct sockaddr_in6 *)addr;
 401                 mdb_nhconvert(&port, &s_in6->sin6_port, sizeof (port));
 402                 mdb_printf("AF_INET6 %N %d ", &(s_in6->sin6_addr), port);
 403                 break;
 404 
 405         case AF_UNIX:
 406                 s_un = (struct sockaddr_un *)addr;
 407                 mdb_printf("AF_UNIX %s ", s_un->sun_path);
 408                 break;
 409         default:
 410                 mdb_printf("AF_?? (%d) ", addr->sa_family);
 411                 break;
 412         }
 413 }
 414 
 415 static int
 416 pfiles_get_sonode(vnode_t *v_sock, struct sonode *sonode)
 417 {
 418         if (mdb_vread(sonode, sizeof (struct sonode),
 419             (uintptr_t)v_sock->v_data) == -1) {
 420                 mdb_warn("failed to read sonode");
 421                 return (-1);
 422         }
 423 
 424         return (0);
 425 }
 426 
 427 static int
 428 pfiles_get_tpi_sonode(vnode_t *v_sock, sotpi_sonode_t *sotpi_sonode)
 429 {
 430 
 431         struct stdata stream;
 432 
 433         if (mdb_vread(&stream, sizeof (stream),
 434             (uintptr_t)v_sock->v_stream) == -1) {
 435                 mdb_warn("failed to read stream data");
 436                 return (-1);
 437         }
 438 
 439         if (mdb_vread(v_sock, sizeof (vnode_t),
 440             (uintptr_t)stream.sd_vnode) == -1) {
 441                 mdb_warn("failed to read stream vnode");
 442                 return (-1);
 443         }
 444 
 445         if (mdb_vread(sotpi_sonode, sizeof (sotpi_sonode_t),
 446             (uintptr_t)v_sock->v_data) == -1) {
 447                 mdb_warn("failed to read sotpi_sonode");
 448                 return (-1);
 449         }
 450 
 451         return (0);
 452 }
 453 
 454 /*
 455  * Do some digging to get a reasonable pathname for this vnode. 'path'
 456  * should point at a buffer of MAXPATHLEN in size.
 457  */
 458 static int
 459 pfiles_dig_pathname(uintptr_t vp, char *path)
 460 {
 461         vnode_t v;
 462 
 463         bzero(path, MAXPATHLEN);
 464 
 465         if (mdb_vread(&v, sizeof (v), vp) == -1) {
 466                 mdb_warn("failed to read vnode");
 467                 return (-1);
 468         }
 469 
 470         if (v.v_path == NULL) {
 471                 /*
 472                  * fifo's and doors are special.   Some have pathnames, and
 473                  * some do not.  And for these, it is pointless to go off to
 474                  * mdb_vnode2path, which is very slow.
 475                  *
 476                  * Event ports never have a pathname.
 477                  */
 478                 if (v.v_type == VFIFO || v.v_type == VDOOR || v.v_type == VPORT)
 479                         return (0);
 480 
 481                 /*
 482                  * For sockets, we won't find a path unless we print the path
 483                  * associated with transport's STREAM device.
 484                  */
 485                 if (v.v_type == VSOCK) {
 486                         struct sonode sonode;
 487                         struct sockparams sockparams;
 488 
 489                         if (pfiles_get_sonode(&v, &sonode) == -1) {
 490                                 return (-1);
 491                         }
 492                         if (mdb_vread(&sockparams, sizeof (sockparams),
 493                             (uintptr_t)sonode.so_sockparams) == -1) {
 494                                 mdb_warn("failed to read sockparams");
 495                                 return (-1);
 496                         }
 497 
 498                         if (!SOCK_IS_NONSTR(&sonode)) {
 499                                 vp = (uintptr_t)
 500                                     sockparams.sp_sdev_info.sd_vnode;
 501                         } else {
 502                                 vp = NULL;
 503                         }
 504                 }
 505         }
 506 
 507 
 508         /*
 509          * mdb_vnode2path will print an error for us as needed, but not
 510          * finding a pathname is not really an error, so we plow on.
 511          */
 512         (void) mdb_vnode2path(vp, path, MAXPATHLEN);
 513 
 514         /*
 515          * A common problem is that device pathnames are prefixed with
 516          * /dev/../devices/.  We just clean those up slightly:
 517          *      /dev/../devices/<mumble> --> /devices/<mumble>
 518          *      /dev/pts/../../devices/<mumble> --> /devices/<mumble>
 519          */
 520         if (strncmp("/dev/../devices/", path, strlen("/dev/../devices/")) == 0)
 521                 strcpy(path, path + 7);
 522 
 523         if (strncmp("/dev/pts/../../devices/", path,
 524             strlen("/dev/pts/../../devices/")) == 0)
 525                 strcpy(path, path + 14);
 526 
 527         return (0);
 528 }
 529 
 530 const struct fs_type {
 531         int type;
 532         const char *name;
 533 } fs_types[] = {
 534         { VNON,   "NON" },
 535         { VREG,   "REG" },
 536         { VDIR,   "DIR" },
 537         { VBLK,   "BLK" },
 538         { VCHR,   "CHR" },
 539         { VLNK,   "LNK" },
 540         { VFIFO,  "FIFO" },
 541         { VDOOR,  "DOOR" },
 542         { VPROC,  "PROC" },
 543         { VSOCK,  "SOCK" },
 544         { VPORT,  "PORT" },
 545         { VBAD,   "BAD" }
 546 };
 547 
 548 #define NUM_FS_TYPES (sizeof (fs_types) / sizeof (struct fs_type))
 549 
 550 struct pfiles_cbdata {
 551         int opt_p;
 552         int fd;
 553 };
 554 
 555 #define list_d2l(a, obj) ((list_node_t *)(((char *)obj) + (a)->list_offset))
 556 #define list_object(a, node) ((void *)(((char *)node) - (a)->list_offset))
 557 
 558 /*
 559  * SCTP interface for geting the first source address of a sctp_t.
 560  */
 561 int
 562 sctp_getsockaddr(sctp_t *sctp, struct sockaddr *addr)
 563 {
 564         int                     err = -1;
 565         int                     i;
 566         int                     l;
 567         sctp_saddr_ipif_t       *pobj;
 568         sctp_saddr_ipif_t       obj;
 569         size_t                  added = 0;
 570         sin6_t                  *sin6;
 571         sin_t                   *sin4;
 572         int                     scanned = 0;
 573         boolean_t               skip_lback = B_FALSE;
 574         conn_t                  *connp = sctp->sctp_connp;
 575 
 576         addr->sa_family = connp->conn_family;
 577         if (sctp->sctp_nsaddrs == 0)
 578                 goto done;
 579 
 580         /*
 581          * Skip loopback addresses for non-loopback assoc.
 582          */
 583         if (sctp->sctp_state >= SCTPS_ESTABLISHED && !sctp->sctp_loopback) {
 584                 skip_lback = B_TRUE;
 585         }
 586 
 587         for (i = 0; i < SCTP_IPIF_HASH; i++) {
 588                 if (sctp->sctp_saddrs[i].ipif_count == 0)
 589                         continue;
 590 
 591                 pobj = list_object(&sctp->sctp_saddrs[i].sctp_ipif_list,
 592                     sctp->sctp_saddrs[i].sctp_ipif_list.list_head.list_next);
 593                 if (mdb_vread(&obj, sizeof (sctp_saddr_ipif_t),
 594                     (uintptr_t)pobj) == -1) {
 595                         mdb_warn("failed to read sctp_saddr_ipif_t");
 596                         return (err);
 597                 }
 598 
 599                 for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) {
 600                         sctp_ipif_t     ipif;
 601                         in6_addr_t      laddr;
 602                         list_node_t     *pnode;
 603                         list_node_t     node;
 604 
 605                         if (mdb_vread(&ipif, sizeof (sctp_ipif_t),
 606                             (uintptr_t)obj.saddr_ipifp) == -1) {
 607                                 mdb_warn("failed to read sctp_ipif_t");
 608                                 return (err);
 609                         }
 610                         laddr = ipif.sctp_ipif_saddr;
 611 
 612                         scanned++;
 613                         if ((ipif.sctp_ipif_state == SCTP_IPIFS_CONDEMNED) ||
 614                             SCTP_DONT_SRC(&obj) ||
 615                             (ipif.sctp_ipif_ill->sctp_ill_flags &
 616                             PHYI_LOOPBACK) && skip_lback) {
 617                                 if (scanned >= sctp->sctp_nsaddrs)
 618                                         goto done;
 619 
 620                                 /* LINTED: alignment */
 621                                 pnode = list_d2l(&sctp->sctp_saddrs[i].
 622                                     sctp_ipif_list, pobj);
 623                                 if (mdb_vread(&node, sizeof (list_node_t),
 624                                     (uintptr_t)pnode) == -1) {
 625                                         mdb_warn("failed to read list_node_t");
 626                                         return (err);
 627                                 }
 628                                 pobj = list_object(&sctp->sctp_saddrs[i].
 629                                     sctp_ipif_list, node.list_next);
 630                                 if (mdb_vread(&obj, sizeof (sctp_saddr_ipif_t),
 631                                     (uintptr_t)pobj) == -1) {
 632                                         mdb_warn("failed to read "
 633                                             "sctp_saddr_ipif_t");
 634                                         return (err);
 635                                 }
 636                                 continue;
 637                         }
 638 
 639                         switch (connp->conn_family) {
 640                         case AF_INET:
 641                                 /* LINTED: alignment */
 642                                 sin4 = (sin_t *)addr;
 643                                 if ((sctp->sctp_state <= SCTPS_LISTEN) &&
 644                                     sctp->sctp_bound_to_all) {
 645                                         sin4->sin_addr.s_addr = INADDR_ANY;
 646                                         sin4->sin_port = connp->conn_lport;
 647                                 } else {
 648                                         sin4 += added;
 649                                         sin4->sin_family = AF_INET;
 650                                         sin4->sin_port = connp->conn_lport;
 651                                         IN6_V4MAPPED_TO_INADDR(&laddr,
 652                                             &sin4->sin_addr);
 653                                 }
 654                                 break;
 655 
 656                         case AF_INET6:
 657                                 /* LINTED: alignment */
 658                                 sin6 = (sin6_t *)addr;
 659                                 if ((sctp->sctp_state <= SCTPS_LISTEN) &&
 660                                     sctp->sctp_bound_to_all) {
 661                                         bzero(&sin6->sin6_addr,
 662                                             sizeof (sin6->sin6_addr));
 663                                         sin6->sin6_port = connp->conn_lport;
 664                                 } else {
 665                                         sin6 += added;
 666                                         sin6->sin6_family = AF_INET6;
 667                                         sin6->sin6_port = connp->conn_lport;
 668                                         sin6->sin6_addr = laddr;
 669                                 }
 670                                 sin6->sin6_flowinfo = connp->conn_flowinfo;
 671                                 sin6->sin6_scope_id = 0;
 672                                 sin6->__sin6_src_id = 0;
 673                                 break;
 674                         }
 675                         added++;
 676                         if (added >= 1) {
 677                                 err = 0;
 678                                 goto done;
 679                         }
 680                         if (scanned >= sctp->sctp_nsaddrs)
 681                                 goto done;
 682 
 683                         /* LINTED: alignment */
 684                         pnode = list_d2l(&sctp->sctp_saddrs[i].sctp_ipif_list,
 685                             pobj);
 686                         if (mdb_vread(&node, sizeof (list_node_t),
 687                             (uintptr_t)pnode) == -1) {
 688                                 mdb_warn("failed to read list_node_t");
 689                                 return (err);
 690                         }
 691                         pobj = list_object(&sctp->sctp_saddrs[i].
 692                             sctp_ipif_list, node.list_next);
 693                         if (mdb_vread(&obj, sizeof (sctp_saddr_ipif_t),
 694                             (uintptr_t)pobj) == -1) {
 695                                 mdb_warn("failed to read sctp_saddr_ipif_t");
 696                                 return (err);
 697                         }
 698                 }
 699         }
 700 done:
 701         return (err);
 702 }
 703 
 704 /*
 705  * SCTP interface for geting the primary peer address of a sctp_t.
 706  */
 707 static int
 708 sctp_getpeeraddr(sctp_t *sctp, struct sockaddr *addr)
 709 {
 710         struct sockaddr_in      *sin4;
 711         struct sockaddr_in6     *sin6;
 712         sctp_faddr_t            sctp_primary;
 713         in6_addr_t              faddr;
 714         conn_t                  *connp = sctp->sctp_connp;
 715 
 716         if (sctp->sctp_faddrs == NULL)
 717                 return (-1);
 718 
 719         addr->sa_family = connp->conn_family;
 720         if (mdb_vread(&sctp_primary, sizeof (sctp_faddr_t),
 721             (uintptr_t)sctp->sctp_primary) == -1) {
 722                 mdb_warn("failed to read sctp primary faddr");
 723                 return (-1);
 724         }
 725         faddr = sctp_primary.sf_faddr;
 726 
 727         switch (connp->conn_family) {
 728         case AF_INET:
 729                 /* LINTED: alignment */
 730                 sin4 = (struct sockaddr_in *)addr;
 731                 IN6_V4MAPPED_TO_INADDR(&faddr, &sin4->sin_addr);
 732                 sin4->sin_port = connp->conn_fport;
 733                 sin4->sin_family = AF_INET;
 734                 break;
 735 
 736         case AF_INET6:
 737                 /* LINTED: alignment */
 738                 sin6 = (struct sockaddr_in6 *)addr;
 739                 sin6->sin6_addr = faddr;
 740                 sin6->sin6_port = connp->conn_fport;
 741                 sin6->sin6_family = AF_INET6;
 742                 sin6->sin6_flowinfo = 0;
 743                 sin6->sin6_scope_id = 0;
 744                 sin6->__sin6_src_id = 0;
 745                 break;
 746         }
 747 
 748         return (0);
 749 }
 750 
 751 static int
 752 tpi_sock_print(sotpi_sonode_t *sotpi_sonode)
 753 {
 754         if (sotpi_sonode->st_info.sti_laddr_valid == 1) {
 755                 struct sockaddr *laddr =
 756                     mdb_alloc(sotpi_sonode->st_info.sti_laddr_len, UM_SLEEP);
 757                 if (mdb_vread(laddr, sotpi_sonode->st_info.sti_laddr_len,
 758                     (uintptr_t)sotpi_sonode->st_info.sti_laddr_sa) == -1) {
 759                         mdb_warn("failed to read sotpi_sonode socket addr");
 760                         return (-1);
 761                 }
 762 
 763                 mdb_printf("socket: ");
 764                 pfiles_print_addr(laddr);
 765         }
 766 
 767         if (sotpi_sonode->st_info.sti_faddr_valid == 1) {
 768                 struct sockaddr *faddr =
 769                     mdb_alloc(sotpi_sonode->st_info.sti_faddr_len, UM_SLEEP);
 770                 if (mdb_vread(faddr, sotpi_sonode->st_info.sti_faddr_len,
 771                     (uintptr_t)sotpi_sonode->st_info.sti_faddr_sa) == -1) {
 772                         mdb_warn("failed to read sotpi_sonode remote addr");
 773                         return (-1);
 774                 }
 775 
 776                 mdb_printf("remote: ");
 777                 pfiles_print_addr(faddr);
 778         }
 779 
 780         return (0);
 781 }
 782 
 783 static int
 784 tcpip_sock_print(struct sonode *socknode)
 785 {
 786         switch (socknode->so_family) {
 787         case AF_INET:
 788         {
 789                 conn_t conn_t;
 790                 in_port_t port;
 791 
 792                 if (mdb_vread(&conn_t, sizeof (conn_t),
 793                     (uintptr_t)socknode->so_proto_handle) == -1) {
 794                         mdb_warn("failed to read conn_t V4");
 795                         return (-1);
 796                 }
 797 
 798                 mdb_printf("socket: ");
 799                 mdb_nhconvert(&port, &conn_t.conn_lport, sizeof (port));
 800                 mdb_printf("AF_INET %I %d ", conn_t.conn_laddr_v4, port);
 801 
 802                 /*
 803                  * If this is a listening socket, we don't print
 804                  * the remote address.
 805                  */
 806                 if (IPCL_IS_TCP(&conn_t) && IPCL_IS_BOUND(&conn_t) == 0 ||
 807                     IPCL_IS_UDP(&conn_t) && IPCL_IS_CONNECTED(&conn_t)) {
 808                         mdb_printf("remote: ");
 809                         mdb_nhconvert(&port, &conn_t.conn_fport, sizeof (port));
 810                         mdb_printf("AF_INET %I %d ", conn_t.conn_faddr_v4,
 811                             port);
 812                 }
 813 
 814                 break;
 815         }
 816 
 817         case AF_INET6:
 818         {
 819                 conn_t conn_t;
 820                 in_port_t port;
 821 
 822                 if (mdb_vread(&conn_t, sizeof (conn_t),
 823                     (uintptr_t)socknode->so_proto_handle) == -1) {
 824                         mdb_warn("failed to read conn_t V6");
 825                         return (-1);
 826                 }
 827 
 828                 mdb_printf("socket: ");
 829                 mdb_nhconvert(&port, &conn_t.conn_lport, sizeof (port));
 830                 mdb_printf("AF_INET6 %N %d ", &conn_t.conn_laddr_v4, port);
 831 
 832                 /*
 833                  * If this is a listening socket, we don't print
 834                  * the remote address.
 835                  */
 836                 if (IPCL_IS_TCP(&conn_t) && IPCL_IS_BOUND(&conn_t) == 0 ||
 837                     IPCL_IS_UDP(&conn_t) && IPCL_IS_CONNECTED(&conn_t)) {
 838                         mdb_printf("remote: ");
 839                         mdb_nhconvert(&port, &conn_t.conn_fport, sizeof (port));
 840                         mdb_printf("AF_INET6 %N %d ", &conn_t.conn_faddr_v6,
 841                             port);
 842                 }
 843 
 844                 break;
 845         }
 846 
 847         default:
 848                 mdb_printf("AF_?? (%d)", socknode->so_family);
 849                 break;
 850         }
 851 
 852         return (0);
 853 }
 854 
 855 static int
 856 sctp_sock_print(struct sonode *socknode)
 857 {
 858         sctp_t sctp_t;
 859         conn_t conns;
 860 
 861         struct sockaddr *laddr = mdb_alloc(sizeof (struct sockaddr), UM_SLEEP);
 862         struct sockaddr *faddr = mdb_alloc(sizeof (struct sockaddr), UM_SLEEP);
 863 
 864         if (mdb_vread(&sctp_t, sizeof (sctp_t),
 865             (uintptr_t)socknode->so_proto_handle) == -1) {
 866                 mdb_warn("failed to read sctp_t");
 867                 return (-1);
 868         }
 869 
 870         if (mdb_vread(&conns, sizeof (conn_t),
 871             (uintptr_t)sctp_t.sctp_connp) == -1) {
 872                 mdb_warn("failed to read conn_t at %p",
 873                     (uintptr_t)sctp_t.sctp_connp);
 874                 return (-1);
 875         }
 876         sctp_t.sctp_connp = &conns;
 877 
 878         if (sctp_getsockaddr(&sctp_t, laddr) == 0) {
 879                 mdb_printf("socket:");
 880                 pfiles_print_addr(laddr);
 881         }
 882         if (sctp_getpeeraddr(&sctp_t, faddr) == 0) {
 883                 mdb_printf("remote:");
 884                 pfiles_print_addr(faddr);
 885         }
 886 
 887         return (0);
 888 }
 889 
 890 /* ARGSUSED */
 891 static int
 892 sdp_sock_print(struct sonode *socknode)
 893 {
 894         return (0);
 895 }
 896 
 897 struct sock_print {
 898         int     family;
 899         int     type;
 900         int     pro;
 901         int     (*print)(struct sonode *socknode);
 902 } sock_prints[] = {
 903         { 2,    2,      0,      tcpip_sock_print },     /* /dev/tcp     */
 904         { 2,    2,      6,      tcpip_sock_print },     /* /dev/tcp     */
 905         { 26,   2,      0,      tcpip_sock_print },     /* /dev/tcp6    */
 906         { 26,   2,      6,      tcpip_sock_print },     /* /dev/tcp6    */
 907         { 2,    1,      0,      tcpip_sock_print },     /* /dev/udp     */
 908         { 2,    1,      17,     tcpip_sock_print },     /* /dev/udp     */
 909         { 26,   1,      0,      tcpip_sock_print },     /* /dev/udp6    */
 910         { 26,   1,      17,     tcpip_sock_print },     /* /dev/udp6    */
 911         { 2,    4,      0,      tcpip_sock_print },     /* /dev/rawip   */
 912         { 26,   4,      0,      tcpip_sock_print },     /* /dev/rawip6  */
 913         { 2,    2,      132,    sctp_sock_print },      /* /dev/sctp    */
 914         { 26,   2,      132,    sctp_sock_print },      /* /dev/sctp6   */
 915         { 2,    6,      132,    sctp_sock_print },      /* /dev/sctp    */
 916         { 26,   6,      132,    sctp_sock_print },      /* /dev/sctp6   */
 917         { 24,   4,      0,      tcpip_sock_print },     /* /dev/rts     */
 918         { 2,    2,      257,    sdp_sock_print },       /* /dev/sdp     */
 919         { 26,   2,      257,    sdp_sock_print },       /* /dev/sdp     */
 920 };
 921 
 922 #define NUM_SOCK_PRINTS                                         \
 923         (sizeof (sock_prints) / sizeof (struct sock_print))
 924 
 925 static int
 926 pfile_callback(uintptr_t addr, const struct file *f, struct pfiles_cbdata *cb)
 927 {
 928         vnode_t v, layer_vn;
 929         int myfd = cb->fd;
 930         const char *type;
 931         char path[MAXPATHLEN];
 932         uintptr_t top_vnodep, realvpp;
 933         char fsname[_ST_FSTYPSZ];
 934         int err, i;
 935 
 936         cb->fd++;
 937 
 938         if (addr == NULL) {
 939                 return (WALK_NEXT);
 940         }
 941 
 942         top_vnodep = realvpp = (uintptr_t)f->f_vnode;
 943 
 944         if (mdb_vread(&v, sizeof (v), realvpp) == -1) {
 945                 mdb_warn("failed to read vnode");
 946                 return (DCMD_ERR);
 947         }
 948 
 949         type = "?";
 950         for (i = 0; i <= NUM_FS_TYPES; i++) {
 951                 if (fs_types[i].type == v.v_type)
 952                         type = fs_types[i].name;
 953         }
 954 
 955         do {
 956                 uintptr_t next_realvpp;
 957 
 958                 err = next_realvp(realvpp, &layer_vn, &next_realvpp);
 959                 if (next_realvpp != NULL)
 960                         realvpp = next_realvpp;
 961 
 962         } while (err == REALVP_CONTINUE);
 963 
 964         if (err == REALVP_ERR) {
 965                 mdb_warn("failed to do realvp() for %p", realvpp);
 966                 return (DCMD_ERR);
 967         }
 968 
 969         if (read_fsname((uintptr_t)layer_vn.v_vfsp, fsname) == -1)
 970                 return (DCMD_ERR);
 971 
 972         mdb_printf("%4d %4s %?0p ", myfd, type, top_vnodep);
 973 
 974         if (cb->opt_p) {
 975                 if (pfiles_dig_pathname(top_vnodep, path) == -1)
 976                         return (DCMD_ERR);
 977 
 978                 mdb_printf("%s\n", path);
 979                 return (DCMD_OK);
 980         }
 981 
 982         /*
 983          * Sockets generally don't have interesting pathnames; we only
 984          * show those in the '-p' view.
 985          */
 986         path[0] = '\0';
 987         if (v.v_type != VSOCK) {
 988                 if (pfiles_dig_pathname(top_vnodep, path) == -1)
 989                         return (DCMD_ERR);
 990         }
 991         mdb_printf("%s%s", path, path[0] == '\0' ? "" : " ");
 992 
 993         switch (v.v_type) {
 994         case VDOOR:
 995         {
 996                 door_node_t doornode;
 997                 proc_t pr;
 998 
 999                 if (mdb_vread(&doornode, sizeof (doornode),
1000                     (uintptr_t)layer_vn.v_data) == -1) {
1001                         mdb_warn("failed to read door_node");
1002                         return (DCMD_ERR);
1003                 }
1004 
1005                 if (mdb_vread(&pr, sizeof (pr),
1006                     (uintptr_t)doornode.door_target) == -1) {
1007                         mdb_warn("failed to read door server process %p",
1008                             doornode.door_target);
1009                         return (DCMD_ERR);
1010                 }
1011                 mdb_printf("[door to '%s' (proc=%p)]", pr.p_user.u_comm,
1012                     doornode.door_target);
1013                 break;
1014         }
1015 
1016         case VSOCK:
1017         {
1018                 vnode_t v_sock;
1019                 struct sonode so;
1020 
1021                 if (mdb_vread(&v_sock, sizeof (v_sock), realvpp) == -1) {
1022                         mdb_warn("failed to read socket vnode");
1023                         return (DCMD_ERR);
1024                 }
1025 
1026                 /*
1027                  * Sockets can be non-stream or stream, they have to be dealed
1028                  * with differently.
1029                  */
1030                 if (v_sock.v_stream == NULL) {
1031                         if (pfiles_get_sonode(&v_sock, &so) == -1)
1032                                 return (DCMD_ERR);
1033 
1034                         /* Pick the proper methods. */
1035                         for (i = 0; i <= NUM_SOCK_PRINTS; i++) {
1036                                 if ((sock_prints[i].family == so.so_family &&
1037                                     sock_prints[i].type == so.so_type &&
1038                                     sock_prints[i].pro == so.so_protocol) ||
1039                                     (sock_prints[i].family == so.so_family &&
1040                                     sock_prints[i].type == so.so_type &&
1041                                     so.so_type == SOCK_RAW)) {
1042                                         if ((*sock_prints[i].print)(&so) == -1)
1043                                                 return (DCMD_ERR);
1044                                 }
1045                         }
1046                 } else {
1047                         sotpi_sonode_t sotpi_sonode;
1048 
1049                         if (pfiles_get_sonode(&v_sock, &so) == -1)
1050                                 return (DCMD_ERR);
1051 
1052                         /*
1053                          * If the socket is a fallback socket, read its related
1054                          * information separately; otherwise, read it as a whole
1055                          * tpi socket.
1056                          */
1057                         if (so.so_state & SS_FALLBACK_COMP) {
1058                                 sotpi_sonode.st_sonode = so;
1059 
1060                                 if (mdb_vread(&(sotpi_sonode.st_info),
1061                                     sizeof (sotpi_info_t),
1062                                     (uintptr_t)so.so_priv) == -1)
1063                                         return (DCMD_ERR);
1064                         } else {
1065                                 if (pfiles_get_tpi_sonode(&v_sock,
1066                                     &sotpi_sonode) == -1)
1067                                         return (DCMD_ERR);
1068                         }
1069 
1070                         if (tpi_sock_print(&sotpi_sonode) == -1)
1071                                 return (DCMD_ERR);
1072                 }
1073 
1074                 break;
1075         }
1076 
1077         case VPORT:
1078                 mdb_printf("[event port (port=%p)]", v.v_data);
1079                 break;
1080 
1081         case VPROC:
1082         {
1083                 prnode_t prnode;
1084                 prcommon_t prcommon;
1085 
1086                 if (mdb_vread(&prnode, sizeof (prnode),
1087                     (uintptr_t)layer_vn.v_data) == -1) {
1088                         mdb_warn("failed to read prnode");
1089                         return (DCMD_ERR);
1090                 }
1091 
1092                 if (mdb_vread(&prcommon, sizeof (prcommon),
1093                     (uintptr_t)prnode.pr_common) == -1) {
1094                         mdb_warn("failed to read prcommon %p",
1095                             prnode.pr_common);
1096                         return (DCMD_ERR);
1097                 }
1098 
1099                 mdb_printf("(proc=%p)", prcommon.prc_proc);
1100                 break;
1101         }
1102 
1103         default:
1104                 break;
1105         }
1106 
1107         mdb_printf("\n");
1108 
1109         return (WALK_NEXT);
1110 }
1111 
1112 static int
1113 file_t_callback(uintptr_t addr, const struct file *f, struct pfiles_cbdata *cb)
1114 {
1115         int myfd = cb->fd;
1116 
1117         cb->fd++;
1118 
1119         if (addr == NULL) {
1120                 return (WALK_NEXT);
1121         }
1122 
1123         /*
1124          * We really need 20 digits to print a 64-bit offset_t, but this
1125          * is exceedingly rare, so we cheat and assume a column width of 10
1126          * digits, in order to fit everything cleanly into 80 columns.
1127          */
1128         mdb_printf("%?0p %4d %8x %?0p %10lld %?0p %4d\n",
1129             addr, myfd, f->f_flag, f->f_vnode, f->f_offset, f->f_cred,
1130             f->f_count);
1131 
1132         return (WALK_NEXT);
1133 }
1134 
1135 int
1136 pfiles(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1137 {
1138         int opt_f = 0;
1139 
1140         struct pfiles_cbdata cb;
1141 
1142         bzero(&cb, sizeof (cb));
1143 
1144         if (!(flags & DCMD_ADDRSPEC))
1145                 return (DCMD_USAGE);
1146 
1147         if (mdb_getopts(argc, argv,
1148             'p', MDB_OPT_SETBITS, TRUE, &cb.opt_p,
1149             'f', MDB_OPT_SETBITS, TRUE, &opt_f, NULL) != argc)
1150                 return (DCMD_USAGE);
1151 
1152         if (opt_f) {
1153                 mdb_printf("%<u>%?s %4s %8s %?s %10s %?s %4s%</u>\n", "FILE",
1154                     "FD", "FLAG", "VNODE", "OFFSET", "CRED", "CNT");
1155                 if (mdb_pwalk("allfile", (mdb_walk_cb_t)file_t_callback, &cb,
1156                     addr) == -1) {
1157                         mdb_warn("failed to walk 'allfile'");
1158                         return (DCMD_ERR);
1159                 }
1160         } else {
1161                 mdb_printf("%<u>%-4s %4s %?s ", "FD", "TYPE", "VNODE");
1162                 if (cb.opt_p)
1163                         mdb_printf("PATH");
1164                 else
1165                         mdb_printf("INFO");
1166                 mdb_printf("%</u>\n");
1167 
1168                 if (mdb_pwalk("allfile", (mdb_walk_cb_t)pfile_callback, &cb,
1169                     addr) == -1) {
1170                         mdb_warn("failed to walk 'allfile'");
1171                         return (DCMD_ERR);
1172                 }
1173         }
1174 
1175 
1176         return (DCMD_OK);
1177 }
1178 
1179 void
1180 pfiles_help(void)
1181 {
1182         mdb_printf(
1183             "Given the address of a process, print information about files\n"
1184             "which the process has open.  By default, this includes decoded\n"
1185             "information about the file depending on file and filesystem type\n"
1186             "\n"
1187             "\t-p\tPathnames; omit decoded information.  Only display "
1188             "pathnames\n"
1189             "\t-f\tfile_t view; show the file_t structure corresponding to "
1190             "the fd\n");
1191 }