winsup/cygwin/fhandler_process.cc

   1 /* fhandler_process.cc: fhandler for /proc/<pid> virtual filesystem
   2
   3    Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Red Hat, Inc.
   4
   5 This file is part of Cygwin.
   6
   7 This software is a copyrighted work licensed under the terms of the
   8 Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
   9 details. */
  10
  11 #include "winsup.h"
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <sys/cygwin.h>
  15 #include "cygerrno.h"
  16 #include "security.h"
  17 #include "path.h"
  18 #include "fhandler.h"
  19 #include "fhandler_virtual.h"
  20 #include "pinfo.h"
  21 #include "shared_info.h"
  22 #include "dtable.h"
  23 #include "cygheap.h"
  24 #include "ntdll.h"
  25 #include "cygtls.h"
  26 #include "pwdgrp.h"
  27 #include "tls_pbuf.h"
  28 #include <sys/param.h>
  29 #include <ctype.h>
  30 #include <psapi.h>
  31
  32 #define _COMPILING_NEWLIB
  33 #include <dirent.h>
  34
  35 static _off64_t format_process_maps (void *, char *&);
  36 static _off64_t format_process_stat (void *, char *&);
  37 static _off64_t format_process_status (void *, char *&);
  38 static _off64_t format_process_statm (void *, char *&);
  39 static _off64_t format_process_winexename (void *, char *&);
  40 static _off64_t format_process_winpid (void *, char *&);
  41 static _off64_t format_process_exename (void *, char *&);
  42 static _off64_t format_process_root (void *, char *&);
  43 static _off64_t format_process_cwd (void *, char *&);
  44 static _off64_t format_process_cmdline (void *, char *&);
  45 static _off64_t format_process_ppid (void *, char *&);
  46 static _off64_t format_process_uid (void *, char *&);
  47 static _off64_t format_process_pgid (void *, char *&);
  48 static _off64_t format_process_sid (void *, char *&);
  49 static _off64_t format_process_gid (void *, char *&);
  50 static _off64_t format_process_ctty (void *, char *&);
  51 static _off64_t format_process_fd (void *, char *&);
  52 static _off64_t format_process_mounts (void *, char *&);
  53
  54 static const virt_tab_t process_tab[] =
  55 {
  56   { _VN ("."),          FH_PROCESS,   virt_directory, NULL },
  57   { _VN (".."),         FH_PROCESS,   virt_directory, NULL },
  58   { _VN ("cmdline"),    FH_PROCESS,   virt_file,      format_process_cmdline },
  59   { _VN ("ctty"),       FH_PROCESS,   virt_file,      format_process_ctty },
  60   { _VN ("cwd"),        FH_PROCESS,   virt_symlink,   format_process_cwd },
  61   { _VN ("exe"),        FH_PROCESS,   virt_symlink,   format_process_exename },
  62   { _VN ("exename"),    FH_PROCESS,   virt_file,      format_process_exename },
  63   { _VN ("fd"),         FH_PROCESSFD, virt_directory, format_process_fd },
  64   { _VN ("gid"),        FH_PROCESS,   virt_file,      format_process_gid },
  65   { _VN ("maps"),       FH_PROCESS,   virt_file,      format_process_maps },
  66   { _VN ("mounts"),     FH_PROCESS,   virt_file,      format_process_mounts },
  67   { _VN ("pgid"),       FH_PROCESS,   virt_file,      format_process_pgid },
  68   { _VN ("ppid"),       FH_PROCESS,   virt_file,      format_process_ppid },
  69   { _VN ("root"),       FH_PROCESS,   virt_symlink,   format_process_root },
  70   { _VN ("sid"),        FH_PROCESS,   virt_file,      format_process_sid },
  71   { _VN ("stat"),       FH_PROCESS,   virt_file,      format_process_stat },
  72   { _VN ("statm"),      FH_PROCESS,   virt_file,      format_process_statm },
  73   { _VN ("status"),     FH_PROCESS,   virt_file,      format_process_status },
  74   { _VN ("uid"),        FH_PROCESS,   virt_file,      format_process_uid },
  75   { _VN ("winexename"), FH_PROCESS,   virt_file,      format_process_winexename },
  76   { _VN ("winpid"),     FH_PROCESS,   virt_file,      format_process_winpid },
  77   { NULL, 0,            0,            virt_none,      NULL }
  78 };
  79
  80 static const int PROCESS_LINK_COUNT =
  81   (sizeof (process_tab) / sizeof (virt_tab_t)) - 1;
  82
  83 static int get_process_state (DWORD dwProcessId);
  84 static bool get_mem_values (DWORD dwProcessId, unsigned long *vmsize,
  85                             unsigned long *vmrss, unsigned long *vmtext,
  86                             unsigned long *vmdata, unsigned long *vmlib,
  87                             unsigned long *vmshare);
  88
  89 /* Returns 0 if path doesn't exist, >0 if path is a directory,
  90  * -1 if path is a file, -2 if path is a symlink, -3 if path is a pipe,
  91  * -4 if path is a socket.
  92  */
  93 virtual_ftype_t
  94 fhandler_process::exists ()
  95 {
  96   const char *path = get_name ();
  97   debug_printf ("exists (%s)", path);
  98   path += proc_len + 1;
  99   while (*path != 0 && !isdirsep (*path))
 100     path++;
 101   if (*path == 0)
 102     return virt_rootdir;
 103
 104   virt_tab_t *entry = virt_tab_search (path + 1, true, process_tab,
 105                                        PROCESS_LINK_COUNT);
 106   if (entry)
 107     {
 108       if (!path[entry->name_len + 1])
 109         {
 110           fileid = entry - process_tab;
 111           return entry->type;
 112         }
 113       if (entry->type == virt_directory)
 114         {
 115           fileid = entry - process_tab;
 116           if (fill_filebuf ())
 117             return virt_symlink;
 118           /* Check for nameless device entries. */
 119           path = strrchr (path, '/');
 120           if (path && *++path)
 121             {
 122               if (!strncmp (path, "pipe:[", 6))
 123                 return virt_pipe;
 124               else if (!strncmp (path, "socket:[", 8))
 125                 return virt_socket;
 126             }
 127         }
 128     }
 129   return virt_none;
 130 }
 131
 132 fhandler_process::fhandler_process ():
 133   fhandler_proc ()
 134 {
 135 }
 136
 137 int
 138 fhandler_process::fstat (struct __stat64 *buf)
 139 {
 140   const char *path = get_name ();
 141   int file_type = exists ();
 142   fhandler_base::fstat (buf);
 143   path += proc_len + 1;
 144   pid = atoi (path);
 145   pinfo p (pid);
 146   if (!p)
 147     {
 148       set_errno (ENOENT);
 149       return -1;
 150     }
 151
 152   buf->st_mode &= ~_IFMT & NO_W;
 153
 154   switch (file_type)
 155     {
 156     case virt_none:
 157       set_errno (ENOENT);
 158       return -1;
 159     case virt_directory:
 160     case virt_rootdir:
 161       buf->st_ctime = buf->st_mtime = buf->st_birthtime = p->start_time;
 162       buf->st_ctim.tv_nsec = buf->st_mtim.tv_nsec
 163         = buf->st_birthtim.tv_nsec = 0;
 164       time_as_timestruc_t (&buf->st_atim);
 165       buf->st_uid = p->uid;
 166       buf->st_gid = p->gid;
 167       buf->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
 168       if (file_type == 1)
 169         buf->st_nlink = 2;
 170       else
 171         buf->st_nlink = 3;
 172       return 0;
 173     case virt_symlink:
 174       buf->st_uid = p->uid;
 175       buf->st_gid = p->gid;
 176       buf->st_mode = S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
 177       return 0;
 178     case virt_pipe:
 179       buf->st_uid = p->uid;
 180       buf->st_gid = p->gid;
 181       buf->st_mode = S_IFIFO | S_IRUSR | S_IWUSR;
 182       return 0;
 183     case virt_socket:
 184       buf->st_uid = p->uid;
 185       buf->st_gid = p->gid;
 186       buf->st_mode = S_IFSOCK | S_IRUSR | S_IWUSR;
 187       return 0;
 188     case virt_file:
 189     default:
 190       buf->st_uid = p->uid;
 191       buf->st_gid = p->gid;
 192       buf->st_mode |= S_IFREG | S_IRUSR | S_IRGRP | S_IROTH;
 193       return 0;
 194     }
 195 }
 196
 197 DIR *
 198 fhandler_process::opendir (int fd)
 199 {
 200   DIR *dir = fhandler_virtual::opendir (fd);
 201   if (dir && process_tab[fileid].fhandler == FH_PROCESSFD)
 202     fill_filebuf ();
 203   return dir;
 204 }
 205
 206 int
 207 fhandler_process::readdir (DIR *dir, dirent *de)
 208 {
 209   int res = ENMFILE;
 210   if (process_tab[fileid].fhandler == FH_PROCESSFD)
 211     {
 212       if (dir->__d_position >= 2 + filesize / sizeof (int))
 213         goto out;
 214     }
 215   else if (dir->__d_position >= PROCESS_LINK_COUNT)
 216     goto out;
 217   if (process_tab[fileid].fhandler == FH_PROCESSFD && dir->__d_position > 1)
 218     {
 219       int *p = (int *) filebuf;
 220       __small_sprintf (de->d_name, "%d", p[dir->__d_position++ - 2]);
 221     }
 222   else
 223     strcpy (de->d_name, process_tab[dir->__d_position++].name);
 224   dir->__flags |= dirent_saw_dot | dirent_saw_dot_dot;
 225   res = 0;
 226 out:
 227   syscall_printf ("%d = readdir (%p, %p) (%s)", res, dir, de, de->d_name);
 228   return res;
 229 }
 230
 231 int
 232 fhandler_process::open (int flags, mode_t mode)
 233 {
 234   int res = fhandler_virtual::open (flags, mode);
 235   if (!res)
 236     goto out;
 237
 238   nohandle (true);
 239
 240   const char *path;
 241   path = get_name () + proc_len + 1;
 242   pid = atoi (path);
 243   while (*path != 0 && !isdirsep (*path))
 244     path++;
 245
 246   if (*path == 0)
 247     {
 248       if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 249         {
 250           set_errno (EEXIST);
 251           res = 0;
 252           goto out;
 253         }
 254       else if (flags & O_WRONLY)
 255         {
 256           set_errno (EISDIR);
 257           res = 0;
 258           goto out;
 259         }
 260       else
 261         {
 262           flags |= O_DIROPEN;
 263           goto success;
 264         }
 265     }
 266
 267   virt_tab_t *entry;
 268   entry = virt_tab_search (path + 1, true, process_tab, PROCESS_LINK_COUNT);
 269   if (!entry)
 270     {
 271       set_errno ((flags & O_CREAT) ? EROFS : ENOENT);
 272       res = 0;
 273       goto out;
 274     }
 275   if (entry->fhandler == FH_PROCESSFD)
 276     {
 277       flags |= O_DIROPEN;
 278       goto success;
 279     }
 280   if (flags & O_WRONLY)
 281     {
 282       set_errno (EROFS);
 283       res = 0;
 284       goto out;
 285     }
 286
 287   fileid = entry - process_tab;
 288   if (!fill_filebuf ())
 289         {
 290           res = 0;
 291           goto out;
 292         }
 293
 294   if (flags & O_APPEND)
 295     position = filesize;
 296   else
 297     position = 0;
 298
 299 success:
 300   res = 1;
 301   set_flags ((flags & ~O_TEXT) | O_BINARY);
 302   set_open_status ();
 303 out:
 304   syscall_printf ("%d = fhandler_proc::open (%p, %d)", res, flags, mode);
 305   return res;
 306 }
 307
 308 struct process_fd_t {
 309   const char *path;
 310   _pinfo *p;
 311 };
 312
 313 bool
 314 fhandler_process::fill_filebuf ()
 315 {
 316   const char *path;
 317   path = get_name () + proc_len + 1;
 318   if (!pid)
 319     pid = atoi (path);
 320
 321   pinfo p (pid);
 322
 323   if (!p)
 324     {
 325       set_errno (ENOENT);
 326       return false;
 327     }
 328
 329   if (process_tab[fileid].format_func)
 330     {
 331       if (process_tab[fileid].fhandler == FH_PROCESSFD)
 332         {
 333           process_fd_t fd = { path, p };
 334           filesize = process_tab[fileid].format_func (&fd, filebuf);
 335         }
 336       else
 337         filesize = process_tab[fileid].format_func (p, filebuf);
 338       return !filesize ? false : true;
 339     }
 340   return false;
 341 }
 342
 343 static _off64_t
 344 format_process_fd (void *data, char *&destbuf)
 345 {
 346   _pinfo *p = ((process_fd_t *) data)->p;
 347   const char *path = ((process_fd_t *) data)->path;
 348   size_t fs = 0;
 349   char *fdp = strrchr (path, '/');
 350
 351   if (!fdp || *++fdp == 'f') /* The "fd" directory itself. */
 352     {
 353       if (destbuf)
 354         cfree (destbuf);
 355       destbuf = p->fds (fs);
 356     }
 357   else
 358     {
 359       if (destbuf)
 360         cfree (destbuf);
 361       int fd = atoi (fdp);
 362       if (fd < 0 || (fd == 0 && !isdigit (*fdp)))
 363         {
 364           set_errno (ENOENT);
 365           return 0;
 366         }
 367       destbuf = p->fd (fd, fs);
 368       if (!destbuf || !*destbuf)
 369         {
 370           set_errno (ENOENT);
 371           return 0;
 372         }
 373     }
 374   return fs;
 375 }
 376
 377 static _off64_t
 378 format_process_ppid (void *data, char *&destbuf)
 379 {
 380   _pinfo *p = (_pinfo *) data;
 381   destbuf = (char *) crealloc_abort (destbuf, 40);
 382   return __small_sprintf (destbuf, "%d\n", p->ppid);
 383 }
 384
 385 static _off64_t
 386 format_process_uid (void *data, char *&destbuf)
 387 {
 388   _pinfo *p = (_pinfo *) data;
 389   destbuf = (char *) crealloc_abort (destbuf, 40);
 390   return __small_sprintf (destbuf, "%d\n", p->uid);
 391 }
 392
 393 static _off64_t
 394 format_process_pgid (void *data, char *&destbuf)
 395 {
 396   _pinfo *p = (_pinfo *) data;
 397   destbuf = (char *) crealloc_abort (destbuf, 40);
 398   return __small_sprintf (destbuf, "%d\n", p->pgid);
 399 }
 400
 401 static _off64_t
 402 format_process_sid (void *data, char *&destbuf)
 403 {
 404   _pinfo *p = (_pinfo *) data;
 405   destbuf = (char *) crealloc_abort (destbuf, 40);
 406   return __small_sprintf (destbuf, "%d\n", p->sid);
 407 }
 408
 409 static _off64_t
 410 format_process_gid (void *data, char *&destbuf)
 411 {
 412   _pinfo *p = (_pinfo *) data;
 413   destbuf = (char *) crealloc_abort (destbuf, 40);
 414   return __small_sprintf (destbuf, "%d\n", p->gid);
 415 }
 416
 417 static _off64_t
 418 format_process_ctty (void *data, char *&destbuf)
 419 {
 420   _pinfo *p = (_pinfo *) data;
 421   destbuf = (char *) crealloc_abort (destbuf, 40);
 422   return __small_sprintf (destbuf, "%d\n", p->ctty);
 423 }
 424
 425 static _off64_t
 426 format_process_root (void *data, char *&destbuf)
 427 {
 428   _pinfo *p = (_pinfo *) data;
 429   size_t fs;
 430
 431   if (destbuf)
 432     {
 433       cfree (destbuf);
 434       destbuf = NULL;
 435     }
 436   destbuf = p->root (fs);
 437   if (!destbuf || !*destbuf)
 438     {
 439       destbuf = cstrdup ("<defunct>");
 440       fs = strlen (destbuf) + 1;
 441     }
 442   return fs;
 443 }
 444
 445 static _off64_t
 446 format_process_cwd (void *data, char *&destbuf)
 447 {
 448   _pinfo *p = (_pinfo *) data;
 449   size_t fs;
 450
 451   if (destbuf)
 452     {
 453       cfree (destbuf);
 454       destbuf = NULL;
 455     }
 456   destbuf = p->cwd (fs);
 457   if (!destbuf || !*destbuf)
 458     {
 459       destbuf = cstrdup ("<defunct>");
 460       fs = strlen (destbuf) + 1;
 461     }
 462   return fs;
 463 }
 464
 465 static _off64_t
 466 format_process_cmdline (void *data, char *&destbuf)
 467 {
 468   _pinfo *p = (_pinfo *) data;
 469   size_t fs;
 470
 471   if (destbuf)
 472     {
 473       cfree (destbuf);
 474       destbuf = NULL;
 475     }
 476   destbuf = p->cmdline (fs);
 477   if (!destbuf || !*destbuf)
 478     {
 479       destbuf = cstrdup ("<defunct>");
 480       fs = strlen (destbuf) + 1;
 481     }
 482   return fs;
 483 }
 484
 485 static _off64_t
 486 format_process_exename (void *data, char *&destbuf)
 487 {
 488   _pinfo *p = (_pinfo *) data;
 489   int len;
 490   tmp_pathbuf tp;
 491
 492   char *buf = tp.c_get ();
 493   if (p->process_state & PID_EXITED)
 494     stpcpy (buf, "<defunct>");
 495   else
 496     {
 497       mount_table->conv_to_posix_path (p->progname, buf, 1);
 498       len = strlen (buf);
 499       if (len > 4)
 500         {
 501           char *s = buf + len - 4;
 502           if (ascii_strcasematch (s, ".exe"))
 503             *s = 0;
 504         }
 505     }
 506   destbuf = (char *) crealloc_abort (destbuf, (len = strlen (buf)) + 1);
 507   stpcpy (destbuf, buf);
 508   return len;
 509 }
 510
 511 static _off64_t
 512 format_process_winpid (void *data, char *&destbuf)
 513 {
 514   _pinfo *p = (_pinfo *) data;
 515   destbuf = (char *) crealloc_abort (destbuf, 20);
 516   return __small_sprintf (destbuf, "%d\n", p->dwProcessId);
 517 }
 518
 519 static _off64_t
 520 format_process_winexename (void *data, char *&destbuf)
 521 {
 522   _pinfo *p = (_pinfo *) data;
 523   size_t len = sys_wcstombs (NULL, 0, p->progname);
 524   destbuf = (char *) crealloc_abort (destbuf, len + 1);
 525   sys_wcstombs (destbuf, len, p->progname);
 526   destbuf[len] = '\n';
 527   return len + 1;
 528 }
 529
 530 static _off64_t
 531 format_process_maps (void *data, char *&destbuf)
 532 {
 533   _pinfo *p = (_pinfo *) data;
 534   HANDLE proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
 535                              FALSE,
 536                              p->dwProcessId);
 537   if (!proc)
 538     return 0;
 539
 540   _off64_t len = 0;
 541   HMODULE *modules;
 542   DWORD needed, i;
 543   DWORD_PTR wset_size;
 544   DWORD_PTR *workingset = NULL;
 545   MODULEINFO info;
 546
 547   tmp_pathbuf tp;
 548   PWCHAR modname = tp.w_get ();
 549   char *posix_modname = tp.c_get ();
 550   size_t maxsize = 0;
 551
 552   if (destbuf)
 553     {
 554       cfree (destbuf);
 555       destbuf = NULL;
 556     }
 557   if (!EnumProcessModules (proc, NULL, 0, &needed))
 558     {
 559       __seterrno ();
 560       len = -1;
 561       goto out;
 562     }
 563   modules = (HMODULE*) alloca (needed);
 564   if (!EnumProcessModules (proc, modules, needed, &needed))
 565     {
 566       __seterrno ();
 567       len = -1;
 568       goto out;
 569     }
 570
 571   QueryWorkingSet (proc, (void *) &wset_size, sizeof wset_size);
 572   if (GetLastError () == ERROR_BAD_LENGTH)
 573     {
 574       workingset = (DWORD_PTR *) alloca (sizeof (DWORD_PTR) * ++wset_size);
 575       if (!QueryWorkingSet (proc, (void *) workingset,
 576                             sizeof (DWORD_PTR) * wset_size))
 577         workingset = NULL;
 578     }
 579   for (i = 0; i < needed / sizeof (HMODULE); i++)
 580     if (GetModuleInformation (proc, modules[i], &info, sizeof info)
 581         && GetModuleFileNameExW (proc, modules[i], modname, NT_MAX_PATH))
 582       {
 583         char access[5];
 584         strcpy (access, "r--p");
 585         struct __stat64 st;
 586         if (mount_table->conv_to_posix_path (modname, posix_modname, 0))
 587           sys_wcstombs (posix_modname, NT_MAX_PATH, modname);
 588         if (stat64 (posix_modname, &st))
 589           {
 590             st.st_dev = 0;
 591             st.st_ino = 0;
 592           }
 593         size_t newlen = strlen (posix_modname) + 62;
 594         if (len + newlen >= maxsize)
 595           destbuf = (char *) crealloc_abort (destbuf,
 596                                            maxsize += roundup2 (newlen, 2048));
 597         if (workingset)
 598           for (unsigned i = 1; i <= wset_size; ++i)
 599             {
 600               DWORD_PTR addr = workingset[i] & 0xfffff000UL;
 601               if ((char *)addr >= info.lpBaseOfDll
 602                   && (char *)addr < (char *)info.lpBaseOfDll + info.SizeOfImage)
 603                 {
 604                   access[0] = (workingset[i] & 0x5) ? 'r' : '-';
 605                   access[1] = (workingset[i] & 0x4) ? 'w' : '-';
 606                   access[2] = (workingset[i] & 0x2) ? 'x' : '-';
 607                   access[3] = (workingset[i] & 0x100) ? 's' : 'p';
 608                 }
 609             }
 610         int written = __small_sprintf (destbuf + len,
 611                                 "%08lx-%08lx %s %08lx %04x:%04x %U   ",
 612                                 info.lpBaseOfDll,
 613                                 (unsigned long)info.lpBaseOfDll
 614                                 + info.SizeOfImage,
 615                                 access,
 616                                 info.EntryPoint,
 617                                 st.st_dev >> 16,
 618                                 st.st_dev & 0xffff,
 619                                 st.st_ino);
 620         while (written < 62)
 621           destbuf[len + written++] = ' ';
 622         len += written;
 623         len += __small_sprintf (destbuf + len, "%s\n", posix_modname);
 624       }
 625 out:
 626   CloseHandle (proc);
 627   return len;
 628 }
 629
 630 static _off64_t
 631 format_process_stat (void *data, char *&destbuf)
 632 {
 633   _pinfo *p = (_pinfo *) data;
 634   char cmd[NAME_MAX + 1];
 635   WCHAR wcmd[NAME_MAX + 1];
 636   int state = 'R';
 637   unsigned long fault_count = 0UL,
 638                 utime = 0UL, stime = 0UL,
 639                 start_time = 0UL,
 640                 vmsize = 0UL, vmrss = 0UL, vmmaxrss = 0UL;
 641   int priority = 0;
 642   if (p->process_state & PID_EXITED)
 643     strcpy (cmd, "<defunct>");
 644   else
 645     {
 646       PWCHAR last_slash = wcsrchr (p->progname, L'\\');
 647       wcscpy (wcmd, last_slash ? last_slash + 1 : p->progname);
 648       sys_wcstombs (cmd, NAME_MAX + 1, wcmd);
 649       int len = strlen (cmd);
 650       if (len > 4)
 651         {
 652           char *s = cmd + len - 4;
 653           if (ascii_strcasematch (s, ".exe"))
 654             *s = 0;
 655          }
 656     }
 657   /*
 658    * Note: under Windows, a _process_ is always running - it's only _threads_
 659    * that get suspended. Therefore the default state is R (runnable).
 660    */
 661   if (p->process_state & PID_EXITED)
 662     state = 'Z';
 663   else if (p->process_state & PID_STOPPED)
 664     state = 'T';
 665   else
 666     state = get_process_state (p->dwProcessId);
 667   start_time = (GetTickCount () / 1000 - time (NULL) + p->start_time) * HZ;
 668
 669   NTSTATUS ret;
 670   HANDLE hProcess;
 671   VM_COUNTERS vmc;
 672   KERNEL_USER_TIMES put;
 673   PROCESS_BASIC_INFORMATION pbi;
 674   QUOTA_LIMITS ql;
 675   SYSTEM_TIME_OF_DAY_INFORMATION stodi;
 676   SYSTEM_PROCESSOR_TIMES spt;
 677   hProcess = OpenProcess (PROCESS_VM_READ | PROCESS_QUERY_INFORMATION,
 678                           FALSE, p->dwProcessId);
 679   if (hProcess != NULL)
 680     {
 681       ret = NtQueryInformationProcess (hProcess,
 682                                        ProcessVmCounters,
 683                                        (PVOID) &vmc,
 684                                        sizeof vmc, NULL);
 685       if (ret == STATUS_SUCCESS)
 686         ret = NtQueryInformationProcess (hProcess,
 687                                          ProcessTimes,
 688                                          (PVOID) &put,
 689                                          sizeof put, NULL);
 690       if (ret == STATUS_SUCCESS)
 691         ret = NtQueryInformationProcess (hProcess,
 692                                          ProcessBasicInformation,
 693                                          (PVOID) &pbi,
 694                                          sizeof pbi, NULL);
 695       if (ret == STATUS_SUCCESS)
 696         ret = NtQueryInformationProcess (hProcess,
 697                                          ProcessQuotaLimits,
 698                                          (PVOID) &ql,
 699                                          sizeof ql, NULL);
 700       CloseHandle (hProcess);
 701     }
 702   else
 703     {
 704       DWORD error = GetLastError ();
 705       __seterrno_from_win_error (error);
 706       debug_printf ("OpenProcess: ret %d", error);
 707       return 0;
 708     }
 709   if (ret == STATUS_SUCCESS)
 710     ret = NtQuerySystemInformation (SystemTimeOfDayInformation,
 711                                     (PVOID) &stodi,
 712                                     sizeof stodi, NULL);
 713   if (ret == STATUS_SUCCESS)
 714     ret = NtQuerySystemInformation (SystemProcessorTimes,
 715                                     (PVOID) &spt,
 716                                     sizeof spt, NULL);
 717   if (ret != STATUS_SUCCESS)
 718     {
 719       __seterrno_from_nt_status (ret);
 720       debug_printf ("NtQueryInformationProcess: ret %d, Dos(ret) %E", ret);
 721       return 0;
 722     }
 723   fault_count = vmc.PageFaultCount;
 724   utime = put.UserTime.QuadPart * HZ / 10000000ULL;
 725   stime = put.KernelTime.QuadPart * HZ / 10000000ULL;
 726 #if 0
 727    if (stodi.CurrentTime.QuadPart > put.CreateTime.QuadPart)
 728      start_time = (spt.KernelTime.QuadPart + spt.UserTime.QuadPart -
 729                    stodi.CurrentTime.QuadPart + put.CreateTime.QuadPart) * HZ / 10000000ULL;
 730    else
 731      /*
 732       * sometimes stodi.CurrentTime is a bit behind
 733       * Note: some older versions of procps are broken and can't cope
 734       * with process start times > time(NULL).
 735       */
 736      start_time = (spt.KernelTme.QuadPart + spt.UserTime.QuadPart) * HZ / 10000000ULL;
 737 #endif
 738   priority = pbi.BasePriority;
 739   unsigned page_size = getsystempagesize ();
 740   vmsize = vmc.PagefileUsage;
 741   vmrss = vmc.WorkingSetSize / page_size;
 742   vmmaxrss = ql.MaximumWorkingSetSize / page_size;
 743
 744   destbuf = (char *) crealloc_abort (destbuf, strlen (cmd) + 320);
 745   return __small_sprintf (destbuf, "%d (%s) %c "
 746                                    "%d %d %d %d %d "
 747                                    "%lu %lu %lu %lu %lu %lu %lu "
 748                                    "%ld %ld %ld %ld %ld %ld "
 749                                    "%lu %lu "
 750                                    "%ld "
 751                                    "%lu",
 752                           p->pid, cmd,
 753                           state,
 754                           p->ppid, p->pgid, p->sid, makedev (FH_TTYS, p->ctty),
 755                           -1, 0, fault_count, fault_count, 0, 0, utime, stime,
 756                           utime, stime, priority, 0, 0, 0,
 757                           start_time, vmsize,
 758                           vmrss, vmmaxrss
 759                           );
 760 }
 761
 762 static _off64_t
 763 format_process_status (void *data, char *&destbuf)
 764 {
 765   _pinfo *p = (_pinfo *) data;
 766   char cmd[NAME_MAX + 1];
 767   WCHAR wcmd[NAME_MAX + 1];
 768   int state = 'R';
 769   const char *state_str = "unknown";
 770   unsigned long vmsize = 0UL, vmrss = 0UL, vmdata = 0UL, vmlib = 0UL, vmtext = 0UL,
 771                 vmshare = 0UL;
 772   if (p->process_state & PID_EXITED)
 773     strcpy (cmd, "<defunct>");
 774   else
 775     {
 776       PWCHAR last_slash = wcsrchr (p->progname, L'\\');
 777       wcscpy (wcmd, last_slash ? last_slash + 1 : p->progname);
 778       sys_wcstombs (cmd, NAME_MAX + 1, wcmd);
 779       int len = strlen (cmd);
 780       if (len > 4)
 781         {
 782           char *s = cmd + len - 4;
 783           if (ascii_strcasematch (s, ".exe"))
 784             *s = 0;
 785          }
 786     }
 787   /*
 788    * Note: under Windows, a _process_ is always running - it's only _threads_
 789    * that get suspended. Therefore the default state is R (runnable).
 790    */
 791   if (p->process_state & PID_EXITED)
 792     state = 'Z';
 793   else if (p->process_state & PID_STOPPED)
 794     state = 'T';
 795   else
 796     state = get_process_state (p->dwProcessId);
 797   switch (state)
 798     {
 799     case 'O':
 800       state_str = "running";
 801       break;
 802     case 'D':
 803     case 'S':
 804       state_str = "sleeping";
 805       break;
 806     case 'R':
 807       state_str = "runnable";
 808       break;
 809     case 'Z':
 810       state_str = "zombie";
 811       break;
 812     case 'T':
 813       state_str = "stopped";
 814       break;
 815     }
 816   if (!get_mem_values (p->dwProcessId, &vmsize, &vmrss, &vmtext, &vmdata,
 817                        &vmlib, &vmshare))
 818     return 0;
 819   unsigned page_size = getsystempagesize ();
 820   vmsize *= page_size; vmrss *= page_size; vmdata *= page_size;
 821   vmtext *= page_size; vmlib *= page_size;
 822   // The real uid value for *this* process is stored at cygheap->user.real_uid
 823   // but we can't get at the real uid value for any other process, so
 824   // just fake it as p->uid. Similar for p->gid.
 825   destbuf = (char *) crealloc_abort (destbuf, strlen (cmd) + 320);
 826   return __small_sprintf (destbuf, "Name:\t%s\n"
 827                                    "State:\t%c (%s)\n"
 828                                    "Tgid:\t%d\n"
 829                                    "Pid:\t%d\n"
 830                                    "PPid:\t%d\n"
 831                                    "Uid:\t%d %d %d %d\n"
 832                                    "Gid:\t%d %d %d %d\n"
 833                                    "VmSize:\t%8d kB\n"
 834                                    "VmLck:\t%8d kB\n"
 835                                    "VmRSS:\t%8d kB\n"
 836                                    "VmData:\t%8d kB\n"
 837                                    "VmStk:\t%8d kB\n"
 838                                    "VmExe:\t%8d kB\n"
 839                                    "VmLib:\t%8d kB\n"
 840                                    "SigPnd:\t%016x\n"
 841                                    "SigBlk:\t%016x\n"
 842                                    "SigIgn:\t%016x\n",
 843                           cmd,
 844                           state, state_str,
 845                           p->pgid,
 846                           p->pid,
 847                           p->ppid,
 848                           p->uid, p->uid, p->uid, p->uid,
 849                           p->gid, p->gid, p->gid, p->gid,
 850                           vmsize >> 10, 0, vmrss >> 10, vmdata >> 10, 0,
 851                           vmtext >> 10, vmlib >> 10,
 852                           0, 0, _my_tls.sigmask
 853                           );
 854 }
 855
 856 static _off64_t
 857 format_process_statm (void *data, char *&destbuf)
 858 {
 859   _pinfo *p = (_pinfo *) data;
 860   unsigned long vmsize = 0UL, vmrss = 0UL, vmtext = 0UL, vmdata = 0UL,
 861                 vmlib = 0UL, vmshare = 0UL;
 862   if (!get_mem_values (p->dwProcessId, &vmsize, &vmrss, &vmtext, &vmdata,
 863                        &vmlib, &vmshare))
 864     return 0;
 865   destbuf = (char *) crealloc_abort (destbuf, 96);
 866   return __small_sprintf (destbuf, "%ld %ld %ld %ld %ld %ld %ld",
 867                           vmsize, vmrss, vmshare, vmtext, vmlib, vmdata, 0);
 868 }
 869
 870 extern "C" {
 871   FILE *setmntent (const char *, const char *);
 872   struct mntent *getmntent (FILE *);
 873 };
 874
 875 static _off64_t
 876 format_process_mounts (void *data, char *&destbuf)
 877 {
 878   _pinfo *p = (_pinfo *) data;
 879   user_info *u_shared = NULL;
 880   HANDLE u_hdl = NULL;
 881   _off64_t len = 0;
 882   struct mntent *mnt;
 883
 884   if (p->pid != myself->pid)
 885     {
 886       WCHAR sid_string[UNLEN + 1] = L""; /* Large enough for SID */
 887
 888       cygsid p_sid;
 889
 890       if (!p_sid.getfrompw (internal_getpwuid (p->uid)))
 891         return 0;
 892       p_sid.string (sid_string);
 893       u_shared = (user_info *) open_shared (sid_string, USER_VERSION, u_hdl,
 894                                             sizeof (user_info), SH_JUSTOPEN,
 895                                             &sec_none_nih);
 896       if (!u_shared)
 897         return 0;
 898     }
 899   else
 900     u_shared = user_shared;
 901
 902   /* Store old value of _my_tls.locals here. */
 903   int iteration = _my_tls.locals.iteration;
 904   unsigned available_drives = _my_tls.locals.available_drives;
 905   /* This reinitializes the above values in _my_tls. */
 906   setmntent (NULL, NULL);
 907   while ((mnt = getmntent (NULL)))
 908     {
 909       destbuf = (char *) crealloc_abort (destbuf, len
 910                                                   + strlen (mnt->mnt_fsname)
 911                                                   + strlen (mnt->mnt_dir)
 912                                                   + strlen (mnt->mnt_type)
 913                                                   + strlen (mnt->mnt_opts)
 914                                                   + 28);
 915       len += __small_sprintf (destbuf + len, "%s %s %s %s %d %d\n",
 916                               mnt->mnt_fsname, mnt->mnt_dir, mnt->mnt_type,
 917                               mnt->mnt_opts, mnt->mnt_freq, mnt->mnt_passno);
 918     }
 919   /* Restore old value of _my_tls.locals here. */
 920   _my_tls.locals.iteration = iteration;
 921   _my_tls.locals.available_drives = available_drives;
 922
 923   if (u_hdl) /* Only not-NULL if open_shared has been called. */
 924     {
 925       UnmapViewOfFile (u_shared);
 926       CloseHandle (u_hdl);
 927     }
 928   return len;
 929 }
 930
 931 static int
 932 get_process_state (DWORD dwProcessId)
 933 {
 934   /*
 935    * This isn't really heavy magic - just go through the processes'
 936    * threads one by one and return a value accordingly
 937    * Errors are silently ignored.
 938    */
 939   NTSTATUS ret;
 940   SYSTEM_PROCESSES *sp;
 941   ULONG n = 0x1000;
 942   PULONG p = new ULONG[n];
 943   int state =' ';
 944   while (STATUS_INFO_LENGTH_MISMATCH ==
 945          (ret = NtQuerySystemInformation (SystemProcessesAndThreadsInformation,
 946                                          (PVOID) p,
 947                                          n * sizeof *p, NULL)))
 948     delete [] p, p = new ULONG[n *= 2];
 949   if (ret != STATUS_SUCCESS)
 950     {
 951       debug_printf ("NtQuerySystemInformation: ret %d, Dos(ret) %d",
 952                     ret, RtlNtStatusToDosError (ret));
 953       goto out;
 954     }
 955   state = 'Z';
 956   sp = (SYSTEM_PROCESSES *) p;
 957   for (;;)
 958     {
 959       if (sp->ProcessId == dwProcessId)
 960         {
 961           SYSTEM_THREADS *st;
 962           if (wincap.has_process_io_counters ())
 963             /*
 964              * Windows 2000 and XP have an extra member in SYSTEM_PROCESSES
 965              * which means the offset of the first SYSTEM_THREADS entry is
 966              * different on these operating systems compared to NT 4.
 967              */
 968             st = &sp->Threads[0];
 969           else
 970             /*
 971              * 136 is the offset of the first SYSTEM_THREADS entry on
 972              * Windows NT 4.
 973              */
 974             st = (SYSTEM_THREADS *) ((char *) sp + 136);
 975           state = 'S';
 976           for (unsigned i = 0; i < sp->ThreadCount; i++)
 977             {
 978               if (st->State == StateRunning ||
 979                   st->State == StateReady)
 980                 {
 981                   state = 'R';
 982                   goto out;
 983                 }
 984               st++;
 985             }
 986           break;
 987         }
 988       if (!sp->NextEntryDelta)
 989          break;
 990       sp = (SYSTEM_PROCESSES *) ((char *) sp + sp->NextEntryDelta);
 991     }
 992 out:
 993   delete [] p;
 994   return state;
 995 }
 996
 997 static bool
 998 get_mem_values (DWORD dwProcessId, unsigned long *vmsize, unsigned long *vmrss,
 999                 unsigned long *vmtext, unsigned long *vmdata,
1000                 unsigned long *vmlib, unsigned long *vmshare)
1001 {
1002   bool res = false;
1003   NTSTATUS ret;
1004   HANDLE hProcess;
1005   VM_COUNTERS vmc;
1006   MEMORY_WORKING_SET_LIST *mwsl;
1007   ULONG n = 0x4000, length;
1008   PMEMORY_WORKING_SET_LIST p = (PMEMORY_WORKING_SET_LIST) malloc (n);
1009   unsigned page_size = getsystempagesize ();
1010   hProcess = OpenProcess (PROCESS_QUERY_INFORMATION,
1011                           FALSE, dwProcessId);
1012   if (hProcess == NULL)
1013     {
1014       __seterrno ();
1015       debug_printf ("OpenProcess, %E");
1016       return false;
1017     }
1018   do
1019     {
1020       ret = NtQueryVirtualMemory (hProcess, 0, MemoryWorkingSetList,
1021                                   (PVOID) p, n, (length = ULONG_MAX, &length));
1022       if (ret == STATUS_INFO_LENGTH_MISMATCH
1023           || (!NT_SUCCESS (ret) && length > n))
1024         {
1025           ret = STATUS_INFO_LENGTH_MISMATCH;
1026           n <<= 1;
1027           PMEMORY_WORKING_SET_LIST new_p = (PMEMORY_WORKING_SET_LIST)
1028                                            realloc (p, n);
1029           if (!new_p)
1030             goto out;
1031           p = new_p;
1032         }
1033     }
1034   while (!NT_SUCCESS (ret));
1035   if (!NT_SUCCESS (ret))
1036     {
1037       debug_printf ("NtQueryVirtualMemory: ret %p", ret);
1038       __seterrno_from_nt_status (ret);
1039       goto out;
1040     }
1041   mwsl = (MEMORY_WORKING_SET_LIST *) p;
1042   for (unsigned long i = 0; i < mwsl->NumberOfPages; i++)
1043     {
1044       ++*vmrss;
1045       unsigned flags = mwsl->WorkingSetList[i] & 0x0FFF;
1046       if ((flags & (WSLE_PAGE_EXECUTE | WSLE_PAGE_SHAREABLE))
1047           == (WSLE_PAGE_EXECUTE | WSLE_PAGE_SHAREABLE))
1048         ++*vmlib;
1049       else if (flags & WSLE_PAGE_SHAREABLE)
1050         ++*vmshare;
1051       else if (flags & WSLE_PAGE_EXECUTE)
1052         ++*vmtext;
1053       else
1054         ++*vmdata;
1055     }
1056   ret = NtQueryInformationProcess (hProcess, ProcessVmCounters, (PVOID) &vmc,
1057                                    sizeof vmc, NULL);
1058   if (!NT_SUCCESS (ret))
1059     {
1060       debug_printf ("NtQueryInformationProcess: ret %p", ret);
1061       __seterrno_from_nt_status (ret);
1062       goto out;
1063     }
1064   *vmsize = vmc.PagefileUsage / page_size;
1065   res = true;
1066 out:
1067   free (p);
1068   CloseHandle (hProcess);
1069   return res;
1070 }