diff --git a/src/library/ps/DESCRIPTION b/src/library/ps/DESCRIPTION
index d0be85932..4794469a0 100644
--- a/src/library/ps/DESCRIPTION
+++ b/src/library/ps/DESCRIPTION
@@ -1,6 +1,6 @@
 Package: ps
 Title: List, Query, Manipulate System Processes
-Version: 1.7.6
+Version: 1.8.1
 Authors@R: c(
     person("Jay", "Loden", role = "aut"),
     person("Dave", "Daeschler", role = "aut"),
@@ -16,14 +16,14 @@ BugReports: https://github.com/r-lib/ps/issues
 Depends: R (>= 3.4)
 Imports: utils
 Suggests: callr, covr, curl, pillar, pingr, processx (>= 3.1.0), R6,
-        rlang, testthat (>= 3.0.0), webfakes
+        rlang, testthat (>= 3.0.0), webfakes, withr
 Biarch: true
 Config/Needs/website: tidyverse/tidytemplate
 Config/testthat/edition: 3
 Encoding: UTF-8
-RoxygenNote: 7.2.3
+RoxygenNote: 7.3.2
 NeedsCompilation: yes
-Packaged: 2024-01-18 06:13:01 UTC; gaborcsardi
+Packaged: 2024-10-28 21:43:41 UTC; gaborcsardi
 Author: Jay Loden [aut],
   Dave Daeschler [aut],
   Giampaolo Rodola' [aut],
@@ -31,4 +31,4 @@ Author: Jay Loden [aut],
   Posit Software, PBC [cph, fnd]
 Maintainer: Gábor Csárdi <csardi.gabor@gmail.com>
 Repository: CRAN
-Date/Publication: 2024-01-18 06:40:02 UTC
+Date/Publication: 2024-10-28 22:10:02 UTC
diff --git a/src/library/ps/NAMESPACE b/src/library/ps/NAMESPACE
index 61a047735..b80cb2b02 100644
--- a/src/library/ps/NAMESPACE
+++ b/src/library/ps/NAMESPACE
@@ -7,6 +7,7 @@ S3method(print,with_process_cleanup)
 export(CleanupReporter)
 export(errno)
 export(ps)
+export(ps_apps)
 export(ps_boot_time)
 export(ps_children)
 export(ps_cmdline)
@@ -16,12 +17,16 @@ export(ps_cpu_times)
 export(ps_create_time)
 export(ps_cwd)
 export(ps_descent)
+export(ps_disk_io_counters)
 export(ps_disk_partitions)
 export(ps_disk_usage)
 export(ps_environ)
 export(ps_environ_raw)
 export(ps_exe)
 export(ps_find_tree)
+export(ps_fs_info)
+export(ps_fs_mount_point)
+export(ps_fs_stat)
 export(ps_get_cpu_affinity)
 export(ps_get_nice)
 export(ps_gids)
@@ -61,6 +66,7 @@ export(ps_tty_size)
 export(ps_uids)
 export(ps_username)
 export(ps_users)
+export(ps_wait)
 export(ps_windows_nice_values)
 export(signals)
 export(with_process_cleanup)
diff --git a/src/library/ps/NEWS.md b/src/library/ps/NEWS.md
index 415644587..257f80f2b 100644
--- a/src/library/ps/NEWS.md
+++ b/src/library/ps/NEWS.md
@@ -1,3 +1,42 @@
+# ps 1.8.1
+
+* ps can now be installed again on unsupported platforms.
+
+# ps 1.8.0
+
+* New `ps_apps()` function to list all running applications on macOS.
+
+* New function `ps_disk_io_counters()` to query disk I/O counters
+  (#145, @michaelwalshe).
+
+* New `ps_fs_info()` to query information about the file system of one
+  or more files or directories.
+
+* New `ps_wait()` to start an interruptible wait on multiple processes,
+  with a timeout (#166).
+
+* `ps_handle()` now allows a numeric (double) scalar as the pid, as long
+  as its value is integer.
+
+* `ps_send_signal()`, `ps_suspend()`, `ps_resume()`, `ps_terminate()`,
+  `ps_kill()`, and `ps_interrupt()` can now operate on multiple processes,
+  if passed a list of process handles.
+
+* `ps_kill()` and `ps_kill_tree()` have a new `grace` argument.
+  On Unix, if this argument is not zero, then `ps_kill()` first sends a
+  `TERM` signal, and waits for the processes to quit gracefully, via
+  `ps_wait()`. The processes that are still alive after the grace period
+  are then killed with `SIGKILL`.
+
+* `ps_status()` (and thus `ps()`) is now better at getting the correct
+  status of processes on macOS. This usually requires calling the external
+  `ps` tool. See `?ps_status()` on how to opt out from the new
+  behavior (#31).
+
+# ps 1.7.7
+
+* `ps_cpu_times()` values are now correct on newer arm64 macOS.
+
 # ps 1.7.6
 
 * `ps_name()` now does not fail in the rare case when `ps_cmdline()` returns an empty vector (#150).
diff --git a/src/library/ps/R/cleancall.R b/src/library/ps/R/cleancall.R
new file mode 100644
index 000000000..944cfd3c5
--- /dev/null
+++ b/src/library/ps/R/cleancall.R
@@ -0,0 +1,4 @@
+
+call_with_cleanup <- function(ptr, ...) {
+  .Call(cleancall_call, pairlist(ptr, ...), parent.frame())
+}
diff --git a/src/library/ps/R/disk.R b/src/library/ps/R/disk.R
index e340cf9a4..b6bc362d9 100644
--- a/src/library/ps/R/disk.R
+++ b/src/library/ps/R/disk.R
@@ -120,3 +120,305 @@ ps__disk_usage_format_posix <- function(paths, l) {
 
   d
 }
+
+#' System-wide disk I/O counters
+#'
+#' Returns a data.frame of system-wide disk I/O counters.
+#'
+#' Includes the following non-NA fields for all supported platforms:
+#' * `read_count`: number of reads
+#' * `write_count`: number of writes
+#' * `read_bytes`: number of bytes read
+#' * `write_bytes`: number of bytes written
+#'
+#' And for only some platforms:
+#' * `read_time`: time spent reading from disk (in milliseconds)
+#' * `write_time`: time spent writing to disk (in milliseconds)
+#' * `busy_time`: time spent doing actual I/Os (in milliseconds)
+#' * `read_merged_count`: number of merged reads (see iostats doc)
+#' * `write_merged_count`: number of merged writes (see iostats doc)
+#'
+#' @return A data frame of one row per disk of I/O stats, with columns
+#' `name`, `read_count` `read_merged_count` `read_bytes`, `read_time`,
+#' `write_count`, `write_merged_count`, `write_bytes` `write_time`, and
+#' `busy_time`.
+#'
+#' @family disk functions
+#' @export
+#' @examplesIf ps::ps_is_supported() && ps:::ps_os_name() %in% c("LINUX", "WINDOWS") && !ps:::is_cran_check()
+#' ps_disk_io_counters()
+ps_disk_io_counters <- function() {
+  os <- ps_os_name()
+  tab <- if (os == "LINUX") {
+    ps__disk_io_counters_linux()
+  } else if (os == "WINDOWS") {
+    ps__disk_io_counters_windows()
+  } else {
+    ps__disk_io_counters_macos()
+  }
+
+  class(tab) <- c("tbl", "data.frame")
+  tab
+}
+
+ps__disk_io_counters_windows <- function() {
+  l <- .Call(ps__disk_io_counters)
+  disk_info <- data_frame(
+    name = l[[1]],
+    read_count = l[[2]],
+    read_merged_count = NA,
+    read_bytes = l[[3]],
+    read_time = l[[4]],
+    write_count = l[[5]],
+    write_merged_count = NA,
+    write_bytes = l[[6]],
+    write_time = l[[7]],
+    busy_time = NA
+  )
+
+  disk_info[disk_info$name != "",]
+}
+
+ps__disk_io_counters_macos <- function() {
+  tab <- not_null(.Call(ps__disk_io_counters))
+  data_frame(
+    name = names(tab),
+    read_count = map_dbl(tab, "[[", 1),
+    read_merged_count = NA,
+    read_bytes = map_dbl(tab, "[[", 3),
+    read_time = map_dbl(tab, "[[", 5),
+    write_count = map_dbl(tab, "[[", 2),
+    write_merged_count = NA,
+    write_bytes = map_dbl(tab, "[[", 4),
+    write_time = map_dbl(tab, "[[", 6),
+    busy_time = NA
+  )
+}
+
+#' File system information for files
+#'
+#' @param paths A path or a vector of paths. `ps_fs_info()` returns
+#'   information about the file systems of all paths. `path` may contain
+#'   direcories as well.
+#' @return Data frame with file system information for each
+#'   path in `paths`, one row per path. Common columns for all
+#'   operating systems:
+#'   * `path`: The input paths, i.e. the `paths` argument.
+#'   * `mountpoint`: Directory where the file system is mounted.
+#'     On Linux there is a small chance that it was not possible to
+#'     look this up, and it is `NA_character_`. This is the drive letter
+#'     or the mount directory on Windows, with a trailing `\`.
+#'   * `name`: Device name.
+#'     On Linux there is a small chance that it was not possible to
+#'     look this up, and it is `NA_character_`. On Windows this is the
+#'     volume GUID path of the form `\\?\Volume{GUID}\`.
+#'   * `type`: File system type (character).
+#'     On Linux there is a tiny chance that it was not possible to
+#'     look this up, and it is `NA_character_`.
+#'   * `block_size`: File system block size. This is the sector size on
+#'     Windows, in bytes.
+#'   * `transfer_block_size`: Pptimal transfer block size. On Linux it is
+#'     currently always the same as `block_size`. This is the cluster size
+#'     on Windows, in bytes.
+#'   * `total_data_blocks`: Total data blocks in file system. On Windows
+#'     this is the number of sectors.
+#'   * `free_blocks`: Free blocks in file system. On Windows this is the
+#'     number of free sectors.
+#'   * `free_blocks_non_superuser`: Free blocks for a non-superuser, which
+#'     might be different on Unix. On Windows this is the number of free
+#'     sectors for the calling user.
+#'   * `id`: File system id. This is a raw vector. On Linux it is
+#'     often all zeros. It is always `NULL` on Windows.
+#'   * `owner`: User that mounted the file system. On Linux and Windows
+#'     this is currently always `NA_real_`.
+#'   * `type_code`: Type of file system, a numeric code. On Windows this
+#'     this is `NA_real_`.
+#'   * `subtype_code`: File system subtype (flavor). On Linux and Windows
+#'     this is always `NA_real_`.
+#'
+#'   The rest of the columns are flags, and they are operating system
+#'   dependent.
+#'
+#'   macOS:
+#'
+#'   * `RDONLY`: A read-only filesystem.
+#'   * `SYNCHRONOUS`: File system is written to synchronously.
+#'   * `NOEXEC`: Can't exec from filesystem.
+#'   * `NOSUID`: Setuid bits are not honored on this filesystem.
+#'   * `NODEV`: Don't interpret special files.
+#'   * `UNION`: Union with underlying filesysten.
+#'   * `ASYNC`: File system written to asynchronously.
+#'   * `EXPORTED`: File system is exported.
+#'   * `LOCAL`: File system is stored locally.
+#'   * `QUOTA`: Quotas are enabled on this file system.
+#'   * `ROOTFS`: This file system is the root of the file system.
+#'   * `DOVOLFS`: File system supports volfs.
+#'   * `DONTBROWSE`: File system is not appropriate path to user data.
+#'   * `UNKNOWNPERMISSIONS`:  VFS will ignore ownership information on
+#'     filesystem filesystemtem objects.
+#'   * `AUTOMOUNTED`: File system was mounted by automounter.
+#'   * `JOURNALED`: File system is journaled.
+#'   * `DEFWRITE`: File system should defer writes.
+#'   * `MULTILABEL`: MAC support for individual labels.
+#'   * `CPROTECT`: File system supports per-file encrypted data protection.
+#'
+#'   Linux:
+#'
+#'   * `MANDLOCK`: Mandatory locking is permitted on the filesystem
+#'     (see `fcntl(2)`).
+#'   * `NOATIME`: Do not update access times; see `mount(2)`.
+#'   * `NODEV`: Disallow access to device special files on this filesystem.
+#'   * `NODIRATIME`: Do not update directory access times; see mount(2).
+#'   * `NOEXEC`: Execution of programs is disallowed on this filesystem.
+#'   * `NOSUID`: The set-user-ID and set-group-ID bits are ignored by
+#'      `exec(3)` for executable files on this filesystem
+#'   * `RDONLY`: This filesystem is mounted read-only.
+#'   * `RELATIME`: Update atime relative to mtime/ctime; see `mount(2)`.
+#'   * `SYNCHRONOUS`: Writes are synched to the filesystem immediately
+#'     (see the description of `O_SYNC` in `open(2)``).
+#'   * `NOSYMFOLLOW`: Symbolic links are not followed when resolving paths;
+#'     see `mount(2)``.
+#'
+#'   Windows:
+#'
+#'   * `CASE_SENSITIVE_SEARCH`: Supports case-sensitive file names.
+#'   * `CASE_PRESERVED_NAMES`: Supports preserved case of file names when
+#'      it places a name on disk.
+#'   * `UNICODE_ON_DISK`: Supports Unicode in file names as they appear on
+#'      disk.
+#'   * `PERSISTENT_ACLS`: Preserves and enforces access control lists
+#'      (ACL). For example, the NTFS file system preserves and enforces
+#'      ACLs, and the FAT file system does not.
+#'   * `FILE_COMPRESSION`: Supports file-based compression.
+#'   * `VOLUME_QUOTAS`: Supports disk quotas.
+#'   * `SUPPORTS_SPARSE_FILES`: Supports sparse files.
+#'   * `SUPPORTS_REPARSE_POINTS`: Supports reparse points.
+#'   * `SUPPORTS_REMOTE_STORAGE`: Supports remote storage.
+#'   * `RETURNS_CLEANUP_RESULT_INFO`: On a successful cleanup operation,
+#'      the file system returns information that describes additional
+#'      actions taken during cleanup, such as deleting the file. File
+#'      system filters can examine this information in their post-cleanup
+#'      callback.
+#'   * `SUPPORTS_POSIX_UNLINK_RENAME`: Supports POSIX-style delete and
+#'      rename operations.
+#'   * `VOLUME_IS_COMPRESSED`: It is a compressed volume, for example, a
+#'      DoubleSpace volume.
+#'   * `SUPPORTS_OBJECT_IDS`: Supports object identifiers.
+#'   * `SUPPORTS_ENCRYPTION`: Supports the Encrypted File System (EFS).
+#'   * `NAMED_STREAMS`: Supports named streams.
+#'   * `READ_ONLY_VOLUME`: It is read-only.
+#'   * `SEQUENTIAL_WRITE_ONCE`: Supports a single sequential write.
+#'   * `SUPPORTS_TRANSACTIONS`: Supports transactions.
+#'   * `SUPPORTS_HARD_LINKS`: The volume supports hard links.
+#'   * `SUPPORTS_EXTENDED_ATTRIBUTES`: Supports extended attributes.
+#'   * `SUPPORTS_OPEN_BY_FILE_ID`: Supports open by FileID.
+#'   * `SUPPORTS_USN_JOURNAL`: Supports update sequence number (USN)
+#'      journals.
+#'   * `SUPPORTS_INTEGRITY_STREAMS`: Supports integrity streams.
+#'   * `SUPPORTS_BLOCK_REFCOUNTING`: The volume supports sharing logical
+#'      clusters between files on the same volume.
+#'   * `SUPPORTS_SPARSE_VDL`: The file system tracks whether each cluster
+#'      of a file contains valid data (either from explicit file writes or
+#'      automatic zeros) or invalid data (has not yet been written to or
+#'      zeroed).
+#'   * `DAX_VOLUME`: The volume is a direct access (DAX) volume.
+#'   * `SUPPORTS_GHOSTING`: Supports ghosting.
+#'
+#' @export
+#' @examplesIf ps::ps_is_supported() && ! ps:::is_cran_check()
+#' ps_fs_info(c("/", "~", "."))
+
+ps_fs_info <- function(paths = "/") {
+  assert_character(paths)
+  abspaths <- normalizePath(paths, mustWork = TRUE)
+  mps <- ps_fs_mount_point(paths)
+  res <- .Call(ps__fs_info, paths, abspaths, mps)
+  df <- as_data_frame(res)
+
+  # this should not happen in practice, but just in case
+  if (ps_os_type()[["LINUX"]] && any(is.na(df$type))) {
+    miss <- which(is.na(df$type))
+    df$type[miss] <- linux_fs_types$name[match(df$type_code[miss], linux_fs_types$id)]
+  }
+
+  df
+}
+
+linux_fs_types <- utils::read.table(
+  "tools/linux-fs-types.txt",
+  header = TRUE,
+  stringsAsFactors = FALSE
+)
+
+posix_stat_types <- c(
+  "regular file",
+  "directory",
+  "character device",
+  "block device",
+  "FIFO",
+  "symbolic link",
+  "socket"
+)
+
+#' File status
+#'
+#' This function is currently not implemented on Windows.
+#'
+#' @param paths Paths to files, directories, devices, etc. They must
+#'   exist. They are expanded using [base::path.expand()].
+#' @param follow Whether to follow symbolic links. If `FALSE` it returns
+#'   information on the links themselves.
+#' @return Data frame with one row for each path in `paths`. Columns:
+#'   * `path`: Expanded `paths`.
+#'   * `dev_major`: Major device ID of the device the path resides on.
+#'   * `dev_minor`: Minor device ID of the device the path resodes on.
+#'   * `inode`: Inode number.
+#'   * `mode`: File type and mode (permissions). It is easier to use the
+#'     `type` and `permissions` columns.
+#'   * `type`: File type, character. One of
+#'     `r paste(posix_stat_types, collapse = ", ")`.
+#'   * `permissions`: Permissions, numeric code in an integer column.
+#'   * `nlink`: Number of hard links.
+#'   * `uid`: User id of owner.
+#'   * `gid`: Group id of owner.
+#'   * `rdev_major`: If the path is a device, its major device id,
+#'     otherwise `NA_integer_`.
+#'   * `rdev_minor`: IF the path is a device, its minor device id,
+#'     otherwise `NA_integer_`.
+#'   * `size`: File size in bytes.
+#'   * `block_size`: Block size for filesystem I/O.
+#'   * `blocks`: Number of 512B blocks allocated.
+#'   * `access_time`: Time of last access.
+#'   * `modification_time`: Time of last modification.
+#'   * `change_time`: Time of last status change.
+#'
+#' @export
+#' @examplesIf ps::ps_is_supported() && ! ps:::is_cran_check() && ps_os_type()[["POSIX"]]
+#' ps_fs_stat(c(".", tempdir()))
+
+ps_fs_stat <- function(paths, follow = TRUE) {
+  assert_character(paths)
+  paths <- path.expand(paths)
+  res <- .Call(ps__stat, paths, follow)
+  res[["type"]] <- posix_stat_types[res[["type"]]]
+  res[["access_time"]] <- .POSIXct(res[["access_time"]], "UTC")
+  res[["modification_time"]] <- .POSIXct(res[["modification_time"]], "UTC")
+  res[["change_time"]] <- .POSIXct(res[["change_time"]], "UTC")
+  as_data_frame(res)
+}
+
+#' Find the mount point of a file or directory
+#'
+#' @param paths Paths to files, directories, devices, etc. They must
+#'   exist. They are normalized using [base::normalizePath()].
+#' @return Character vector, paths to the mount points of the input
+#'   `paths`.
+#' @export
+#' @examplesIf ps::ps_is_supported() && ! ps:::is_cran_check()
+#' ps_fs_mount_point(".")
+
+ps_fs_mount_point <- function(paths) {
+  assert_character(paths)
+  paths <- normalizePath(paths, mustWork = TRUE)
+  call_with_cleanup(ps__mount_point, paths)
+}
diff --git a/src/library/ps/R/iso-date.R b/src/library/ps/R/iso-date.R
new file mode 100644
index 000000000..687af22a3
--- /dev/null
+++ b/src/library/ps/R/iso-date.R
@@ -0,0 +1,144 @@
+
+milliseconds <- function(x) as.difftime(as.numeric(x) / 1000, units = "secs")
+seconds <- function(x) as.difftime(as.numeric(x), units = "secs")
+minutes <- function(x) as.difftime(as.numeric(x), units = "mins")
+hours <- function(x) as.difftime(as.numeric(x), units = "hours")
+days <- function(x) as.difftime(as.numeric(x), units = "days")
+weeks <- function(x) as.difftime(as.numeric(x), units = "weeks")
+wday <- function(x) as.POSIXlt(x, tz = "UTC")$wday + 1
+with_tz <- function(x, tzone = "") as.POSIXct(as.POSIXlt(x, tz = tzone))
+ymd <- function(x) as.POSIXct(x, format = "%Y %m %d", tz = "UTC")
+yj <- function(x) as.POSIXct(x, format = "%Y %j", tz = "UTC")
+
+parse_iso_8601 <- function(dates, default_tz = "UTC") {
+  if (default_tz == "") default_tz <- Sys.timezone()
+  dates <- as.character(dates)
+  match <- re_match(dates, iso_regex)
+  matching <- !is.na(match$.match)
+  result <- rep(.POSIXct(NA_real_, tz = ""), length.out = length(dates))
+  result[matching] <- parse_iso_parts(match[matching, ], default_tz)
+  class(result) <- c("POSIXct", "POSIXt")
+  with_tz(result, "UTC")
+}
+
+parse_iso_parts <- function(mm, default_tz) {
+
+  num <- nrow(mm)
+
+  ## -----------------------------------------------------------------
+  ## Date first
+
+  date <- .POSIXct(rep(NA_real_, num), tz = "")
+
+  ## Years-days
+  fyd <- is.na(date) & mm$yearday != ""
+  date[fyd] <- yj(paste(mm$year[fyd], mm$yearday[fyd]))
+
+  ## Years-weeks-days
+  fywd <- is.na(date) & mm$week != "" & mm$weekday != ""
+  date[fywd] <- iso_week(mm$year[fywd], mm$week[fywd], mm$weekday[fywd])
+
+  ## Years-weeks
+  fyw <- is.na(date) & mm$week != ""
+  date[fyw] <- iso_week(mm$year[fyw], mm$week[fyw], "1")
+
+  ## Years-months-days
+  fymd <- is.na(date) & mm$month != "" & mm$day != ""
+  date[fymd] <- ymd(paste(mm$year[fymd], mm$month[fymd], mm$day[fymd]))
+
+  ## Years-months
+  fym <- is.na(date) & mm$month != ""
+  date[fym] <- ymd(paste(mm$year[fym], mm$month[fym], "01"))
+
+  ## Years
+  fy <- is.na(date)
+  date[fy] <- ymd(paste(mm$year, "01", "01"))
+
+  ## -----------------------------------------------------------------
+  ## Now the time
+
+  th <- mm$hour != ""
+  date[th] <- date[th] + hours(mm$hour[th])
+
+  tm <- mm$min != ""
+  date[tm] <- date[tm] + minutes(mm$min[tm])
+
+  ts <- mm$sec != ""
+  date[ts] <- date[ts] + seconds(mm$sec[ts])
+
+  ## -----------------------------------------------------------------
+  ## Fractional time
+
+  frac <- as.numeric(sub(",", ".", mm$frac))
+
+  tfs <- !is.na(frac) & mm$sec != ""
+  date[tfs] <- date[tfs] + milliseconds(round(frac[tfs] * 1000))
+
+  tfm <- !is.na(frac) & mm$sec == "" & mm$min != ""
+  sec <- trunc(frac[tfm] * 60)
+  mil <- round((frac[tfm] * 60 - sec) * 1000)
+  date[tfm] <- date[tfm] + seconds(sec) + milliseconds(mil)
+
+  tfh <- !is.na(frac) & mm$sec == "" & mm$min == ""
+  min <- trunc(frac[tfh] * 60)
+  sec <- trunc((frac[tfh] * 60 - min) * 60)
+  mil <- round((((frac[tfh] * 60) - min) * 60 - sec) * 1000)
+  date[tfh] <- date[tfh] + minutes(min) + seconds(sec) + milliseconds(mil)
+
+  ## -----------------------------------------------------------------
+  ## Time zone
+
+  ftzpm <- mm$tzpm != ""
+  m <- ifelse(mm$tzpm[ftzpm] == "+", -1, 1)
+  ftzpmh <- ftzpm & mm$tzhour != ""
+  date[ftzpmh] <- date[ftzpmh] + m * hours(mm$tzhour[ftzpmh])
+  ftzpmm <- ftzpm & mm$tzmin != ""
+  date[ftzpmm] <- date[ftzpmm] + m * minutes(mm$tzmin[ftzpmm])
+
+  ftzz <- mm$tz == "Z"
+  date[ftzz] <- as.POSIXct(date[ftzz], "UTC")
+
+  ftz <- mm$tz != "Z" & mm$tz != ""
+  date[ftz] <- as.POSIXct(date[ftz], mm$tz[ftz])
+
+  if (default_tz != "UTC") {
+    ftna <- mm$tzpm == "" & mm$tz == ""
+    if (any(ftna)) {
+      dd <- as.POSIXct(format_iso_8601(date[ftna]),
+                       "%Y-%m-%dT%H:%M:%S+00:00", tz = default_tz)
+      date[ftna] <- dd
+    }
+  }
+
+  as.POSIXct(date, "UTC")
+}
+
+iso_regex <- paste0(
+  "^\\s*",
+  "(?<year>[\\+-]?\\d{4}(?!\\d{2}\\b))",
+  "(?:(?<dash>-?)",
+   "(?:(?<month>0[1-9]|1[0-2])",
+    "(?:\\g{dash}(?<day>[12]\\d|0[1-9]|3[01]))?",
+    "|W(?<week>[0-4]\\d|5[0-3])(?:-?(?<weekday>[1-7]))?",
+    "|(?<yearday>00[1-9]|0[1-9]\\d|[12]\\d{2}|3",
+      "(?:[0-5]\\d|6[1-6])))",
+   "(?<time>[T\\s](?:(?:(?<hour>[01]\\d|2[0-3])",
+            "(?:(?<colon>:?)(?<min>[0-5]\\d))?|24\\:?00)",
+           "(?<frac>[\\.,]\\d+(?!:))?)?",
+    "(?:\\g{colon}(?<sec>[0-5]\\d)(?:[\\.,]\\d+)?)?",
+    "(?<tz>[zZ]|(?<tzpm>[\\+-])",
+     "(?<tzhour>[01]\\d|2[0-3]):?(?<tzmin>[0-5]\\d)?)?)?)?$"
+  )
+
+iso_week <- function(year, week, weekday) {
+
+  wdmon <- function(date) { (wday(date) + 5L) %% 7L }
+  thu <- function(date) { date - days(wdmon(date) - 3L) }
+
+  thu(ymd(paste(year, "01", "04"))) + weeks(as.numeric(week) - 1L) +
+    days(as.numeric(weekday) - 4L)
+}
+
+format_iso_8601 <- function(date) {
+  format(as.POSIXlt(date, tz = "UTC"), "%Y-%m-%dT%H:%M:%S+00:00")
+}
diff --git a/src/library/ps/R/kill-tree.R b/src/library/ps/R/kill-tree.R
index 1a5b709fa..7e94abaa4 100644
--- a/src/library/ps/R/kill-tree.R
+++ b/src/library/ps/R/kill-tree.R
@@ -132,27 +132,34 @@ ps_find_tree <- function(marker) {
 #' use to find the marked processes.
 #' @param sig The signal to send to the marked processes on Unix. On
 #' Windows this argument is ignored currently.
+#' @param grace Grace period, in milliseconds, used on Unix, if `sig` is
+#'   `SIGKILL`.  If it is not zero, then `ps_kill_tree()` first sends a
+#'   `SIGTERM` signal to all processes. If some proccesses do not
+#'   terminate within `grace` milliseconds after the `SIGTERM` signal,
+#'   `ps_kill_tree()` kills them by sending `SIGKILL` signals.
 #'
 #' @rdname ps_kill_tree
 #' @export
 
-ps_kill_tree <- function(marker, sig = signals()$SIGKILL) {
+ps_kill_tree <- function(marker, sig = signals()$SIGKILL, grace = 200) {
 
-  assert_string(marker)
   # NULL on Windows
-  if (.Platform$OS.type != "windows") assert_integer(sig)
-
-  after <- as.numeric(strsplit(marker, "_", fixed = TRUE)[[1]][2])
+  if (!ps_os_type()[["WINDOWS"]]) {
+    sig <- assert_integer(sig)
+  }
 
-  pids <- setdiff(ps_pids(), Sys.getpid())
+  procs <- ps_find_tree(marker)
+  pids <- map_int(procs, ps_pid)
+  nms <- map_chr(
+    procs,
+    function(p) tryCatch(ps_name(p), error = function(e) "???")
+  )
 
-  ret <- lapply(pids, function(p) {
-    tryCatch(
-      .Call(ps__kill_if_env, marker, after, p, sig),
-      error = function(e) e
-    )
-  })
+  if (!ps_os_type()[["WINDOWS"]] && sig == signals()$SIGKILL) {
+    ps_send_signal(procs, sig)
+  } else {
+    ps_kill(procs, grace = grace)
+  }
 
-  gone <- map_lgl(ret, function(x) is.character(x))
-  structure(pids[gone], names = unlist(ret[gone]))
+  structure(pids, names = nms)
 }
diff --git a/src/library/ps/R/linux.R b/src/library/ps/R/linux.R
index 6d3ae4097..ca1288bc4 100644
--- a/src/library/ps/R/linux.R
+++ b/src/library/ps/R/linux.R
@@ -191,3 +191,110 @@ ps__system_cpu_times_linux <- function() {
   names(tms) <- nms[1:length(tms)]
   tms
 }
+
+ps__disk_io_counters_linux <- function() {
+  # Internal disk IO counters for Linux, reads lines from diskstats if it exists
+  # or /sys/block as a backup
+  if (file.exists("/proc/diskstats")) {
+    ps__read_procfs()
+  } else if (dir.exists("/sys/block")) {
+    ps__read_sysfs()
+  } else {
+    stop("Can't read disk IO, neither /proc/diskstats or /sys/block on this system")
+  }
+}
+
+ps__is_storage_device <- function(name, including_virtual = TRUE) {
+  # Whether a named drive (e.g. 'sda') is a real storage device, or a virtual one
+  name <- gsub("/", "!", name, fixed=TRUE)
+  if (including_virtual) {
+    path <- file.path("/sys/block", name)
+  } else {
+    path <- file.path("/sys/block", name, "device")
+  }
+
+  return(dir.exists(path))
+}
+
+ps__read_procfs <- function() {
+  # Read total disk IO stats from /proc/diskstats
+  file <- readLines("/proc/diskstats")
+  # Get info as list of vectors (could be different lengths)
+  lines <- strsplit(trimws(file), "\\s+")
+  # Pre-allocate matrix of info as NAs
+  mat <- matrix(data = NA_character_, nrow = length(lines), ncol = 10)
+  for (i in seq_along(lines)) {
+    # For each line, check length and insert into matrix as appropriate
+    line <- lines[[i]]
+    flen <- length(line)
+    if (flen == 15) {
+      # Linux 2.4
+      mat[i, 1] <- line[[4]] # name
+      mat[i, 2] <- line[[3]] # reads
+      mat[i, 3:9] <- line[5:11] # reads_merged, rbytes, rtime, writes, writes_merged, wbytes, wtime
+      mat[i, 10] <- line[[14]] # busy_time
+    } else if (flen == 14 || flen >= 18) {
+      # Linux 2.6+, line referring to a disk
+      mat[i, 1] <- line[[3]] # name
+      mat[i, 2:9] <- line[5:12] # reads, reads_merged, rbytes, rtime, writes, writes_merged, wbytes, wtime
+      mat[i, 10] <- line[[14]] # busy_time
+    } else if (flen == 7) {
+      # Linux 2.6+, line referring to a partition
+      mat[i, 1] <- line[[2]] # name
+      mat[i, 2] <- line[[4]] # reads
+      mat[i, 4:5] <- line[5:6] # rbytes, writes
+      mat[i, 8] <- line[7] # wbytes
+    } else {
+      stop("Cannot read diskstats file")
+    }
+  }
+
+  # Add names and convert types as appropriate
+  return(data.frame(
+    name = mat[, 1],
+    read_count = as.numeric(mat[, 2]),
+    read_merged_count = as.numeric(mat[, 3]),
+    read_bytes = as.numeric(mat[, 4]) * 512, # Multiple by disk sector size to get bytes
+    read_time = as.numeric(mat[, 5]),
+    write_count = as.numeric(mat[, 6]),
+    write_merged_count = as.numeric(mat[, 7]),
+    write_bytes = as.numeric(mat[, 8]) * 512, # Multiple by disk sector size to get bytes
+    write_time = as.numeric(mat[, 9]),
+    busy_time = as.numeric(mat[, 10])
+  ))
+}
+
+ps__read_sysfs <- function() {
+  # Read disk IO from each device folder in /sys/block
+
+  # Get stat files for each block
+  blocks <- list.dirs("/sys/block/", recursive = FALSE)
+  all_files <- list.files(blocks, full.names = TRUE)
+  stats <- all_files[grepl("(stat)$", all_files)]
+
+  # Pre-allocate list for dfs
+  disk_info <- vector(mode = "list", length = length(stats))
+  for (i in seq_along(stats)) {
+    # Read in each file, get the field
+    stat <- stats[[i]]
+    fields <- readLines(stat)
+    fields <- unlist(strsplit(trimws(fields), "\\s+"))
+
+    # Save all info as a dataframe
+    block_info <- data.frame(
+      name = strsplit(stat, "/", fixed=TRUE)[[1]][[5]], # Extract name from stat filepath
+      read_count = as.numeric(fields[[1]]),
+      read_merged_count = as.numeric(fields[[2]]),
+      read_bytes = as.numeric(fields[[3]]) * 512, # Multiple by disk sector size to get bytes
+      read_time = as.numeric(fields[[4]]),
+      write_count = as.numeric(fields[[5]]),
+      write_merged_count = as.numeric(fields[[6]]),
+      write_bytes = as.numeric(fields[[7]]) * 512, # Multiple by disk sector size to get bytes
+      write_time = as.numeric(fields[[8]]),
+      busy_time = as.numeric(fields[[10]])
+    )
+
+    disk_info[[i]] <- block_info
+  }
+  return(do.call(rbind, disk_info))
+}
diff --git a/src/library/ps/R/low-level.R b/src/library/ps/R/low-level.R
index a6e6691d2..ccabfdc2d 100644
--- a/src/library/ps/R/low-level.R
+++ b/src/library/ps/R/low-level.R
@@ -15,7 +15,7 @@
 #' p
 
 ps_handle <- function(pid = NULL, time = NULL) {
-  if (!is.null(pid)) assert_pid(pid)
+  if (!is.null(pid)) pid <- assert_pid(pid)
   if (!is.null(time)) assert_time(time)
   .Call(psll_handle, pid, time)
 }
@@ -177,13 +177,21 @@ ps_name <- function(p = ps_handle()) {
     ## If it matches the first part of the cmdline we return that
     ## one instead because it's usually more explicative.
     ## Examples are "gnome-keyring-d" vs. "gnome-keyring-daemon".
+
+    ## In addition, under qemu (e.g. in cross-platform Docker), the
+    ## first entry is qemu and the second entry is the file name
     cmdline <- tryCatch(
       ps_cmdline(p),
       error = function(e) NULL
     )
     if (!is.null(cmdline) && length(cmdline) > 0L) {
       exname <- basename(cmdline[1])
-      if (str_starts_with(exname, n)) n <- exname
+      if (str_starts_with(exname, n)) {
+        n <- exname
+      } else if (grepl("qemu", exname) && length(cmdline) >= 2 &&
+                 str_starts_with(exname2 <- basename(cmdline[2]), n)) {
+        n <- exname2
+      }
     }
   }
   n
@@ -241,7 +249,8 @@ ps_cmdline <- function(p = ps_handle()) {
 #' Current process status
 #'
 #' One of the following:
-#' * `"idle"`: Process being created by fork, macOS only.
+#' * `"idle"`: Process being created by fork, or process has been sleeping
+#'     for a long time. macOS only.
 #' * `"running"`: Currently runnable on macOS and Windows. Actually
 #'     running on Linux.
 #' * `"sleeping"` Sleeping on a wait or poll.
@@ -249,6 +258,7 @@ ps_cmdline <- function(p = ps_handle()) {
 #'    (Linux only).
 #' * `"stopped"` Stopped, either by a job control signal or because it
 #'    is being traced.
+#' * `"uninterruptible"` Process is in uninterruptible wait. macOS only.
 #' * `"tracing_stop"` Stopped for tracing (Linux only).
 #' * `"zombie"` Zombie. Finished, but parent has not read out the exit
 #'    status yet.
@@ -256,8 +266,29 @@ ps_cmdline <- function(p = ps_handle()) {
 #' * `"wake_kill"` Received fatal signal (Linux only).
 #' * `"waking"` Paging (Linux only, not valid since the 2.6.xx kernel).
 #'
+#' It might return `NA_character_` on macOS.
+#'
 #' Works for zombie processes.
 #'
+#' @section Note on macOS:
+#' On macOS `ps_status()` often falls back to calling the external `ps`
+#' program, because macOS does not let R access the status of most other
+#' processes. Notably, it is usually able to access the status of other R
+#' processes.
+#'
+#' The external `ps` program always runs as the root user, and
+#' it also has special entitlements, so it can typically access the status
+#' of most processes.
+#'
+#' If this behavior is problematic for you, e.g. because calling an
+#' external program is too slow, set the `ps.no_external_ps` option to
+#' `TRUE`:
+#' ```
+#' options(ps.no_external_ps = TRUE)
+#' ```
+#' Note that setting this option to `TRUE` will cause `ps_status()` to
+#' return `NA_character_` for most processes.
+#'
 #' @param p Process handle.
 #' @return Character scalar.
 #'
@@ -270,10 +301,14 @@ ps_cmdline <- function(p = ps_handle()) {
 
 ps_status <- function(p = ps_handle()) {
   assert_ps_handle(p)
-  .Call(psll_status, p)
+  ret <- .Call(psll_status, p)
+  if (is.na(ret) && ps_os_type()[["MACOS"]] &&
+      !isTRUE(getOption("ps.no_external_ps"))) {
+    ret <- ps_status_macos_ps(ps_pid(p))
+  }
+  ret
 }
 
-
 #' Owner of the process
 #'
 #' The name of the user that owns the process. On Unix it is calculated
@@ -376,7 +411,9 @@ ps_gids <- function(p = ps_handle()) {
 ps_terminal <- function(p = ps_handle()) {
   assert_ps_handle(p)
   ttynr <- .Call(psll_terminal, p)
-  if (is.na(ttynr)) {
+  if (is.character(ttynr)) {
+    ttynr
+  } else if (is.na(ttynr)) {
     NA_character_
   } else {
     tmap <- get_terminal_map()
@@ -399,6 +436,28 @@ ps_terminal <- function(p = ps_handle()) {
 #'
 #' These functions throw a `zombie_process` error for zombie processes.
 #'
+#' @section macOS issues:
+#'
+#' `ps_environ()` usually does not work on macOS nowadays. This is because
+#' macOS does not allow reading the environment variables of another
+#' process. Accoding to the Darwin source code, `ps_environ` will work is
+#' one of these conditions hold:
+#'
+#' * You are running a development or debug kernel, i.e. if you are
+#'   debugging the macOS kernel itself.
+#' * The target process is same as the calling process.
+#' * SIP if off.
+#' * The target process is not restricted, e.g. it is running a binary
+#'   that was not signed.
+#' * The calling process has the
+#'   `com.apple.private.read-environment-variables` entitlement. However
+#'   adding this entitlement to the R binary makes R crash on startup.
+#'
+#' Otherwise `ps_environ` will return an empty set of environment variables
+#' on macOS.
+#'
+#' Issue 121 might have more information about this.
+#'
 #' @param p Process handle.
 #' @return `ps_environ()` returns a named character vector (that has a
 #' `Dlist` class, so it is printed nicely), `ps_environ_raw()` returns a
@@ -482,7 +541,7 @@ ps_cpu_times <- function(p = ps_handle()) {
 #'
 #' `ps_memory_info()` returns information about memory usage.
 #'
-#' It returns a named list. Portable fields:
+#' It returns a named vector. Portable fields:
 #' * `rss`: "Resident Set Size", this is the non-swapped physical memory a
 #'   process has used (bytes). On UNIX it matches "top"‘s 'RES' column (see doc). On
 #'   Windows this is an alias for `wset` field and it matches "Memory"
@@ -580,6 +639,41 @@ ps_memory_full_info <- function(p = ps_handle()) {
   }
 }
 
+process_signal_result <- function(p, res, err_msg) {
+  ok <- map_lgl(res, function(x) is.character(x) || is.null(x))
+  if (all(ok)) {
+    unlist(res)
+  } else {
+    for (i in which(!ok)) {
+      class(res[[i]]) <- res[[i]][[2]]
+    }
+    pids <- map_int(res[!ok], function(x) x[["pid"]] %||% NA_integer_)
+    nms <- map_chr(p[!ok], function(pp) {
+      tryCatch(ps_name(pp), error = function(e) "???")
+    })
+    pmsg <- paste0(pids, " (", nms, ")", collapse = ", ")
+    # put these classes at the end
+    common <- c("ps_error", "error", "condition")
+    cls <- c(
+      unique(setdiff(unlist(lapply(res[!ok], function(x) class(x))), common)),
+      common
+    )
+    err <- structure(
+      list(
+        message = paste0(
+          err_msg,
+          if (length(p) == 1) ": " else " some processes: ",
+          pmsg
+        ),
+        results = res,
+        pid = pids
+      ),
+      class = cls
+    )
+    stop(err)
+  }
+}
+
 #' Send signal to a process
 #'
 #' Send a signal to the process. Not implemented on Windows. See
@@ -588,7 +682,7 @@ ps_memory_full_info <- function(p = ps_handle()) {
 #' It checks if the process is still running, before sending the signal,
 #' to avoid signalling the wrong process, because of pid reuse.
 #'
-#' @param p Process handle.
+#' @param p Process handle, or a list of process handles.
 #' @param sig Signal number, see [signals()].
 #'
 #' @family process handle functions
@@ -603,9 +697,15 @@ ps_memory_full_info <- function(p = ps_handle()) {
 #' px$get_exit_status()
 
 ps_send_signal <- function(p = ps_handle(), sig) {
-  assert_ps_handle(p)
+  p <- assert_ps_handle_or_handle_list(p)
   assert_signal(sig)
-  .Call(psll_send_signal, p, sig)
+  res <- lapply(p, function(pp) {
+    tryCatch(
+      .Call(psll_send_signal, pp, sig),
+      error = function(e) e
+    )
+  })
+  process_signal_result(p, res, "Failed to send signal to")
 }
 
 #' Suspend (stop) the process
@@ -614,7 +714,7 @@ ps_send_signal <- function(p = ps_handle(), sig) {
 #' whether PID has been reused. On Windows this has the effect of
 #' suspending all process threads.
 #'
-#' @param p Process handle.
+#' @param p Process handle or a list of process handles.
 #'
 #' @family process handle functions
 #' @export
@@ -629,8 +729,14 @@ ps_send_signal <- function(p = ps_handle(), sig) {
 #' ps_kill(p)
 
 ps_suspend <- function(p = ps_handle()) {
-  assert_ps_handle(p)
-  .Call(psll_suspend, p)
+  p <- assert_ps_handle_or_handle_list(p)
+  res <- lapply(p, function(pp) {
+    tryCatch(
+      .Call(psll_suspend, pp),
+      error = function(e) e
+    )
+  })
+  process_signal_result(p, res, "Failed to suspend")
 }
 
 #' Resume (continue) a stopped process
@@ -639,7 +745,7 @@ ps_suspend <- function(p = ps_handle()) {
 #' whether PID has been reused. On Windows this has the effect of resuming
 #' all process threads.
 #'
-#' @param p Process handle.
+#' @param p Process handle or a list of process handles.
 #'
 #' @family process handle functions
 #' @export
@@ -654,8 +760,14 @@ ps_suspend <- function(p = ps_handle()) {
 #' ps_kill(p)
 
 ps_resume <- function(p = ps_handle()) {
-  assert_ps_handle(p)
-  .Call(psll_resume, p)
+  p <- assert_ps_handle_or_handle_list(p)
+  res <- lapply(p, function(pp) {
+    tryCatch(
+      .Call(psll_resume, pp),
+      error = function(e) e
+    )
+  })
+  process_signal_result(p, res, "Failed to resume")
 }
 
 #' Terminate a Unix process
@@ -664,7 +776,7 @@ ps_resume <- function(p = ps_handle()) {
 #'
 #' Checks if the process is still running, to work around pid reuse.
 #'
-#' @param p Process handle.
+#' @param p Process handle or a list of process handles.
 #'
 #' @family process handle functions
 #' @export
@@ -678,16 +790,34 @@ ps_resume <- function(p = ps_handle()) {
 #' px$get_exit_status()
 
 ps_terminate <- function(p = ps_handle()) {
-  assert_ps_handle(p)
-  .Call(psll_terminate, p)
+  p <- assert_ps_handle_or_handle_list(p)
+  res <- lapply(p, function(pp) {
+    tryCatch(
+      .Call(psll_terminate, pp),
+      error = function(e) e
+    )
+  })
+  process_signal_result(p, res, "Failed to terminate")
 }
 
-#' Kill a process
+#' Kill one or more processes
 #'
-#' Kill the current process with SIGKILL preemptively checking
-#' whether PID has been reused. On Windows it uses `TerminateProcess()`.
+#' Kill the process with SIGKILL preemptively checking whether PID has
+#' been reused. On Windows it uses `TerminateProcess()`.
 #'
-#' @param p Process handle.
+#' Note that since ps version 1.8, `ps_kill()` does not error if the
+#' `p` process (or some processes if `p` is a list) are already terminated.
+#'
+#' @param p Process handle, or a list of process handles.
+#' @param grace Grace period, in milliseconds, used on Unix. If it is not
+#'   zero, then `ps_kill()` first sends a `SIGTERM` signal to all processes
+#'   in `p`. If some proccesses do not terminate within `grace`
+#'   milliseconds after the `SIGTERM` signal, `ps_kill()` kills them by
+#'   sending `SIGKILL` signals.
+#' @return Character vector, with one element for each process handle in
+#'   `p`. If the process was already dead before `ps_kill()` tried to kill
+#'   it, the corresponding return value is `"dead"`. If `ps_kill()` just
+#'   killed it, it is `"killed"`.
 #'
 #' @family process handle functions
 #' @export
@@ -700,9 +830,27 @@ ps_terminate <- function(p = ps_handle()) {
 #' ps_is_running(p)
 #' px$get_exit_status()
 
-ps_kill <- function(p = ps_handle()) {
-  assert_ps_handle(p)
-  .Call(psll_kill, p)
+ps_kill <- function(p = ps_handle(), grace = 200) {
+  p <- assert_ps_handle_or_handle_list(p)
+  grace <- assert_grace(grace)
+  if (ps_os_type()[["WINDOWS"]]) {
+    res <- lapply(p, function(pp) {
+      tryCatch({
+        if (ps_is_running(pp)) {
+          .Call(psll_kill, pp, 0L)
+          "killed"
+        } else {
+          "dead"
+        }
+      }, error = function(e) {
+        if (inherits(e, "no_such_process")) "dead" else e
+      })
+    })
+  } else {
+    res <- call_with_cleanup(psll_kill, p, grace)
+  }
+
+  process_signal_result(p, res, "Failed to kill")
 }
 
 #' List of child processes (process objects) of the process. Note that
@@ -964,22 +1112,27 @@ ps_connections <- function(p = ps_handle()) {
 #'
 #' Sends `SIGINT` on POSIX, and 'CTRL+C' or 'CTRL+BREAK' on Windows.
 #'
-#' @param p Process handle.
+#' @param p Process handle or a list of process handles.
 #' @param ctrl_c On Windows, whether to send 'CTRL+C'. If `FALSE`, then
 #'   'CTRL+BREAK' is sent. Ignored on non-Windows platforms.
 #'
 #' @family process handle functions
 #' @export
 
-ps_interrupt  <- function(p = ps_handle(), ctrl_c = TRUE) {
-  assert_ps_handle(p)
+ps_interrupt <- function(p = ps_handle(), ctrl_c = TRUE) {
+  p <- assert_ps_handle_or_handle_list(p)
   assert_flag(ctrl_c)
-  if (ps_os_type()[["WINDOWS"]]) {
-    interrupt <- get_tool("interrupt")
-    .Call(psll_interrupt, p, ctrl_c, interrupt)
-  } else {
-    .Call(psll_interrupt, p, ctrl_c, NULL)
-  }
+  res <- lapply(p, function(pp) {
+    tryCatch({
+      if (ps_os_type()[["WINDOWS"]]) {
+        interrupt <- get_tool("interrupt")
+        .Call(psll_interrupt, pp, ctrl_c, interrupt)
+      } else {
+        .Call(psll_interrupt, pp, ctrl_c, NULL)
+      }
+    }, error = function(e) e)
+  })
+  process_signal_result(p, res, "Failed to interrupt")
 }
 
 #' @return `ps_windows_nice_values()` return a character vector of possible
@@ -1145,3 +1298,40 @@ ps_set_cpu_affinity <- function(p = ps_handle(), affinity) {
 
   invisible(.Call(psll_set_cpu_aff, p, affinity))
 }
+
+#' Wait for one or more processes to terminate, with a timeout
+#'
+#' This function supports interruption with SIGINT on Unix, or CTRL+C
+#' or CTRL+BREAK on Windows.
+#'
+#' @param p A process handle, or a list of process handles. The
+#'   process(es) to wait for.
+#' @param timeout Timeout in milliseconds. If -1, `ps_wait()` will wait
+#'   indefinitely (or until it is interrupted). If 0, then it checks which
+#'   processes have already terminated, and returns immediately.
+#' @return Logical vector, with one value of each process in `p`.
+#'   For processes that terminated it contains a `TRUE` value. For
+#'   processes that are still running it contains a `FALSE` value.
+#'
+#' @export
+#' @examplesIf ps::ps_is_supported() && ! ps:::is_cran_check() && ps::ps_os_type()["POSIX"]
+#' # this example calls `sleep`, so it only works on Unix
+#' p1 <- processx::process$new("sleep", "100")
+#' p2 <- processx::process$new("sleep", "100")
+#'
+#' # returns c(FALSE, FALSE) immediately if p1 and p2 are running
+#' ps_wait(list(p1$as_ps_handle(), p2$as_ps_handle()), 0)
+#'
+#' # timeouts at one second
+#' ps_wait(list(p1$as_ps_handle(), p2$as_ps_handle()), 1000)
+#'
+#' p1$kill()
+#' p2$kill()
+#' # returns c(TRUE, TRUE) immediately
+#' ps_wait(list(p1$as_ps_handle(), p2$as_ps_handle()), 1000)
+
+ps_wait <- function(p, timeout = -1) {
+  p <- assert_ps_handle_or_handle_list(p)
+  timeout <- assert_integer(timeout)
+  call_with_cleanup(psll_wait, p, timeout)
+}
diff --git a/src/library/ps/R/macos.R b/src/library/ps/R/macos.R
new file mode 100644
index 000000000..f01ec6a03
--- /dev/null
+++ b/src/library/ps/R/macos.R
@@ -0,0 +1,85 @@
+
+#' List currently running applications
+#'
+#' This function currently only works on macOS.
+#'
+#' @return A data frame with columns:
+#'   - `pid`: integer process id.
+#'   - `name`: process name.
+#'   - `bundle_identifier`: bundle identifier, e.g. `com.apple.dock`.
+#'   - `bundle_url`: bundle URL, a `file://` URL to the app bundle.
+#'   - `arch`: executable architecture, possible values are
+#'     `r paste(macos_archs$name, collapse = ", ")`.
+#'   - `executable_url`: `file://` URL to the executable file.
+#'   - `launch_date`: launch time stamp, a `POSIXct` object, may be `NA`.
+#'   - `finished_launching`: whether the app has finished launching.
+#'   - `active`: whether the app is active.
+#'   - `activation_policy`: one of the following values:
+#'     * `regular`: the application is an ordinary app that appears in the
+#'       Dock and may have a user interface.
+#'     * `accessory`: the application doesn’t appear in the Dock and
+#'       doesn’t have a menu bar, but it may be activated programmatically
+#'       or by clicking on one of its windows.
+#'     * `prohibited`: the application doesn’t appear in the Dock and may
+#'       not create windows or be activated.
+#'
+#' @export
+#' @examplesIf ps_is_supported() && ps_os_type()[["MACOS"]] && !ps:::is_cran_check()
+#' ps_apps()
+
+ps_apps <- function() {
+  if (!ps_os_type()[["MACOS"]]) {
+    stop("'ps_apps()' is only implemented on macOS")
+  }
+  tab <- as_data_frame(.Call(ps__list_apps))
+
+  tab <- tab[, c("pid", setdiff(names(tab), "pid"))]
+  tab[["arch"]] <- macos_archs$name[match(tab[["arch"]], macos_archs$code)]
+  tab[["launch_date"]] <- parse_iso_8601(
+    sub(" +", "+", fixed = TRUE, tab[["launch_date"]])
+  )
+  # drop the ones without a pid, they are clearly (?) not running
+  tab <- tab[tab$pid != -1, ]
+  tab
+}
+
+macos_archs <- data.frame(
+  name = c("arm64",    "i386",     "x86_64",   "ppc",      "ppc64"),
+  code = c(0x0100000c, 0x00000007, 0x01000007, 0x00000012, 0x01000012)
+)
+
+ps_status_macos_ps <- function(pids) {
+  stopifnot(is.integer(pids))
+  suppressWarnings(tryCatch({
+    out <- system2(
+      "/bin/ps",
+      c("-o", "pid,stat", "-p", paste(pids, collapse = ",")),
+      stdout = TRUE,
+      stderr = FALSE
+    )
+    out <- out[-1]
+    out <- trimws(out)
+    out2 <- strsplit(out, " ")
+    opids <- map_int(out2, function(x) as.integer(x[[1]]))
+    state <- map_chr(out2, function(x) substr(x[[2]], 1, 1))
+    state <- macos_process_states[state]
+    unname(state[match(pids, opids)])
+  }, error = function(e) rep(NA_character_, length(pids))))
+}
+
+# From `man 1 ps`
+# I       Marks a process that is idle (sleeping for longer than about 20 seconds).
+# R       Marks a runnable process.
+# S       Marks a process that is sleeping for less than about 20 seconds.
+# T       Marks a stopped process.
+# U       Marks a process in uninterruptible wait.
+# Z       Marks a dead process (a “zombie”).
+
+macos_process_states <- c(
+  I = "idle",
+  R = "running",
+  S = "sleeping",
+  T = "stopped",
+  U = "uninterruptible",
+  Z = "zombie"
+)
diff --git a/src/library/ps/R/ps.R b/src/library/ps/R/ps.R
index e15ecd55f..c92ae3c4e 100644
--- a/src/library/ps/R/ps.R
+++ b/src/library/ps/R/ps.R
@@ -59,7 +59,17 @@ ps <- function(user = NULL, after = NULL) {
   pd <- map_int(processes, function(p) fallback(ps_pid(p), NA_integer_))
   pp <- map_int(processes, function(p) fallback(ps_ppid(p), NA_integer_))
   nm <- map_chr(processes, function(p) fallback(ps_name(p), NA_character_))
+
+  opt <- options(ps.no_external_ps = TRUE)
+  on.exit(options(opt), add = TRUE)
   st <- map_chr(processes, function(p) fallback(ps_status(p), NA_character_))
+  options(opt)
+  if (ps_os_type()[["MACOS"]] && !isTRUE(getOption("ps.no_external_ps")) &&
+      anyNA(st[pids != 0])) {
+    misspids <- map_int(processes[is.na(st)], ps_pid)
+    st[is.na(st)] <- ps_status_macos_ps(misspids)
+  }
+
   time <- lapply(processes, function(p) fallback(ps_cpu_times(p), NULL))
   cpt <- map_dbl(time, function(x) x[["user"]] %||% NA_real_)
   cps <- map_dbl(time, function(x) x[["system"]] %||% NA_real_)
diff --git a/src/library/ps/R/rematch2.R b/src/library/ps/R/rematch2.R
new file mode 100644
index 000000000..ba6bdc9b0
--- /dev/null
+++ b/src/library/ps/R/rematch2.R
@@ -0,0 +1,31 @@
+
+re_match <- function(text, pattern, perl = TRUE, ...) {
+  text <- as.character(text)
+
+  match <- regexpr(pattern, text, perl = perl, ...)
+
+  start  <- as.vector(match)
+  length <- attr(match, "match.length")
+  end    <- start + length - 1L
+
+  matchstr <- substring(text, start, end)
+  matchstr[ start == -1 ] <- NA_character_
+
+  res <- data_frame(.text = text, .match = matchstr)
+
+  if (!is.null(attr(match, "capture.start"))) {
+
+    gstart  <- attr(match, "capture.start")
+    glength <- attr(match, "capture.length")
+    gend    <- gstart + glength - 1L
+
+    groupstr <- substring(text, gstart, gend)
+    groupstr[ gstart == -1 ] <- NA_character_
+    dim(groupstr) <- dim(gstart)
+
+    res <- cbind(groupstr, res, stringsAsFactors = FALSE)
+  }
+  names(res) <- c(attr(match, "capture.names"), ".text", ".match")
+  class(res) <- c("tbl", class(res))
+  res
+}
diff --git a/src/library/ps/R/testthat-reporter.R b/src/library/ps/R/testthat-reporter.R
index ba543f833..6ad9b4eb4 100644
--- a/src/library/ps/R/testthat-reporter.R
+++ b/src/library/ps/R/testthat-reporter.R
@@ -10,6 +10,11 @@ globalVariables("private")
 #' Child processes can be reported via a failed expectation, cleaned up
 #' silently, or cleaned up and reported (the default).
 #'
+#' If a `test_that()` block has an error, `CLeanupReporter` does not
+#' emit any expectations at the end of that block. The error will lead to a
+#' test failure anyway. It will still perform the cleanup, if requested,
+#' however.
+#'
 #' The constructor of the `CleanupReporter` class has options:
 #' * `file`: the output file, if any, this is passed to `reporter`.
 #' * `proc_unit`: when to perform the child process check and cleanup.
@@ -110,6 +115,7 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
       },
 
       start_test = function(context, test) {
+        private$has_error <- FALSE
         super$start_test(context, test)
         if (private$file_unit == "test") private$files <- ps_open_files(ps_handle())
         if (private$rconn_unit == "test") private$rconns <- showConnections()
@@ -125,6 +131,13 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
         super$end_test(context, test)
       },
 
+      add_result = function(context, test, result) {
+        if (inherits(result, "expectation_error")) {
+          private$has_error <- TRUE
+        }
+        super$add_result(context, test, result)
+      },
+
       start_reporter = function() {
         super$start_reporter()
         if (private$file_unit == "testsuite") private$files <- ps_open_files(ps_handle())
@@ -155,11 +168,16 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
         if (private$proc_fail) {
           while (length(ret <- ps::ps_find_tree(private$tree_id)) &&
                  Sys.time() < deadline) Sys.sleep(0.05)
+          # maybe gc() will clean up something
+          if (length(ret) > 0) {
+            gc()
+            ret <- ps::ps_find_tree(private$tree_id)
+          }
         }
         if (private$proc_cleanup) {
           ret <- ps::ps_kill_tree(private$tree_id)
         }
-        if (private$proc_fail)  {
+        if (private$proc_fail && !private$has_error)  {
           testthat::with_reporter(self, start_end_reporter = FALSE, {
             self$expect_cleanup(test, ret, quote)
           })
@@ -172,13 +190,20 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
         private$rconns <- NULL
         leftover <- ! new[, "description"] %in% old[, "description"]
 
+        # maybe gc() will clean up some
+        if (sum(leftover) > 0) {
+          gc()
+          new <- showConnections()
+          leftover <- ! new[, "description"] %in% old[, "description"]
+        }
+
         if (private$rconn_cleanup) {
           for (no in as.integer(rownames(new)[leftover])) {
             tryCatch(close(getConnection(no)), error = function(e) NULL)
           }
         }
 
-        if (private$rconn_fail) {
+        if (private$rconn_fail && !private$has_error) {
           act <- testthat::quasi_label(rlang::enquo(test), test)
           testthat::expect(
             sum(leftover) == 0,
@@ -200,7 +225,15 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
         ## * /dev/urandom might be opened internally by curl, openssl, etc.
         leftover <- leftover & new$path != "/dev/urandom"
 
-        if (private$file_fail) {
+        # maybe gc() will clean up some
+        if (sum(leftover) > 0) {
+          gc()
+          new <- ps_open_files(ps_handle())
+          leftover <- ! new$path %in% old$path
+          leftover <- leftover & new$path != "/dev/urandom"
+        }
+
+        if (private$file_fail && !private$has_error) {
           act <- testthat::quasi_label(rlang::enquo(test), test)
           testthat::expect(
             sum(leftover) == 0,
@@ -220,6 +253,7 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
         ## from the processes connection tables, so we try waiting a bit.
         ## We haven't seen issues with this on other OSes yet.
         deadline <- Sys.time() + as.difftime(0.5, units = "secs")
+        done <- FALSE
         repeat {
           new <- ps_connections(ps_handle())[, 1:6]
           ## This is a connection that is used internally on macOS,
@@ -238,14 +272,21 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
           leftover <- ! apply(new, 1, paste, collapse = "&") %in%
             apply(old, 1, paste, collapse = "&")
 
-          if (!ps_os_type()[["WINDOWS"]] ||
-              sum(leftover) == 0 ||
-              Sys.time() >= deadline) break;
+          # is this the final try, or are we all clean?
+          if (done || sum(leftover) == 0) break
+
+          # if Unix, then try again after gc()
+          # on Windows, gc() after a timeout, then quit
+          if (!ps_os_type()[["WINDOWS"]] || Sys.time() >= deadline) {
+            gc()
+            done <- TRUE
+            next
+          }
 
           Sys.sleep(0.05)
         }
 
-        if (private$conn_fail) {
+        if (private$conn_fail && !private$has_error) {
           left <- new[leftover,]
           act <- testthat::quasi_label(rlang::enquo(test), test)
           testthat::expect(
@@ -290,7 +331,9 @@ CleanupReporter <- function(reporter = testthat::ProgressReporter) {
       conn_fail = NULL,
       conns = NULL,
 
-      tree_id = NULL
+      tree_id = NULL,
+
+      has_error = FALSE
     )
   )
 }
diff --git a/src/library/ps/R/utils.R b/src/library/ps/R/utils.R
index fca2fb9c0..6ea318884 100644
--- a/src/library/ps/R/utils.R
+++ b/src/library/ps/R/utils.R
@@ -114,7 +114,11 @@ assert_string <- function(x) {
 }
 
 assert_integer <- function(x) {
-  if (is.integer(x) && length(x) == 1 && !is.na(x)) return()
+  x <- tryCatch(
+    suppressWarnings(as.integer(x)),
+    error = function(e) x
+  )
+  if (is.integer(x) && length(x) == 1 && !is.na(x)) return(x)
   stop(ps__invalid_argument(match.call()$x,
                             " is not a scalar integer"))
 }
@@ -126,11 +130,27 @@ assert_character <- function(x) {
 }
 
 assert_pid <- function(x) {
-  if (is.integer(x) && length(x) == 1 && !is.na(x)) return()
+  if (is.integer(x) && length(x) == 1 && !is.na(x)) return(x)
+  if (is.numeric(x) && length(x) == 1 && !is.na(x) &&
+      as.integer(x) == x) {
+    return(as.integer(x))
+  }
   stop(ps__invalid_argument(match.call()$x,
                             " is not a process id (integer scalar)"))
 }
 
+assert_grace <- function(x) {
+  if (is.integer(x) && length(x) == 1 && !is.na(x) && x >= 0) return(x)
+  if (is.numeric(x) && length(x) == 1 && !is.na(x) && x >= 0) {
+    xi <- as.integer(x)
+    # if x is non-zero, then return non-zero
+    if (xi == 0 && x > 0) return(1)
+    return(as.integer(x))
+  }
+  stop(ps__invalid_argument(match.call()$x,
+                            " is not a non-negative integer"))
+}
+
 assert_time <- function(x) {
   if (inherits(x, "POSIXct")) return()
   stop(ps__invalid_argument(match.call()$x,
@@ -143,6 +163,24 @@ assert_ps_handle <- function(x) {
                             " must be a process handle (ps_handle)"))
 }
 
+assert_ps_handle_list <- function(x) {
+  if (all(map_lgl(x, inherits, "ps_handle"))) return()
+  stop(ps__invalid_argument(
+    match.call()$x,
+    " must be a process handle (ps_handle) or a list of process handles"
+  ))
+}
+
+assert_ps_handle_or_handle_list <- function(p) {
+  if (!is.list(p)) {
+    assert_ps_handle(p)
+    p <- list(p)
+  } else {
+    assert_ps_handle_list(p)
+  }
+  p
+}
+
 assert_flag <- function(x) {
   if (is.logical(x) && length(x) == 1 && !is.na(x)) return()
   stop(ps__invalid_argument(match.call()$x,
diff --git a/src/library/ps/configure b/src/library/ps/configure
index a437802cc..4566d1b3f 100755
--- a/src/library/ps/configure
+++ b/src/library/ps/configure
@@ -62,7 +62,7 @@ unset AIX
 # ------------------------------------------------------------------------
 
 MACROS=""
-OBJECTS="init.o api-common.o common.o extra.o dummy.o error-codes.o"
+OBJECTS="init.o api-common.o common.o extra.o dummy.o error-codes.o cleancall.o"
 
 if [ -n "$POSIX" ]; then
     OBJECTS="${OBJECTS} posix.o api-posix.o";
@@ -105,6 +105,8 @@ elif [ -n "$MACOS" ]; then
     MACROS="${MACROS} PS__MACOS"
     PS__MACOS=1
     OBJECTS="${OBJECTS} macos.o api-macos.o arch/macos/process_info.o"
+    OBJECTS="${OBJECTS} arch/macos/disk.o arch/macos/apps.o"
+    FRAMEWORKS="-framework AppKit"
 
 elif [ -n "$FREEBSD" ]; then
     MACROS="${MACROS} PS__FREEBSD"
@@ -158,11 +160,13 @@ fi
 # LIBRARIES -> PKG_LIBS
 
 LIBS=`for l in $LIBRARIES; do echo "-l${l}"; done | tr "\n", " "`
+LIBS="${LIBS} $FRAMEWORKS"
 
 cat src/Makevars.in | \
     sed "s|@OBJECTS@|${OBJECTS}|" | \
     sed "s/@LIBS@/${LIBS}/" | \
-    sed "s/@TARGETS@/${TARGETS}/" > src/Makevars
+    sed "s/@TARGETS@/${TARGETS}/" | \
+    sed "s|@EXTRA@|${EXTRA}|" > src/Makevars
 
 # MACROS will be set as preprocessor macros
 echo "/* Macros created by configure */" > src/config.h
@@ -171,4 +175,3 @@ for m in $MACROS; do
     echo \#undef $m
     eval echo '\#'define $m $ind
 done >> src/config.h
-
diff --git a/src/library/ps/src/api-linux.c b/src/library/ps/src/api-linux.c
index 3c5adddcd..fa81f534e 100644
--- a/src/library/ps/src/api-linux.c
+++ b/src/library/ps/src/api-linux.c
@@ -1,8 +1,9 @@
-
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE 1
 #endif
 
+#include "ps-internal.h"
+
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -16,10 +17,22 @@
 #include <mntent.h>
 #include <sys/sysinfo.h>
 #include <sched.h>
+#include <sys/vfs.h>
+#include <libgen.h>
+#include <sys/syscall.h>
+#include <sys/epoll.h>
+#include <time.h>
+#include <sys/inotify.h>
+#include <poll.h>
 
 #include <Rinternals.h>
 
 #include "common.h"
+#include "cleancall.h"
+
+#ifndef SYS_pidfd_open
+#define SYS_pidfd_open              434
+#endif
 
 double psll_linux_boot_time = 0;
 double psll_linux_clock_period = 0;
@@ -317,7 +330,10 @@ SEXP psll_handle(SEXP pid, SEXP time) {
   if (!isNull(time))  {
     ctime = REAL(time)[0];
   } else {
-    if (psll_linux_ctime(cpid, &ctime)) ps__throw_error();
+    if (psll_linux_ctime(cpid, &ctime)) {
+      ps__set_error_from_errno();
+      ps__throw_error();
+    }
   }
 
   handle = malloc(sizeof(ps_handle_t));
@@ -653,11 +669,21 @@ SEXP psll_terminal(SEXP p) {
   }
   PS__CHECK_STAT(stat, handle);
 
-  if (stat.tty_nr == 0) {
-    return ScalarInteger(NA_INTEGER);
-  } else {
+  if (stat.tty_nr != 0) {
     return ScalarInteger(stat.tty_nr);
   }
+
+  if (handle->pid != getpid()) {
+    return ScalarInteger(NA_INTEGER);
+  }
+
+  // It is us, try ttyname. This is a workaround for qemu, where
+  // /proc/self/stat is messed up
+  char const *tty = ttyname (STDIN_FILENO);
+  if (! tty) {
+    return ScalarInteger(NA_INTEGER);
+  }
+  return mkString(tty);
 }
 
 SEXP psll_environ(SEXP p) {
@@ -848,43 +874,6 @@ static int psl__linux_match_environ(SEXP r_marker, SEXP r_pid) {
   return ps__memmem(buf, ret, marker, strlen(marker)) != NULL;
 }
 
-SEXP ps__kill_if_env(SEXP r_marker, SEXP r_after, SEXP r_pid, SEXP r_sig) {
-
-  pid_t pid = INTEGER(r_pid)[0];
-  int sig = INTEGER(r_sig)[0];
-  int ret;
-  int match;
-
-  match = psl__linux_match_environ(r_marker, r_pid);
-
-  if (match == -1) ps__throw_error();
-
-  if (match) {
-    psl_stat_t stat;
-    char *name;
-    int stret = psll__parse_stat_file(pid, &stat, &name);
-    ret = kill(pid, sig);
-    if (ret == -1) {
-      if (errno == ESRCH) {
-	ps__no_such_process(pid, 0);
-      } else if (errno == EPERM  || errno == EACCES) {
-	ps__access_denied("");
-      } else {
-	ps__set_error_from_errno();
-      }
-      ps__throw_error();
-    }
-
-    if (stret != -1) {
-      return ps__str_to_utf8(name);
-    } else {
-      return mkString("???");
-    }
-  }
-
-  return R_NilValue;
-}
-
 SEXP ps__find_if_env(SEXP r_marker, SEXP r_after, SEXP r_pid) {
   SEXP phandle;
   int match;
@@ -1211,6 +1200,370 @@ SEXP psll_set_cpu_aff(SEXP p, SEXP affinity) {
   return R_NilValue;
 }
 
+// timeout = 0 special case, no need to poll, just check if running
+SEXP psll_wait0(SEXP pps) {
+  R_xlen_t i, num_handles = Rf_xlength(pps);
+  SEXP res = PROTECT(Rf_allocVector(LGLSXP, num_handles));
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+    if (!handle) Rf_error("Process pointer #%d cleaned up already", (int) i);
+    LOGICAL(res)[i] = ! LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0];
+  }
+
+  UNPROTECT(1);
+  return res;
+}
+
+// Add time limit to current time.
+// clock_gettime does not fail, as long as the struct timespec
+// pointer is ok. So no need to check the return value.
+static void add_time(struct timespec *due, int ms) {
+  clock_gettime(CLOCK_MONOTONIC, due);
+  due->tv_sec = due->tv_sec + ms / 1000;
+  due->tv_nsec = due->tv_nsec + (ms % 1000) * 1000000;
+  if (due->tv_nsec >= 1000000000) {
+    due->tv_nsec -= 1000000000;
+    due->tv_sec++;
+  }
+}
+
+static inline int time_left(struct timespec *due) {
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  return
+    (due->tv_sec - now.tv_sec) * 1000 +
+    (due->tv_nsec - now.tv_nsec) / 1000 / 1000;
+}
+
+struct psll__wait_inotify_cleanup_data {
+  int inotfd;
+};
+
+void psll__wait_inotify_cleanup(void *data) {
+  struct psll__wait_inotify_cleanup_data *cdata =
+    (struct psll__wait_inotify_cleanup_data*) data;
+  if (cdata->inotfd != -1) {
+    close(cdata->inotfd);
+  }
+}
+
+SEXP psll_wait_inotify(SEXP pps, SEXP timeout) {
+  int ctimeout = INTEGER(timeout)[0];
+  int forever = ctimeout < 0;
+  R_xlen_t i, num_handles = Rf_xlength(pps);
+
+  struct psll__wait_inotify_cleanup_data cdata = { -1 };
+  r_call_on_early_exit(psll__wait_inotify_cleanup, &cdata);
+
+  cdata.inotfd = inotify_init1(IN_NONBLOCK);
+  if (cdata.inotfd == -1) {
+    ps__set_error_from_errno();
+    ps__throw_error();
+  }
+
+  SEXP res = PROTECT(Rf_allocVector(LGLSXP, num_handles));
+  memset(LOGICAL(res), 0, sizeof(int) * num_handles);
+  SEXP rwatches = PROTECT(Rf_allocVector(INTSXP, num_handles));
+  int *watches = INTEGER(rwatches);
+
+  char path[128];
+  R_xlen_t topoll = 0;
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+    if (!handle) Rf_error("Process pointer #%d cleaned up already", (int) i);
+    if (!LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0]) {
+      // already done
+      LOGICAL(res)[i] = 1;
+    } else {
+      snprintf(path, sizeof(path)-1, "/proc/%d/exe", handle->pid);
+      watches[i] = inotify_add_watch(cdata.inotfd, path, IN_CLOSE_NOWRITE);
+      if (watches[i] == -1) {
+        if (errno == ENOENT) {
+          // just finished
+          LOGICAL(res)[i] = 0;
+        } else {
+          ps__set_error_from_errno();
+          ps__throw_error();
+        }
+      } else {
+        topoll++;
+      }
+    }
+  }
+
+  // early exit if nothing to do
+  if (topoll == 0) {
+    psll__wait_inotify_cleanup(&cdata);
+    UNPROTECT(2);
+    return res;
+  }
+
+  // first timeout is the smaller of PROCESSX_INTERRUPT_INTERVAL & timeout
+  int ts;
+  if (forever || ctimeout > PROCESSX_INTERRUPT_INTERVAL) {
+    ts = PROCESSX_INTERRUPT_INTERVAL;
+  } else {
+    ts = ctimeout;
+  }
+
+  // this is the ultimate time limit, unless we poll forever
+  struct timespec due;
+  if (!forever) {
+    add_time(&due, ctimeout);
+  }
+
+  struct pollfd pfd = { cdata.inotfd, POLLIN, 0 };
+  int ret;
+
+  do {
+    do {
+      ret = poll(&pfd, 1, ts);
+    } while (ret == -1 && errno == EINTR);
+
+    if (ret == -1) {
+      ps__set_error_from_errno();
+      ps__throw_error();
+    }
+
+    if (ret > 0) {
+      struct inotify_event event;
+      ret = read(cdata.inotfd, &event, sizeof(event));
+      if (ret == -1) {
+        ps__set_error_from_errno();
+        ps__throw_error();
+      }
+      // this should not happen
+      if (event.len > 0) {
+        Rf_error("Invalid inotify event in ps_wait.");
+      }
+
+      // now we need to see if the event means that any processes have quit
+      for (i = 0; i < num_handles; i++) {
+        // we know that it finished
+        if (LOGICAL(res)[i]) continue;
+        if (watches[i] == event.wd) {
+          if (!LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0]) {
+            LOGICAL(res)[i] = 1;
+            topoll--;
+          } else {
+            // Still running, but we got an event. Maybe it called execve()
+            // We need to start watching the new exe, if any. We might be
+            // still watching the old exe, as this might be needed for
+            // other processes.
+            ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+            snprintf(path, sizeof(path)-1, "/proc/%d/exe", handle->pid);
+            watches[i] = inotify_add_watch(cdata.inotfd, path, IN_CLOSE_NOWRITE);
+            if (watches[i] == -1) {
+              if (errno == ENOENT) {
+                // just finished
+                LOGICAL(res)[i] = 1;
+                topoll--;
+              } else {
+                ps__set_error_from_errno();
+                ps__throw_error();
+              }
+            }
+          }
+        }
+      }
+
+      // are we done?
+      if (topoll == 0) {
+        break;
+      }
+    }
+
+    // is the time limit over? Do we need to update the poll timeout
+    if (!forever) {
+      int tl = time_left(&due);
+      if (tl < 0) {
+        break;
+      }
+      if (tl < PROCESSX_INTERRUPT_INTERVAL) {
+        ts = tl;
+      }
+    }
+
+    R_CheckUserInterrupt();
+
+  } while (1);
+
+  psll__wait_inotify_cleanup(&cdata);
+  UNPROTECT(2);
+  return res;
+}
+
+struct psll__wait_cleanup_data {
+  int epfd;
+  R_xlen_t num_handles;
+  int *pfds;
+};
+
+static void psll__wait_cleanup(void *data) {
+  struct psll__wait_cleanup_data *cdata =
+    (struct psll__wait_cleanup_data*) data;
+  if (cdata->epfd != -1) {
+    close(cdata->epfd);
+    cdata->epfd = -1;
+  }
+  R_xlen_t i;
+  if (cdata->pfds) {
+    for (i = 0; i < cdata->num_handles; i++) {
+      if (cdata->pfds[i] != -1) {
+        close(cdata->pfds[i]);
+      }
+    }
+  }
+}
+
+SEXP psll_wait(SEXP pps, SEXP timeout) {
+  int ctimeout = INTEGER(timeout)[0];
+  // this is much simpler, no need to poll at all
+  if (ctimeout == 0) {
+    return psll_wait0(pps);
+  }
+
+  // for testing
+  if (getenv("PS_WAIT_FORCE_INOTIFY")) {
+    return psll_wait_inotify(pps, timeout);
+  }
+
+  // Check if the kernel has pidfd_open() support
+  if (ps_pidfd_open_support == PS_MAYBE) {
+    int testfd = syscall(SYS_pidfd_open, getpid(), /* flags= */ 0);
+    if (testfd == -1) {
+      if (errno == ENOSYS || errno == ENODEV) {
+        ps_pidfd_open_support = PS_NOPE;
+      } else {
+        // this is a real error, e.g. EMFILE or ENFILE, but nevertheless
+        // we have pidfd_open support, so we march on, and error later, if
+        ps_pidfd_open_support = PS_YEAH;
+      }
+    } else {
+      ps_pidfd_open_support = PS_YEAH;
+      close(testfd);
+    }
+  }
+  if (ps_pidfd_open_support == PS_NOPE) {
+    return psll_wait_inotify(pps, timeout);
+  }
+
+  int forever = ctimeout < 0;
+  R_xlen_t i, num_handles = Rf_xlength(pps);
+
+  struct psll__wait_cleanup_data cdata = {
+    /* epfd=        */ -1,
+    /* num_handles= */ num_handles,
+    /* pfds= */        NULL
+  };
+  r_call_on_early_exit(psll__wait_cleanup, &cdata);
+  cdata.epfd = epoll_create(num_handles);
+  if (cdata.epfd == -1) {
+    ps__set_error_from_errno();
+    ps__throw_error();
+  }
+
+  SEXP res = PROTECT(Rf_allocVector(LGLSXP, num_handles));
+  SEXP pfds = PROTECT(Rf_allocVector(INTSXP, num_handles));
+  cdata.pfds = INTEGER(pfds);
+
+  R_xlen_t topoll = 0;
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+    if (!handle) Rf_error("Process pointer #%d cleaned up already", (int) i);
+    if (!LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0]) {
+      // already done
+      LOGICAL(res)[i] = 1;
+      cdata.pfds[i] = -1;
+    } else {
+      cdata.pfds[i] = syscall(SYS_pidfd_open, handle->pid, /* flags= */ 0);
+      if (cdata.pfds[i] == -1) {
+        if (errno == ESRCH) {
+          LOGICAL(res)[i] = 1;
+          cdata.pfds[i] = -1;
+        } else {
+          ps__set_error_from_errno();
+          ps__throw_error();
+        }
+      } else {
+        topoll++;
+        LOGICAL(res)[i] = 0;
+        struct epoll_event ev;
+        ev.events = EPOLLIN;
+        ev.data.u64 = i;
+        epoll_ctl(cdata.epfd, EPOLL_CTL_ADD, cdata.pfds[i], &ev);
+      }
+    }
+  }
+
+  // early exit if nothing to do
+  if (topoll == 0) {
+    psll__wait_cleanup(&cdata);
+    UNPROTECT(2);
+    return res;
+  }
+
+  int ret;
+  SEXP revents = PROTECT(Rf_allocVector(RAWSXP, sizeof(struct epoll_event) * topoll));
+  struct epoll_event *events = (struct epoll_event*) RAW(revents);
+
+  // first timeout is the smaller of PROCESSX_INTERRUPT_INTERVAL & timeout
+  int ts;
+  if (forever || ctimeout > PROCESSX_INTERRUPT_INTERVAL) {
+    ts = PROCESSX_INTERRUPT_INTERVAL;
+  } else {
+    ts = ctimeout;
+  }
+
+  // this is the ultimate time limit, unless we poll forever
+  struct timespec due;
+  if (!forever) {
+    add_time(&due, ctimeout);
+  }
+
+  do {
+    do {
+      ret = epoll_wait(cdata.epfd, events, topoll, ts);
+    } while (ret == -1 && errno == EINTR);
+
+    if (ret == -1) {
+      ps__set_error_from_errno();
+      ps__throw_error();
+    }
+
+    for (i = 0; i < ret; i++) {
+      uint64_t id = events[i].data.u64;
+      LOGICAL(res)[id] = 1;
+      close(cdata.pfds[id]);
+      cdata.pfds[id] = -1;
+      topoll--;
+    }
+
+    // are we done?
+    if (topoll == 0) {
+      break;
+    }
+
+    // is the time limit over? Do we need to update the poll timeout
+    if (!forever) {
+      int tl = time_left(&due);
+      if (tl < 0) {
+        break;
+      }
+      if (tl < PROCESSX_INTERRUPT_INTERVAL) {
+        ts = tl;
+      }
+    }
+
+    R_CheckUserInterrupt();
+
+  } while (1);
+
+  psll__wait_cleanup(&cdata);
+  UNPROTECT(3);
+  return res;
+}
+
 SEXP ps__users(void) {
   struct utmp *ut;
   SEXP result;
@@ -1284,6 +1637,151 @@ SEXP ps__disk_partitions(SEXP all) {
   return R_NilValue;
 }
 
+// These are from include/linux/statfs.h in Linux
+
+#define ST_RDONLY	0x0001	/* mount read-only */
+#define ST_NOSUID	0x0002	/* ignore suid and sgid bits */
+#define ST_NODEV	0x0004	/* disallow access to device special files */
+#define ST_NOEXEC	0x0008	/* disallow program execution */
+#define ST_SYNCHRONOUS	0x0010	/* writes are synced at once */
+#define ST_VALID	0x0020	/* f_flags support is implemented */
+#define ST_MANDLOCK	0x0040	/* allow mandatory locks on an FS */
+/* 0x0080 used for ST_WRITE in glibc */
+/* 0x0100 used for ST_APPEND in glibc */
+/* 0x0200 used for ST_IMMUTABLE in glibc */
+#define ST_NOATIME	0x0400	/* do not update access times */
+#define ST_NODIRATIME	0x0800	/* do not update directory access times */
+#define ST_RELATIME	0x1000	/* update atime relative to mtime/ctime */
+#define ST_NOSYMFOLLOW	0x2000	/* do not follow symlinks */
+
+SEXP ps__fs_info(SEXP path, SEXP abspath, SEXP mps) {
+  struct statfs sfs;
+  R_xlen_t i, j, len = Rf_xlength(path);
+  int ret;
+
+  // Need to query all partitions to get the device name and fs type.
+  SEXP partitions = PROTECT(ps__disk_partitions(Rf_ScalarLogical(1)));
+  R_xlen_t num_parts = Rf_xlength(partitions);
+
+  const char *nms[] = {
+    "path",
+    "mountpoint",
+    "name",
+    "type",
+    "block_size",
+    "transfer_block_size",
+    "total_data_blocks",
+    "free_blocks",
+    "free_blocks_non_superuser",
+    "total_nodes",
+    "free_nodes",
+    "id",
+    "owner",
+    "type_code",
+    "subtype_code",
+
+    "MANDLOCK",
+    "NOATIME",
+    "NODEV",
+    "NODIRATIME",
+    "NOEXEC",
+    "NOSUID",
+    "RDONLY",
+    "RELATIME",
+    "SYNCHRONOUS",
+    "NOSYMFOLLOW",
+    ""
+  };
+
+  SEXP res = PROTECT(Rf_mkNamed(VECSXP, nms));
+  SET_VECTOR_ELT(res, 0, path);
+  SET_VECTOR_ELT(res, 1, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 2, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 3, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 4, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 5, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 6, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 7, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 8, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 9, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 10, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 11, Rf_allocVector(VECSXP, len));
+  SET_VECTOR_ELT(res, 12, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 13, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 14, Rf_allocVector(REALSXP, len));
+
+  SET_VECTOR_ELT(res, 15, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 16, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 17, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 18, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 19, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 20, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 21, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 22, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 23, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 24, Rf_allocVector(LGLSXP, len));
+
+  for (i = 0; i < len; i++) {
+    ret = statfs(CHAR(STRING_ELT(abspath, i)), &sfs);
+    if (ret != 0) {
+      ps__set_error(
+        "statfs %s: %d %s",
+        CHAR(STRING_ELT(abspath, i)), errno, strerror(errno)
+      );
+      ps__throw_error();
+    }
+
+    SET_STRING_ELT(VECTOR_ELT(res, 1), i, NA_STRING);
+    SET_STRING_ELT(VECTOR_ELT(res, 2), i, NA_STRING);
+    SET_STRING_ELT(VECTOR_ELT(res, 3), i, NA_STRING);
+
+    // match the mount point to the partitions
+    const char *mpi = CHAR(STRING_ELT(mps, i));
+    for (j = 0; j < num_parts; j++) {
+      const char *mpp = CHAR(STRING_ELT(VECTOR_ELT(VECTOR_ELT(partitions, j), 1), 0));
+      if (0 == strcmp(mpi, mpp)) {
+        SET_STRING_ELT(
+          VECTOR_ELT(res, 1), i,
+          STRING_ELT(VECTOR_ELT(VECTOR_ELT(partitions, j), 1), 0));
+        SET_STRING_ELT(
+          VECTOR_ELT(res, 2), i,
+          STRING_ELT(VECTOR_ELT(VECTOR_ELT(partitions, j), 0), 0));
+        SET_STRING_ELT(
+          VECTOR_ELT(res, 3), i,
+          STRING_ELT(VECTOR_ELT(VECTOR_ELT(partitions, j), 2), 0));
+        break;
+      }
+    }
+
+    REAL(VECTOR_ELT(res, 4))[i] = sfs.f_bsize;
+    REAL(VECTOR_ELT(res, 5))[i] = sfs.f_bsize;
+    REAL(VECTOR_ELT(res, 6))[i] = sfs.f_blocks;
+    REAL(VECTOR_ELT(res, 7))[i] = sfs.f_bfree;
+    REAL(VECTOR_ELT(res, 8))[i] = sfs.f_bavail;
+    REAL(VECTOR_ELT(res, 9))[i] = sfs.f_files;
+    REAL(VECTOR_ELT(res, 10))[i] = sfs.f_ffree;
+    SET_VECTOR_ELT(VECTOR_ELT(res, 11), i, Rf_allocVector(RAWSXP, sizeof(fsid_t)));
+    memcpy(RAW(VECTOR_ELT(VECTOR_ELT(res, 11), i)), &sfs.f_fsid, sizeof(fsid_t));
+    REAL(VECTOR_ELT(res, 12))[i] = NA_REAL;
+    REAL(VECTOR_ELT(res, 13))[i] = sfs.f_type;
+    REAL(VECTOR_ELT(res, 14))[i] = NA_REAL;
+
+    LOGICAL(VECTOR_ELT(res, 15))[i] = sfs.f_flags & ST_MANDLOCK;
+    LOGICAL(VECTOR_ELT(res, 16))[i] = sfs.f_flags & ST_NOATIME;
+    LOGICAL(VECTOR_ELT(res, 17))[i] = sfs.f_flags & ST_NODEV;
+    LOGICAL(VECTOR_ELT(res, 18))[i] = sfs.f_flags & ST_NODIRATIME;
+    LOGICAL(VECTOR_ELT(res, 19))[i] = sfs.f_flags & ST_NOEXEC;
+    LOGICAL(VECTOR_ELT(res, 20))[i] = sfs.f_flags & ST_NOSUID;
+    LOGICAL(VECTOR_ELT(res, 21))[i] = sfs.f_flags & ST_RDONLY;
+    LOGICAL(VECTOR_ELT(res, 22))[i] = sfs.f_flags & ST_RELATIME;
+    LOGICAL(VECTOR_ELT(res, 23))[i] = sfs.f_flags & ST_SYNCHRONOUS;
+    LOGICAL(VECTOR_ELT(res, 24))[i] = sfs.f_flags & ST_NOSYMFOLLOW;
+  }
+
+  UNPROTECT(2);
+  return res;
+}
+
 SEXP ps__loadavg(SEXP counter_name) {
   /* Try /proc first, if fails we try sysinfo() */
   struct sysinfo info;
diff --git a/src/library/ps/src/api-macos.c b/src/library/ps/src/api-macos.c
index 06040ee18..e25661f56 100644
--- a/src/library/ps/src/api-macos.c
+++ b/src/library/ps/src/api-macos.c
@@ -10,19 +10,34 @@
 #include <sys/types.h>
 #include <libproc.h>
 #include <errno.h>
+#include <sys/errno.h>
 #include <string.h>
 #include <utmpx.h>
 #include <arpa/inet.h>
+#include <sys/param.h>
+#include <sys/mount.h>
 
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <mach/shared_region.h>
+#include <mach/mach_time.h>
+
+#include <sys/event.h>
+#include <sys/time.h>
 
 #include "ps-internal.h"
 #include "arch/macos/process_info.h"
+#include "cleancall.h"
 
 #include <stdbool.h>
 
+#if defined(__i386__) || defined(__ppc__)
+#define statfs statfs64
+#define getfsstat getfsstat64
+#endif
+
+struct mach_timebase_info PS_MACH_TIMEBASE_INFO;
+
 #define PS__TV2DOUBLE(t) ((t).tv_sec + (t).tv_usec / 1000000.0)
 
 #define PS__CHECK_KINFO(kp, handle)				      \
@@ -41,16 +56,101 @@
     PS__CHECK_KINFO(kp, handle);			\
   } while (0)
 
-#define PS__GET_STATUS(stat, result, error)		\
+#define PS__GET_STATUS(pid, stat, result, error)		\
   switch(stat) {					\
   case SIDL:   result = mkString("idle");     break;	\
-  case SRUN:   result = mkString("running");  break;	\
+  case SRUN:   result = ps__get_status(pid);  break;	\
   case SSLEEP: result = mkString("sleeping"); break;	\
   case SSTOP:  result = mkString("stopped");  break;	\
   case SZOMB:  result = mkString("zombie");   break;	\
   default:     error;					\
   }
 
+// this is a non-API alternative for task_for_pid(). ps uses this:
+// https://github.com/apple-oss-distributions/adv_cmds/blob/8744084ea0ff41ca4bb96b0f9c22407d0e48e9b7/ps/tasks.c#L28
+// but it seems that it does not actually change anything, and we still
+// cannot get the tesk for most processes, so no need to use it right now
+// extern kern_return_t task_read_for_pid(
+// 	mach_port_name_t target_tport,
+// 	int pid,
+// 	mach_port_name_t *t);
+
+SEXP ps__get_status(long pid) {
+  /*
+   * Scan threads for process state information.
+   * Based on:
+   * http://stackoverflow.com/questions/6788274/ios-mac-cpu-usage-for-thread and
+   * https://github.com/max-horvath/htop-osx/blob/e86692e869e30b0bc7264b3675d2a4014866ef46/ProcessList.c
+   */
+
+  kern_return_t ret;
+  task_t port;
+  ret = task_for_pid(mach_task_self(), pid, &port);
+  if (ret != KERN_SUCCESS) {
+    return Rf_ScalarString(NA_STRING);
+  }
+
+  task_info_data_t tinfo;
+  mach_msg_type_number_t task_info_count = TASK_INFO_MAX;
+  ret = task_info(
+    port,
+    TASK_BASIC_INFO,
+    (task_info_t) tinfo,
+    &task_info_count
+  );
+  if (ret != KERN_SUCCESS) {
+    return Rf_ScalarString(NA_STRING);
+  }
+
+  thread_array_t thread_list;
+  mach_msg_type_number_t thread_count;
+  ret = task_threads(port, &thread_list, &thread_count);
+  if (ret != KERN_SUCCESS) {
+    mach_port_deallocate(mach_task_self(), port);
+    return Rf_ScalarString(NA_STRING);
+  }
+
+  integer_t run_state = 999;
+  for (unsigned int i = 0; i < thread_count; i++) {
+    thread_info_data_t thinfo;
+    mach_msg_type_number_t thread_info_count = THREAD_BASIC_INFO_COUNT;
+    ret = thread_info(
+      thread_list[i],
+      THREAD_BASIC_INFO,
+      (thread_info_t) thinfo,
+      &thread_info_count
+    );
+    if (ret == KERN_SUCCESS) {
+      thread_basic_info_t basic_info_th = (thread_basic_info_t)thinfo;
+      if (basic_info_th->run_state < run_state) {
+        run_state = basic_info_th->run_state;
+      }
+      mach_port_deallocate(mach_task_self(), thread_list[i]);
+    }
+  }
+  vm_deallocate(
+    mach_task_self(),
+    (vm_address_t)thread_list,
+    sizeof(thread_port_array_t) * thread_count
+  );
+  mach_port_deallocate(mach_task_self(), port);
+
+  switch (run_state) {
+  case TH_STATE_RUNNING:
+    return mkString("running");
+  case TH_STATE_STOPPED:
+    return mkString("stopped");
+  case TH_STATE_WAITING:
+    return mkString("sleeping");
+  case TH_STATE_UNINTERRUPTIBLE:
+    return mkString("uninterruptible");
+  case TH_STATE_HALTED:
+    return mkString("halted");
+  default:
+    return Rf_ScalarString(NA_STRING);
+  }
+}
+
 void ps__check_for_zombie(ps_handle_t *handle, int err) {
   struct kinfo_proc kp;
   int ret;
@@ -130,7 +230,7 @@ SEXP psll_format(SEXP p) {
     PROTECT(status = mkString("terminated"));
   } else {
     PROTECT(name = ps__str_to_utf8(kp.kp_proc.p_comm));
-    PS__GET_STATUS(kp.kp_proc.p_stat, status, status = mkString("unknown"));
+    PS__GET_STATUS(handle->pid, kp.kp_proc.p_stat, status, status = mkString("unknown"));
     PROTECT(status);
   }
   PROTECT(result = ps__build_list("OldO", name, (long) handle->pid,
@@ -254,7 +354,7 @@ SEXP psll_status(SEXP p) {
 
   PS__CHECK_KINFO(kp, handle);
 
-  PS__GET_STATUS(kp.kp_proc.p_stat, result, error("Unknown process status"));
+  PS__GET_STATUS(handle->pid, kp.kp_proc.p_stat, result, error("Unknown process status"));
 
   return result;
 }
@@ -400,6 +500,8 @@ SEXP psll_cpu_times(SEXP p) {
   ps_handle_t *handle = R_ExternalPtrAddr(p);
   struct proc_taskinfo pti;
   SEXP result, names;
+  uint64_t total_user;
+  uint64_t total_system;
 
   if (!handle) error("Process pointer cleaned up already");
 
@@ -410,9 +512,14 @@ SEXP psll_cpu_times(SEXP p) {
 
   PS__CHECK_HANDLE(handle);
 
+  total_user = pti.pti_total_user * PS_MACH_TIMEBASE_INFO.numer;
+  total_user /= PS_MACH_TIMEBASE_INFO.denom;
+  total_system = pti.pti_total_system * PS_MACH_TIMEBASE_INFO.numer;
+  total_system /= PS_MACH_TIMEBASE_INFO.denom;
+
   PROTECT(result = allocVector(REALSXP, 4));
-  REAL(result)[0] = (double) pti.pti_total_user / 1000000000.0;
-  REAL(result)[1] = (double) pti.pti_total_system / 1000000000.0;
+  REAL(result)[0] = (double) total_user / 1000000000.0;
+  REAL(result)[1] = (double) total_system / 1000000000.0;
   REAL(result)[2] = REAL(result)[3] = NA_REAL;
   PROTECT(names = ps__build_string("user", "system", "children_user",
 				   "children_system", NULL));
@@ -489,52 +596,6 @@ SEXP ps__cpu_count_physical(void) {
     return ScalarInteger(num);
 }
 
-SEXP ps__kill_if_env(SEXP marker, SEXP after, SEXP pid, SEXP sig) {
-  const char *cmarker = CHAR(STRING_ELT(marker, 0));
-  pid_t cpid = INTEGER(pid)[0];
-  int csig = INTEGER(sig)[0];
-  SEXP env;
-  size_t i, len;
-
-  PROTECT(env = ps__get_environ(cpid));
-  if (isNull(env)) {
-    ps__set_error_from_errno();
-    ps__throw_error();
-  }
-
-  len = LENGTH(env);
-
-  for (i = 0; i < len; i++) {
-    if (strstr(CHAR(STRING_ELT(env, i)), cmarker)) {
-      struct kinfo_proc kp;
-      int kpret = ps__get_kinfo_proc(cpid, &kp);
-      int ret = kill(cpid, csig);
-
-      if (ret == -1) {
-	if (errno == ESRCH) {
-	  ps__no_such_process(cpid, 0);
-	} else if (errno == EPERM || errno == EACCES) {
-	  ps__access_denied("");
-	} else  {
-	  ps__set_error_from_errno();
-	}
-	ps__throw_error();
-      }
-
-      UNPROTECT(1);
-
-      if (kpret != -1) {
-	return ps__str_to_utf8(kp.kp_proc.p_comm);
-      } else {
-	return mkString("???");
-      }
-    }
-  }
-
-  UNPROTECT(1);
-  return R_NilValue;
-}
-
 SEXP ps__find_if_env(SEXP marker, SEXP after, SEXP pid) {
   const char *cmarker = CHAR(STRING_ELT(marker, 0));
   pid_t cpid = INTEGER(pid)[0];
@@ -1074,6 +1135,140 @@ SEXP ps__disk_partitions(SEXP all) {
   return R_NilValue;
 }
 
+SEXP ps__fs_info(SEXP path, SEXP abspath, SEXP mps) {
+  struct statfs sfs;
+  R_xlen_t i, len = Rf_xlength(path);
+
+  const char *nms[] = {
+    "path",                         // 0
+    "mountpoint",                   // 1
+    "name",                         // 2
+    "type",                         // 3
+    "block_size",                   // 4
+    "transfer_block_size",          // 5
+    "total_data_blocks",            // 6
+    "free_blocks",                  // 7
+    "free_blocks_non_superuser",    // 8
+    "total_nodes",                  // 9
+    "free_nodes",                   // 10
+    "id",                           // 11
+    "owner",                        // 12
+    "type_code",                    // 13
+    "subtype_code",                 // 14
+
+    "RDONLY",
+    "SYNCHRONOUS",
+    "NOEXEC",
+    "NOSUID",
+    "NODEV",
+    "UNION",
+    "ASYNC",
+    "EXPORTED",
+    "LOCAL",
+    "QUOTA",
+    "ROOTFS",
+    "DOVOLFS",
+    "DONTBROWSE",
+    "UNKNOWNPERMISSIONS",
+    "AUTOMOUNTED",
+    "JOURNALED",
+    "DEFWRITE",
+    "MULTILABEL",
+    "CPROTECT",
+    ""
+  };
+  SEXP res = PROTECT(Rf_mkNamed(VECSXP, nms));
+  SET_VECTOR_ELT(res, 0, path);
+  SET_VECTOR_ELT(res, 1, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 2, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 3, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 4, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 5, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 6, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 7, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 8, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 9, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 10, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 11, Rf_allocVector(VECSXP, len));
+  SET_VECTOR_ELT(res, 12, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 13, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 14, Rf_allocVector(REALSXP, len));
+
+  SET_VECTOR_ELT(res, 15, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 16, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 17, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 18, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 19, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 20, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 21, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 22, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 23, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 24, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 25, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 26, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 27, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 28, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 29, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 30, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 31, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 32, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 33, Rf_allocVector(LGLSXP, len));
+
+  for (i = 0; i < len; i++) {
+    int ret = statfs(CHAR(STRING_ELT(abspath, i)), &sfs);
+    if (ret != 0) {
+      ps__set_error(
+        "statfs %s: %d %s",
+        CHAR(STRING_ELT(abspath, i)), errno, strerror(errno)
+      );
+      ps__throw_error();
+    }
+    SET_STRING_ELT(VECTOR_ELT(res, 1), i, STRING_ELT(mps, i));
+    SET_STRING_ELT(VECTOR_ELT(res, 2), i,
+                   Rf_mkCharCE(sfs.f_mntfromname, CE_UTF8));
+    SET_STRING_ELT(VECTOR_ELT(res, 3), i,
+                   Rf_mkCharCE(sfs.f_fstypename, CE_UTF8));
+    REAL(VECTOR_ELT(res, 4))[i] = sfs.f_bsize;
+    REAL(VECTOR_ELT(res, 5))[i] = sfs.f_iosize;
+    REAL(VECTOR_ELT(res, 6))[i] = sfs.f_blocks;
+    REAL(VECTOR_ELT(res, 7))[i] = sfs.f_bfree;
+    REAL(VECTOR_ELT(res, 8))[i] = sfs.f_bavail;
+    REAL(VECTOR_ELT(res, 9))[i] = sfs.f_files;
+    REAL(VECTOR_ELT(res, 10))[i] = sfs.f_ffree;
+    SET_VECTOR_ELT(VECTOR_ELT(res, 11), i, Rf_allocVector(RAWSXP, sizeof(fsid_t)));
+    memcpy(RAW(VECTOR_ELT(VECTOR_ELT(res, 11), i)), &sfs.f_fsid, sizeof(fsid_t));
+    REAL(VECTOR_ELT(res, 12))[i] = sfs.f_owner;
+    REAL(VECTOR_ELT(res, 13))[i] = sfs.f_type;
+    REAL(VECTOR_ELT(res, 14))[i] = sfs.f_fssubtype;
+
+    LOGICAL(VECTOR_ELT(res, 15))[i] = sfs.f_flags & MNT_RDONLY;
+    LOGICAL(VECTOR_ELT(res, 16))[i] = sfs.f_flags & MNT_SYNCHRONOUS;
+    LOGICAL(VECTOR_ELT(res, 17))[i] = sfs.f_flags & MNT_NOEXEC;
+    LOGICAL(VECTOR_ELT(res, 18))[i] = sfs.f_flags & MNT_NOSUID;
+    LOGICAL(VECTOR_ELT(res, 19))[i] = sfs.f_flags & MNT_NODEV;
+    LOGICAL(VECTOR_ELT(res, 20))[i] = sfs.f_flags & MNT_UNION;
+    LOGICAL(VECTOR_ELT(res, 21))[i] = sfs.f_flags & MNT_ASYNC;
+    LOGICAL(VECTOR_ELT(res, 22))[i] = sfs.f_flags & MNT_EXPORTED;
+    LOGICAL(VECTOR_ELT(res, 23))[i] = sfs.f_flags & MNT_LOCAL;
+    LOGICAL(VECTOR_ELT(res, 24))[i] = sfs.f_flags & MNT_QUOTA;
+    LOGICAL(VECTOR_ELT(res, 25))[i] = sfs.f_flags & MNT_ROOTFS;
+    LOGICAL(VECTOR_ELT(res, 26))[i] = sfs.f_flags & MNT_DOVOLFS;
+    LOGICAL(VECTOR_ELT(res, 27))[i] = sfs.f_flags & MNT_DONTBROWSE;
+    LOGICAL(VECTOR_ELT(res, 28))[i] = sfs.f_flags & MNT_UNKNOWNPERMISSIONS;
+    LOGICAL(VECTOR_ELT(res, 29))[i] = sfs.f_flags & MNT_AUTOMOUNTED;
+    LOGICAL(VECTOR_ELT(res, 30))[i] = sfs.f_flags & MNT_JOURNALED;
+    LOGICAL(VECTOR_ELT(res, 31))[i] = sfs.f_flags & MNT_DEFWRITE;
+    LOGICAL(VECTOR_ELT(res, 32))[i] = sfs.f_flags & MNT_MULTILABEL;
+/* Since sys/mount.h includes Availability.h, we use underscore-prefixed macro */
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
+    LOGICAL(VECTOR_ELT(res, 33))[i] = sfs.f_flags & MNT_CPROTECT;
+#endif
+  }
+
+  UNPROTECT(1);
+  return res;
+}
+
 int ps__sys_vminfo(vm_statistics_data_t *vmstat) {
   kern_return_t ret;
   mach_msg_type_number_t count = sizeof(*vmstat) / sizeof(integer_t);
@@ -1205,3 +1400,172 @@ SEXP ps__system_cpu_times(void) {
   UNPROTECT(1);
   return ret;
 }
+
+// timeout = 0 special case, no need to poll, just check if running
+SEXP psll_wait0(SEXP pps) {
+  R_xlen_t i, num_handles = Rf_xlength(pps);
+  SEXP res = PROTECT(Rf_allocVector(LGLSXP, num_handles));
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+    if (!handle) Rf_error("Process pointer #%d cleaned up already", (int) i);
+    LOGICAL(res)[i] = ! LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0];
+  }
+
+  UNPROTECT(1);
+  return res;
+}
+
+struct psll__wait_cleanup_data {
+  int epfd;
+};
+
+static void psll__wait_cleanup(void *data) {
+  struct psll__wait_cleanup_data *cdata =
+    (struct psll__wait_cleanup_data*) data;
+  if (cdata->epfd != -1) {
+    close(cdata->epfd);
+    cdata->epfd = -1;
+  }
+}
+
+// Add time limit to current time.
+// clock_gettime does not fail, as long as the struct timespec
+// pointer is ok. So no need to check the return value.
+static void add_time(struct timespec *due, int ms) {
+  clock_gettime(CLOCK_MONOTONIC, due);
+  due->tv_sec = due->tv_sec + ms / 1000;
+  due->tv_nsec = due->tv_nsec + (ms % 1000) * 1000000;
+  if (due->tv_nsec >= 1000000000) {
+    due->tv_nsec -= 1000000000;
+    due->tv_sec++;
+  }
+}
+
+static inline int time_left(struct timespec *due) {
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  return
+    (due->tv_sec - now.tv_sec) * 1000 +
+    (due->tv_nsec - now.tv_nsec) / 1000 / 1000;
+}
+
+SEXP psll_wait(SEXP pps, SEXP timeout) {
+  int ctimeout = INTEGER(timeout)[0];
+  // this is much simpler, no need to poll at all
+  if (ctimeout == 0) {
+    return psll_wait0(pps);
+  }
+
+  int forever = ctimeout < 0;
+  R_xlen_t i, num_handles = Rf_xlength(pps);
+  struct psll__wait_cleanup_data cdata = { -1 };
+  r_call_on_early_exit(psll__wait_cleanup, &cdata);
+  cdata.epfd = kqueue();
+  if (cdata.epfd == -1) {
+    ps__set_error_from_errno();
+    ps__throw_error();
+  }
+
+  SEXP res = PROTECT(Rf_allocVector(LGLSXP, num_handles));
+
+  int ret;
+  R_xlen_t topoll = 0;
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+    if (!handle) Rf_error("Process pointer #%d cleaned up already", (int) i);
+    if (!LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0]) {
+      // already done
+      LOGICAL(res)[i] = 1;
+    } else {
+      struct kevent ev;
+      EV_SET(
+        &ev,
+        handle->pid,
+        EVFILT_PROC,
+        EV_ADD | EV_ONESHOT,
+        NOTE_EXIT,
+        (intptr_t) NULL,
+        LOGICAL(res) + i
+      );
+      ret = kevent(cdata.epfd, &ev, 1, NULL, 0, NULL);
+      if (ret == -1) {
+        if (errno == ESRCH) {
+          LOGICAL(res)[i] = 1;
+        } else {
+          ps__set_error_from_errno();
+          ps__throw_error();
+        }
+      } else {
+        topoll++;
+        LOGICAL(res)[i] = 0;
+      }
+    }
+  }
+
+  // early exit if nothing to do
+  if (topoll == 0) {
+    psll__wait_cleanup(&cdata);
+    UNPROTECT(1);
+    return res;
+  }
+
+  SEXP revents = PROTECT(Rf_allocVector(RAWSXP, sizeof(struct kevent) * topoll));
+  struct kevent *events = (struct kevent*) RAW(revents);
+
+  // first timeout is the smaller of PROCESSX_INTERRUPT_INTERVAL & timeout
+  struct timespec ts = { 0, 0 };
+  if (forever || ctimeout > PROCESSX_INTERRUPT_INTERVAL) {
+    ts.tv_sec = PROCESSX_INTERRUPT_INTERVAL / 1000;
+    ts.tv_nsec = (PROCESSX_INTERRUPT_INTERVAL % 1000) * 1000 * 1000;
+  } else {
+    ts.tv_sec = ctimeout / 1000;
+    ts.tv_nsec = (ctimeout % 1000) * 1000 * 1000;
+  }
+
+  // this is the ultimate time limit, unless we poll forever
+  struct timespec due;
+  if (!forever) {
+    add_time(&due, ctimeout);
+  }
+
+  do {
+    do {
+      ret = kevent(cdata.epfd, NULL, 0, events, topoll, &ts);
+    } while (ret == -1 && errno == EINTR);
+
+    if (ret == -1) {
+      ps__set_error_from_errno();
+      ps__throw_error();
+    }
+
+    for (i = 0; i < ret; i++) {
+      int *ptr = (int*) events[i].udata;
+      *ptr = 1;
+      topoll--;
+    }
+
+    // are we done?
+    if (topoll == 0) {
+      break;
+    }
+
+    // is the time limit over? Do we need to update the poll timeout
+    if (!forever) {
+      int tl = time_left(&due);
+      if (tl < 0) {
+        break;
+      }
+      if (tl < PROCESSX_INTERRUPT_INTERVAL) {
+        ts.tv_sec = tl / 1000;
+        ts.tv_nsec = (tl % 1000) * 1000 * 1000;
+      }
+    }
+
+    R_CheckUserInterrupt();
+
+  } while (1);
+
+  psll__wait_cleanup(&cdata);
+  UNPROTECT(2);
+  return res;
+}
diff --git a/src/library/ps/src/api-posix.c b/src/library/ps/src/api-posix.c
index a0e73b3f7..0440934ed 100644
--- a/src/library/ps/src/api-posix.c
+++ b/src/library/ps/src/api-posix.c
@@ -9,8 +9,18 @@
 #include <unistd.h>
 #include <sys/statvfs.h>
 #include <sys/resource.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#ifdef __linux__
+#include <sys/sysmacros.h>
+#endif
+#include <sys/param.h>
+#include <libgen.h>
+#include <stdlib.h>
 
 #include "ps-internal.h"
+#include "cleancall.h"
 
 SEXP psll_send_signal(SEXP p, SEXP sig) {
   ps_handle_t *handle = R_ExternalPtrAddr(p);
@@ -79,11 +89,86 @@ SEXP psll_terminate(SEXP p) {
 }
 
 
-SEXP psll_kill(SEXP p) {
-  SEXP res, s;
-  PROTECT(s = ScalarInteger(SIGKILL));
-  PROTECT(res = psll_send_signal(p, s));
-  UNPROTECT(2);
+SEXP psll_kill(SEXP p, SEXP grace) {
+  R_xlen_t i, num_handles = Rf_xlength(p);
+
+  // check if handles are ok, and they are not pid 0
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(p, i));
+    if (!handle) Rf_error("Process pointer clean up already");
+    if (handle->pid == 0) {
+      Rf_error(
+        "preventing sending KILL signal to process with PID 0 as it "
+	      "would affect every process in the process group of the "
+        "calling process (Sys.getpid()) instead of PID 0"
+      );
+    }
+  }
+
+  // OK, we can give it a go then
+  SEXP res = PROTECT(Rf_allocVector(VECSXP, num_handles));
+  SEXP ridx = PROTECT(Rf_allocVector(INTSXP, num_handles));
+  int *idx = INTEGER(ridx);
+  memset(idx, 0, sizeof(int) * num_handles);
+
+  // Send out TERM signals
+  int signals_sent = 0;
+  for (i = 0; i < num_handles; i++) {
+    if (!LOGICAL(psll_is_running(VECTOR_ELT(p, i)))[0]) {
+      SET_VECTOR_ELT(res, i, Rf_mkString("dead"));
+      continue;
+    }
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(p, i));
+    int ret = kill(handle->pid, SIGTERM);
+    if (ret == -1) {
+      if (errno == ESRCH) {
+        SET_VECTOR_ELT(res, i, Rf_mkString("dead"));
+        continue;
+      } else if (errno == EPERM || errno == EACCES) {
+        ps__access_denied_pid(handle->pid, "");
+      } else {
+        ps__set_error_from_errno();
+      }
+      SET_VECTOR_ELT(res, i, Rf_duplicate(ps__last_error));
+    } else {
+      idx[signals_sent++] = i;
+    }
+  }
+
+  // all done, exit early
+  if (signals_sent == 0) {
+    UNPROTECT(2);
+    return res;
+  }
+
+  SEXP p2 = PROTECT(Rf_allocVector(VECSXP, signals_sent));
+  for (i = 0; i < signals_sent; i++) {
+    SET_VECTOR_ELT(p2, i, VECTOR_ELT(p, idx[i]));
+  }
+  SEXP waitres = PROTECT(psll_wait(p2, grace));
+  for (i = 0; i < signals_sent; i++) {
+    if (LOGICAL(waitres)[i]) {
+      SET_VECTOR_ELT(res, idx[i], Rf_mkString("terminated"));
+    } else {
+      ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(p2, i));
+      int ret = kill(handle->pid, SIGKILL);
+      if (ret == -1) {
+        if (errno == ESRCH) {
+          SET_VECTOR_ELT(res, idx[i], Rf_mkString("dead"));
+          continue;
+        } else if (errno == EPERM || errno == EACCES) {
+          ps__access_denied_pid(handle->pid, "");
+        } else {
+          ps__set_error_from_errno();
+        }
+        SET_VECTOR_ELT(res, idx[i], Rf_duplicate(ps__last_error));
+      } else {
+        SET_VECTOR_ELT(res, idx[i], Rf_mkString("killed"));
+      }
+    }
+  }
+
+  UNPROTECT(4);
   return res;
 }
 
@@ -187,3 +272,209 @@ SEXP psll_set_nice(SEXP p, SEXP value) {
 
   return R_NilValue;
 }
+
+#define POSIXT(x) (((double) (x).tv_sec) + ((double) (x).tv_nsec) / 1000 / 1000 / 1000)
+
+#ifdef __APPLE__
+#define st_atim st_atimespec
+#define st_mtim st_mtimespec
+#define st_ctim st_ctimespec
+#endif
+
+SEXP ps__stat(SEXP paths, SEXP follow) {
+  const char* nms[] = {
+    "path",
+    "dev_major",
+    "dev_minor",
+    "inode",
+    "mode",
+    "type",
+    "permissions",
+    "nlink",
+    "uid",
+    "gid",
+    "rdev_major",
+    "rdev_minor",
+    "size",
+    "block_size",
+    "blocks",
+    "access_time",
+    "modification_time",
+    "change_time",
+    ""
+  };
+
+  R_xlen_t i, len = Rf_xlength(paths);
+  SEXP res = PROTECT(Rf_mkNamed(VECSXP, nms));
+  SET_VECTOR_ELT(res, 0, paths);
+  SET_VECTOR_ELT(res, 1, Rf_allocVector(INTSXP, len));
+  SET_VECTOR_ELT(res, 2, Rf_allocVector(INTSXP, len));
+  SET_VECTOR_ELT(res, 3, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 4, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 5, Rf_allocVector(INTSXP, len));
+  SET_VECTOR_ELT(res, 6, Rf_allocVector(INTSXP, len));
+  SET_VECTOR_ELT(res, 7, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 8, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 9, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 10, Rf_allocVector(INTSXP, len));
+  SET_VECTOR_ELT(res, 11, Rf_allocVector(INTSXP, len));
+  SET_VECTOR_ELT(res, 12, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 13, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 14, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 15, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 16, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 17, Rf_allocVector(REALSXP, len));
+
+  int lfollow = LOGICAL(follow)[0];
+  for (i = 0; i < len; i++) {
+    const char *cpath = CHAR(STRING_ELT(paths, i));
+    struct stat st;
+    int ret;
+
+    if (lfollow) {
+      ret = stat(cpath, &st);
+    } else {
+      ret = lstat(cpath, &st);
+    }
+
+    if (ret) {
+      ps__set_error_from_errno();
+      ps__throw_error();
+    }
+
+    INTEGER(VECTOR_ELT(res, 1))[i] = major(st.st_dev);
+    INTEGER(VECTOR_ELT(res, 2))[i] = minor(st.st_dev);
+    REAL(VECTOR_ELT(res, 3))[i] = st.st_ino;
+    REAL(VECTOR_ELT(res, 4))[i] = st.st_mode;
+    INTEGER(VECTOR_ELT(res, 5))[i] = NA_INTEGER;
+    int *ctype = INTEGER(VECTOR_ELT(res, 5)) + i;
+    switch (st.st_mode & S_IFMT) {
+    case S_IFREG: *ctype = 1; break;
+    case S_IFDIR: *ctype = 2; break;
+    case S_IFCHR: *ctype = 3; break;
+    case S_IFBLK: *ctype = 4; break;
+    case S_IFIFO: *ctype = 5; break;
+    case S_IFLNK: *ctype = 6; break;
+    case S_IFSOCK: *ctype = 7; break;
+    }
+    INTEGER(VECTOR_ELT(res, 6))[i] = st.st_mode & 07777;
+    REAL(VECTOR_ELT(res, 7))[i] = st.st_nlink;
+    REAL(VECTOR_ELT(res, 8))[i] = st.st_uid;
+    REAL(VECTOR_ELT(res, 9))[i] = st.st_gid;
+    INTEGER(VECTOR_ELT(res, 10))[i] = NA_INTEGER;
+    INTEGER(VECTOR_ELT(res, 11))[i] = NA_INTEGER;
+    if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
+      INTEGER(VECTOR_ELT(res, 10))[i] = major(st.st_rdev);
+      INTEGER(VECTOR_ELT(res, 11))[i] = minor(st.st_rdev);
+    }
+    REAL(VECTOR_ELT(res, 12))[i] = st.st_size;
+    REAL(VECTOR_ELT(res, 13))[i] = st.st_blksize;
+    REAL(VECTOR_ELT(res, 14))[i] = st.st_blocks;
+    REAL(VECTOR_ELT(res, 15))[i] = POSIXT(st.st_atim);
+    REAL(VECTOR_ELT(res, 16))[i] = POSIXT(st.st_mtim);
+    REAL(VECTOR_ELT(res, 17))[i] = POSIXT(st.st_ctim);
+  }
+
+  UNPROTECT(1);
+  return res;
+}
+
+void ps__mount_point_cleanup(void *data) {
+  char *wd = (char*) data;
+  int ret = chdir(wd);
+  if (ret) {
+    REprintf(
+      "Could not restore current working directory "
+      "in ps::ps_fs_mount_point()"
+    );
+  }
+}
+
+SEXP ps__mount_point(SEXP paths) {
+  R_xlen_t i, len = Rf_xlength(paths);
+  struct stat st, lastst;
+  int ret;
+  char wd[MAXPATHLEN + 1];
+
+  // save wd
+  if (!getcwd(wd, MAXPATHLEN)) {
+    ps__set_error_from_errno();
+    ps__throw_error();
+  }
+
+  r_call_on_early_exit(ps__mount_point_cleanup, wd);
+
+  SEXP res = PROTECT(Rf_allocVector(STRSXP, len));
+
+  for (i = 0; i < len; i++) {
+    char buf[MAXPATHLEN + 1];
+    const char *cpath = CHAR(STRING_ELT(paths, i));
+    ret = stat(cpath, &st);
+    if (ret) {
+      ps__set_error_from_errno();
+      ps__throw_error();
+    }
+
+    // go into the directory
+    if (S_ISDIR(st.st_mode)) {
+      ret = chdir(cpath);
+      if (ret) {
+        ps__set_error_from_errno();
+        ps__throw_error();
+      }
+      lastst = st;
+
+    } else {
+      char *tmp = strdup(cpath);
+      const char *dn = dirname(tmp);
+      if (!dn) {
+        free(tmp);
+        ps__set_error_from_errno();
+        ps__throw_error();
+      }
+      ret = chdir(dn);
+      free(tmp);
+      if (ret) {
+        ps__set_error_from_errno();
+        ps__throw_error();
+      }
+      ret = stat(".", &lastst);
+      if (ret) {
+        ps__set_error_from_errno();
+        ps__throw_error();
+      }
+    }
+
+    // walk up until we leave the device or arrive at /
+    while (1) {
+      ret = stat("..", &st);
+      if (ret) {
+        ps__set_error_from_errno();
+        ps__throw_error();
+      }
+      if (st.st_dev != lastst.st_dev || st.st_ino == lastst.st_ino) {
+        break;
+      }
+      ret = chdir("..");
+      if (ret) {
+        ps__set_error_from_errno();
+        ps__throw_error();
+      }
+      lastst = st;
+    }
+
+    if (!getcwd(buf, MAXPATHLEN)) {
+      ps__set_error_from_errno();
+      ps__throw_error();
+    }
+    SET_STRING_ELT(res, i, Rf_mkChar(buf));
+  }
+
+  ret = chdir(wd);
+  if (ret) {
+    ps__set_error_from_errno();
+    ps__throw_error();
+  }
+  UNPROTECT(1);
+  return res;
+}
diff --git a/src/library/ps/src/api-windows.c b/src/library/ps/src/api-windows.c
index 87c6c7559..02159d442 100644
--- a/src/library/ps/src/api-windows.c
+++ b/src/library/ps/src/api-windows.c
@@ -3,11 +3,13 @@
 #include "windows.h"
 #include "arch/windows/process_info.h"
 #include "arch/windows/process_handles.h"
+#include "cleancall.h"
 
 #include <tlhelp32.h>
 #include <string.h>
 #include <math.h>
 #include <wtsapi32.h>
+#include <time.h>
 
 static void psll_finalizer(SEXP p) {
   ps_handle_t *handle = R_ExternalPtrAddr(p);
@@ -519,7 +521,7 @@ SEXP psll_terminate(SEXP p) {
   return R_NilValue;
 }
 
-SEXP psll_kill(SEXP p) {
+SEXP psll_kill(SEXP p, SEXP grace) {
   ps_handle_t *handle = R_ExternalPtrAddr(p);
   SEXP running, ret;
 
@@ -715,62 +717,6 @@ SEXP ps__cpu_count_physical() {
   }
 }
 
-SEXP ps__kill_if_env(SEXP marker, SEXP after, SEXP pid, SEXP sig) {
-  const char *cmarker = CHAR(STRING_ELT(marker, 0));
-  double cafter = REAL(after)[0];
-  DWORD cpid = INTEGER(pid)[0];
-  SEXP env;
-  size_t i, len;
-  double ctime = 0, ctime2 = 0;
-
-  /* Filter on start time */
-  FILETIME ftCreate;
-  int ret = ps__create_time_raw(cpid, &ftCreate);
-  if (ret) ps__throw_error();
-  ctime = ps__filetime_to_unix(ftCreate);
-  if (ctime < cafter - 1) return R_NilValue;
-
-  PROTECT(env = ps__get_environ(cpid));
-  if (isNull(env)) ps__throw_error();
-
-  len = LENGTH(env);
-
-  for (i = 0; i < len; i++) {
-    if (strstr(CHAR(STRING_ELT(env, i)), cmarker)) {
-      HANDLE hProcess = ps__handle_from_pid(cpid);
-      FILETIME ftCreate;
-      SEXP name, ret2;
-      int ret = ps__create_time_raw(cpid, &ftCreate);
-      if (ret) {
-	CloseHandle(hProcess);
-	ps__throw_error();
-      }
-
-      ctime2 = ps__filetime_to_unix(ftCreate);
-      if (fabs(ctime - ctime2) < 0.01)  {
-	PROTECT(name = ps__name(cpid));
-	ret2 = ps__proc_kill(cpid);
-	CloseHandle(hProcess);
-	if (isNull(ret2)) ps__throw_error();
-	if (isNull(name)) {
-	  UNPROTECT(2);
-	  return mkString("???");
-	} else {
-	  UNPROTECT(2);
-	  return name;
-	}
-      } else  {
-	CloseHandle(hProcess);
-	UNPROTECT(1);
-	return R_NilValue;
-      }
-    }
-  }
-
-  UNPROTECT(1);
-  return R_NilValue;
-}
-
 SEXP ps__find_if_env(SEXP marker, SEXP after, SEXP pid) {
   const char *cmarker = CHAR(STRING_ELT(marker, 0));
   double cafter = REAL(after)[0];
@@ -1408,6 +1354,225 @@ SEXP ps__disk_usage(SEXP paths) {
   return R_NilValue;
 }
 
+#ifndef FILE_RETURNS_CLEANUP_RESULT_INFO
+#define FILE_RETURNS_CLEANUP_RESULT_INFO 0x00000200
+#endif
+#ifndef FILE_SUPPORTS_POSIX_UNLINK_RENAME
+#define FILE_SUPPORTS_POSIX_UNLINK_RENAME 0x00000400
+#endif
+#ifndef FILE_SUPPORTS_BLOCK_REFCOUNTING
+#define FILE_SUPPORTS_BLOCK_REFCOUNTING 0x08000000
+#endif
+#ifndef FILE_SUPPORTS_SPARSE_VDL
+#define FILE_SUPPORTS_SPARSE_VDL 0x10000000
+#endif
+#ifndef FILE_DAX_VOLUME
+#define FILE_DAX_VOLUME 0x20000000
+#endif
+#ifndef FILE_SUPPORTS_GHOSTING
+#define FILE_SUPPORTS_GHOSTING 0x40000000
+#endif
+
+SEXP ps__fs_info(SEXP path, SEXP abspath, SEXP mps) {
+  R_xlen_t i, len = Rf_xlength(path);
+
+  const char *nms[] = {
+    "path",                           // 0
+    "mountpoint",                    // 1
+    "name",                           // 2
+    "type",                           // 3
+    "block_size",                     // 4
+    "transfer_block_size",            // 5
+    "total_data_blocks",              // 6
+    "free_blocks",                    // 7
+    "free_blocks_non_superuser",      // 8
+    "total_nodes",                    // 9
+    "free_nodes",                     // 10
+    "id",                             // 11
+    "owner",                          // 12
+    "type_code",                      // 13
+    "subtype_code",                   // 14
+
+    "CASE_SENSITIVE_SEARCH",
+    "CASE_PRESERVED_NAMES",
+    "UNICODE_ON_DISK",
+    "PERSISTENT_ACLS",
+    "FILE_COMPRESSION",
+    "VOLUME_QUOTAS",
+    "SUPPORTS_SPARSE_FILES",
+    "SUPPORTS_REPARSE_POINTS",
+    "SUPPORTS_REMOTE_STORAGE",
+    "RETURNS_CLEANUP_RESULT_INFO",
+    "SUPPORTS_POSIX_UNLINK_RENAME",
+    "VOLUME_IS_COMPRESSED",
+    "SUPPORTS_OBJECT_IDS",
+    "SUPPORTS_ENCRYPTION",
+    "NAMED_STREAMS",
+    "READ_ONLY_VOLUME",
+    "SEQUENTIAL_WRITE_ONCE",
+    "SUPPORTS_TRANSACTIONS",
+    "SUPPORTS_HARD_LINKS",
+    "SUPPORTS_EXTENDED_ATTRIBUTES",
+    "SUPPORTS_OPEN_BY_FILE_ID",
+    "SUPPORTS_USN_JOURNAL",
+    "SUPPORTS_INTEGRITY_STREAMS",
+    "SUPPORTS_BLOCK_REFCOUNTING",
+    "SUPPORTS_SPARSE_VDL",
+    "DAX_VOLUME",
+    "SUPPORTS_GHOSTING",
+    ""
+  };
+  SEXP res = PROTECT(Rf_mkNamed(VECSXP, nms));
+
+  SET_VECTOR_ELT(res, 0, path);
+  SET_VECTOR_ELT(res, 1, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 2, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 3, Rf_allocVector(STRSXP, len));
+  SET_VECTOR_ELT(res, 4, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 5, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 6, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 7, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 8, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 9, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 10, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 11, Rf_allocVector(VECSXP, len));
+  SET_VECTOR_ELT(res, 12, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 13, Rf_allocVector(REALSXP, len));
+  SET_VECTOR_ELT(res, 14, Rf_allocVector(REALSXP, len));
+
+  SET_VECTOR_ELT(res, 15, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 16, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 17, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 18, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 19, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 20, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 21, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 22, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 23, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 24, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 25, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 26, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 27, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 28, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 29, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 30, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 31, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 32, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 33, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 34, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 35, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 36, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 37, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 38, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 39, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 40, Rf_allocVector(LGLSXP, len));
+  SET_VECTOR_ELT(res, 41, Rf_allocVector(LGLSXP, len));
+
+  for (i = 0; i < len; i++) {
+    const char *cpath = CHAR(STRING_ELT(abspath, i));
+    wchar_t *wpath;
+    int iret = ps__utf8_to_utf16(cpath, &wpath);
+    if (iret) {
+      ps__throw_error();
+    }
+
+    // we already have the mount point, convert to UTF-16
+    wchar_t *wmp;
+    iret = ps__utf8_to_utf16(CHAR(STRING_ELT(mps, i)), &wmp);
+    if (iret) {
+      ps__throw_error();
+    }
+    SET_STRING_ELT(VECTOR_ELT(res, 1), i, STRING_ELT(mps, i));
+
+    // name of the volume
+    wchar_t volname[1024];
+    BOOL ok = GetVolumeNameForVolumeMountPointW(
+      wmp,
+      volname,
+      sizeof(volname)/sizeof(wchar_t) - 1
+    );
+    if (!ok) {
+      ps__set_error_from_windows_error(0);
+      ps__throw_error();
+    }
+    SET_STRING_ELT(
+      VECTOR_ELT(res, 2), i,
+      ps__utf16_to_charsxp(volname, -1)
+    );
+
+    DWORD sn, mcl, flags;
+    wchar_t type[MAX_PATH + 1];
+    ok = GetVolumeInformationW(
+      wmp, NULL, 0, &sn, &mcl, &flags, type,
+      sizeof(type)/sizeof(wchar_t) - 1);
+    if (!ok) {
+      ps__set_error_from_windows_error(0);
+      ps__throw_error();
+    }
+    // type
+    SET_STRING_ELT(
+      VECTOR_ELT(res, 3), i,
+      ps__utf16_to_charsxp(type, -1)
+    );
+
+    DWORD spc, bps, freec, totalc;
+    ok = GetDiskFreeSpaceW(wmp, &spc, &bps, &freec, &totalc);
+    if (!ok) {
+      ps__set_error_from_windows_error(0);
+      ps__throw_error();
+    }
+    REAL(VECTOR_ELT(res, 4))[i] = bps;
+    REAL(VECTOR_ELT(res, 5))[i] = bps * spc;
+
+    ULARGE_INTEGER freeuser, total, freeroot;
+    ok = GetDiskFreeSpaceExW(wmp, &freeuser, &total, &freeroot);
+    if (!ok) {
+      ps__set_error_from_windows_error(0);
+      ps__throw_error();
+    }
+    REAL(VECTOR_ELT(res, 6))[i] = total.QuadPart / bps;
+    REAL(VECTOR_ELT(res, 7))[i] = freeroot.QuadPart / bps;
+    REAL(VECTOR_ELT(res, 8))[i] = freeuser.QuadPart / bps;
+    REAL(VECTOR_ELT(res, 9))[i] = NA_REAL;
+    REAL(VECTOR_ELT(res, 10))[i] = NA_REAL;
+    SET_VECTOR_ELT(VECTOR_ELT(res, 11), i, R_NilValue);
+    REAL(VECTOR_ELT(res, 12))[i] = NA_REAL;
+    REAL(VECTOR_ELT(res, 13))[i] = NA_REAL;
+    REAL(VECTOR_ELT(res, 14))[i] = NA_REAL;
+
+    LOGICAL(VECTOR_ELT(res, 15))[i] = flags & FILE_CASE_SENSITIVE_SEARCH;
+    LOGICAL(VECTOR_ELT(res, 16))[i] = flags & FILE_CASE_PRESERVED_NAMES;
+    LOGICAL(VECTOR_ELT(res, 17))[i] = flags & FILE_UNICODE_ON_DISK;
+    LOGICAL(VECTOR_ELT(res, 18))[i] = flags & FILE_PERSISTENT_ACLS;
+    LOGICAL(VECTOR_ELT(res, 19))[i] = flags & FILE_FILE_COMPRESSION;
+    LOGICAL(VECTOR_ELT(res, 20))[i] = flags & FILE_VOLUME_QUOTAS;
+    LOGICAL(VECTOR_ELT(res, 21))[i] = flags & FILE_SUPPORTS_SPARSE_FILES;
+    LOGICAL(VECTOR_ELT(res, 22))[i] = flags & FILE_SUPPORTS_REPARSE_POINTS;
+    LOGICAL(VECTOR_ELT(res, 23))[i] = flags & FILE_SUPPORTS_REMOTE_STORAGE;
+    LOGICAL(VECTOR_ELT(res, 24))[i] = flags & FILE_RETURNS_CLEANUP_RESULT_INFO;
+    LOGICAL(VECTOR_ELT(res, 25))[i] = flags & FILE_SUPPORTS_POSIX_UNLINK_RENAME;
+    LOGICAL(VECTOR_ELT(res, 26))[i] = flags & FILE_VOLUME_IS_COMPRESSED;
+    LOGICAL(VECTOR_ELT(res, 27))[i] = flags & FILE_SUPPORTS_OBJECT_IDS;
+    LOGICAL(VECTOR_ELT(res, 28))[i] = flags & FILE_SUPPORTS_ENCRYPTION;
+    LOGICAL(VECTOR_ELT(res, 29))[i] = flags & FILE_NAMED_STREAMS;
+    LOGICAL(VECTOR_ELT(res, 30))[i] = flags & FILE_READ_ONLY_VOLUME;
+    LOGICAL(VECTOR_ELT(res, 31))[i] = flags & FILE_SEQUENTIAL_WRITE_ONCE;
+    LOGICAL(VECTOR_ELT(res, 32))[i] = flags & FILE_SUPPORTS_TRANSACTIONS;
+    LOGICAL(VECTOR_ELT(res, 33))[i] = flags & FILE_SUPPORTS_HARD_LINKS;
+    LOGICAL(VECTOR_ELT(res, 34))[i] = flags & FILE_SUPPORTS_EXTENDED_ATTRIBUTES;
+    LOGICAL(VECTOR_ELT(res, 35))[i] = flags & FILE_SUPPORTS_OPEN_BY_FILE_ID;
+    LOGICAL(VECTOR_ELT(res, 36))[i] = flags & FILE_SUPPORTS_USN_JOURNAL;
+    LOGICAL(VECTOR_ELT(res, 37))[i] = flags & FILE_SUPPORTS_INTEGRITY_STREAMS;
+    LOGICAL(VECTOR_ELT(res, 38))[i] = flags & FILE_SUPPORTS_BLOCK_REFCOUNTING;
+    LOGICAL(VECTOR_ELT(res, 39))[i] = flags & FILE_SUPPORTS_SPARSE_VDL;
+    LOGICAL(VECTOR_ELT(res, 40))[i] = flags & FILE_DAX_VOLUME;
+    LOGICAL(VECTOR_ELT(res, 41))[i] = flags & FILE_SUPPORTS_GHOSTING;
+  }
+
+  UNPROTECT(1);
+  return res;
+}
+
 SEXP ps__system_memory() {
   MEMORYSTATUSEX memInfo;
   memInfo.dwLength = sizeof(MEMORYSTATUSEX);
@@ -1433,6 +1598,116 @@ SEXP ps__system_swap() {
   return R_NilValue;
 }
 
+SEXP ps__disk_io_counters() {
+    // Based on the implementation from psutil
+    DISK_PERFORMANCE diskPerformance;
+    DWORD dwSize;
+    HANDLE hDevice = NULL;
+    char szDevice[MAX_PATH];
+    char szDeviceDisplay[MAX_PATH];
+    int devNum;
+    int i;
+    DWORD ioctrlSize;
+    BOOL ret;
+
+    SEXP result = PROTECT(allocVector(VECSXP, 7));
+    SEXP device = PROTECT(allocVector(STRSXP, 32));
+    SEXP read_count = PROTECT(allocVector(REALSXP, 32));
+    SEXP read_bytes = PROTECT(allocVector(REALSXP, 32));
+    SEXP read_time = PROTECT(allocVector(REALSXP, 32));
+    SEXP write_count = PROTECT(allocVector(REALSXP, 32));
+    SEXP write_bytes = PROTECT(allocVector(REALSXP, 32));
+    SEXP write_time = PROTECT(allocVector(REALSXP, 32));
+
+    // Apparently there's no way to figure out how many times we have
+    // to iterate in order to find valid drives.
+    // Let's assume 32, which is higher than 26, the number of letters
+    // in the alphabet (from A:\ to Z:\).
+    for (devNum = 0; devNum <= 32; ++devNum) {
+        sprintf_s(szDevice, MAX_PATH, "\\\\.\\PhysicalDrive%d", devNum);
+        hDevice = CreateFile(szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
+                             NULL, OPEN_EXISTING, 0, NULL);
+        if (hDevice == INVALID_HANDLE_VALUE)
+            continue;
+
+        // DeviceIoControl() sucks!
+        i = 0;
+        ioctrlSize = sizeof(diskPerformance);
+        while (1) {
+            i += 1;
+            ret = DeviceIoControl(
+                hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0, &diskPerformance,
+                ioctrlSize, &dwSize, NULL);
+            if (ret != 0)
+                break;  // OK!
+            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+                // Retry with a bigger buffer (+ limit for retries).
+                if (i <= 1024) {
+                    ioctrlSize *= 2;
+                    continue;
+                }
+            }
+            else if (GetLastError() == ERROR_INVALID_FUNCTION) {
+                // This happens on AppVeyor:
+                // https://ci.appveyor.com/project/giampaolo/psutil/build/
+                //      1364/job/ascpdi271b06jle3
+                // Assume it means we're dealing with some exotic disk
+                // and go on.
+                ps__debug("DeviceIoControl -> ERROR_INVALID_FUNCTION; "
+                             "ignore PhysicalDrive%i", devNum);
+                goto next;
+            }
+            else if (GetLastError() == ERROR_NOT_SUPPORTED) {
+                // Again, let's assume we're dealing with some exotic disk.
+                ps__debug("DeviceIoControl -> ERROR_NOT_SUPPORTED; "
+                             "ignore PhysicalDrive%i", devNum);
+                goto next;
+            }
+            // XXX: it seems we should also catch ERROR_INVALID_PARAMETER:
+            // https://sites.ualberta.ca/dept/aict/uts/software/openbsd/
+            //     ports/4.1/i386/openafs/w-openafs-1.4.14-transarc/
+            //     openafs-1.4.14/src/usd/usd_nt.c
+
+            // XXX: we can also bump into ERROR_MORE_DATA in which case
+            // (quoting doc) we're supposed to retry with a bigger buffer
+            // and specify  a new "starting point", whatever it means.
+            ps__set_error_from_windows_error(0);
+            goto error;
+        }
+
+        sprintf_s(szDeviceDisplay, MAX_PATH, "PhysicalDrive%i", devNum);
+        SET_STRING_ELT(device, devNum, mkChar(szDeviceDisplay));
+        REAL(read_count)[devNum] = diskPerformance.ReadCount;
+        REAL(read_bytes)[devNum] =  diskPerformance.BytesRead.QuadPart;
+        REAL(read_time)[devNum] = (unsigned long long) (diskPerformance.ReadTime.QuadPart) / 10000000;
+        REAL(write_count)[devNum] = diskPerformance.WriteCount;
+        REAL(write_bytes)[devNum] = diskPerformance.BytesWritten.QuadPart;
+        REAL(write_time)[devNum] = (unsigned long long) (diskPerformance.WriteTime.QuadPart) / 10000000;
+
+next:
+        CloseHandle(hDevice);
+    }
+
+    SET_VECTOR_ELT(result, 0, device);
+    SET_VECTOR_ELT(result, 1, read_count);
+    SET_VECTOR_ELT(result, 2, read_bytes);
+    SET_VECTOR_ELT(result, 3, read_time);
+    SET_VECTOR_ELT(result, 4, write_count);
+    SET_VECTOR_ELT(result, 5, write_bytes);
+    SET_VECTOR_ELT(result, 6, write_time);
+
+    UNPROTECT(8);
+
+    return result;
+
+error:
+    if (hDevice != NULL)
+        CloseHandle(hDevice);
+    ps__throw_error();
+    return R_NilValue;
+}
+
+
 SEXP psll_get_nice(SEXP p) {
   ps_handle_t *handle = R_ExternalPtrAddr(p);
   HANDLE hProcess = NULL;
@@ -1645,3 +1920,217 @@ SEXP ps__system_cpu_times() {
   UNPROTECT(1);
   return ret;
 }
+
+// timeout = 0 special case, no need to poll, just check if running
+SEXP psll_wait0(SEXP pps) {
+  R_xlen_t i, num_handles = Rf_xlength(pps);
+  SEXP res = PROTECT(Rf_allocVector(LGLSXP, num_handles));
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+    if (!handle) Rf_error("Process pointer #%d cleaned up already", (int) i);
+    LOGICAL(res)[i] = ! LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0];
+  }
+
+  UNPROTECT(1);
+  return res;
+}
+
+struct psll__wait_cleanup_data {
+  R_xlen_t num_handles;
+  HANDLE *pfds;
+};
+
+static void psll__wait_cleanup(void *data) {
+  struct psll__wait_cleanup_data *cdata =
+    (struct psll__wait_cleanup_data*) data;
+  R_xlen_t i;
+  if (cdata->pfds) {
+    for (i = 0; i < cdata->num_handles; i++) {
+      if (cdata->pfds[i] != INVALID_HANDLE_VALUE) {
+	CloseHandle(cdata->pfds[i]);
+      }
+    }
+  }
+}
+
+// Add time limit to current time.
+// clock_gettime does not fail, as long as the struct timespec
+// pointer is ok. So no need to check the return value.
+static void add_time(struct timespec *due, int ms) {
+  clock_gettime(CLOCK_MONOTONIC, due);
+  due->tv_sec = due->tv_sec + ms / 1000;
+  due->tv_nsec = due->tv_nsec + (ms % 1000) * 1000000;
+  if (due->tv_nsec >= 1000000000) {
+    due->tv_nsec -= 1000000000;
+    due->tv_sec++;
+  }
+}
+
+static inline int time_left(struct timespec *due) {
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  return
+    (due->tv_sec - now.tv_sec) * 1000 +
+    (due->tv_nsec - now.tv_nsec) / 1000 / 1000;
+}
+
+SEXP psll_wait(SEXP pps, SEXP timeout) {
+  int ctimeout = INTEGER(timeout)[0];
+  // this is much simpler, no need to poll at all
+  if (ctimeout == 0) {
+    return psll_wait0(pps);
+  }
+
+  int forever = ctimeout < 0;
+  R_xlen_t i, num_handles = Rf_xlength(pps);
+
+  struct psll__wait_cleanup_data cdata = {
+    /* num_handles= */ num_handles,
+    /* pfds= */        NULL
+  };
+  r_call_on_early_exit(psll__wait_cleanup, &cdata);
+
+  SEXP res = PROTECT(Rf_allocVector(LGLSXP, num_handles));
+  SEXP rhandles = PROTECT(Rf_allocVector(RAWSXP, sizeof(HANDLE) * num_handles));
+  cdata.pfds = (HANDLE*) RAW(rhandles);
+
+  R_xlen_t topoll = 0;
+  for (i = 0; i < num_handles; i++) {
+    ps_handle_t *handle = R_ExternalPtrAddr(VECTOR_ELT(pps, i));
+    if (!handle) Rf_error("Process pointer #%d cleaned up already", (int) i);
+    if (!LOGICAL(psll_is_running(VECTOR_ELT(pps, i)))[0]) {
+      // already done
+      LOGICAL(res)[i] = 1;
+      cdata.pfds[i] = INVALID_HANDLE_VALUE;
+    } else {
+      cdata.pfds[i] = OpenProcess(SYNCHRONIZE, FALSE, handle->pid);
+      if (cdata.pfds[i] == NULL) {
+	if (GetLastError() == 87) {
+	  LOGICAL(res)[i] = 1;
+	  cdata.pfds[i] = INVALID_HANDLE_VALUE;
+	} else {
+	  ps__set_error_from_windows_error(0);
+	  ps__throw_error();
+	}
+      } else {
+	cdata.pfds[topoll] = cdata.pfds[i];
+	topoll++;
+	LOGICAL(res)[i] = 0;
+      }
+    }
+  }
+
+  // early exit if nothing to do
+  if (topoll == 0) {
+    psll__wait_cleanup(&cdata);
+    UNPROTECT(2);
+    return res;
+  }
+
+  // first timeout is the smaller of PROCESSX_INTERRUPT_INTERVAL & timeout
+  int ts;
+  if (forever || ctimeout > PROCESSX_INTERRUPT_INTERVAL) {
+    ts = PROCESSX_INTERRUPT_INTERVAL;
+  } else {
+    ts = ctimeout;
+  }
+
+  // this is the ultimate time limit, unless we poll forever
+  struct timespec due;
+  if (!forever) {
+    add_time(&due, ctimeout);
+  }
+
+  // WaitForMultipleObjects can wait on at most 64 processes. If we have
+  // more than that, we poll the first 64, and then if all of them are
+  // done within the timeout, we poll the next 64, etc.
+  int first = 0;
+  topoll = num_handles;
+  DWORD ret;
+  do {
+    topoll = topoll > 64 ? 64 : topoll;
+    ret = WaitForMultipleObjects(topoll, cdata.pfds + first, TRUE, ts);
+    if (ret == WAIT_FAILED) {
+      ps__set_error_from_windows_error(0);
+      ps__throw_error();
+    }
+
+    // all of them (or 64) are done
+    if (ret != WAIT_TIMEOUT) {
+      for (i = first; i < first + topoll; i++) {
+	LOGICAL(res)[i] = 1;
+      }
+      first += topoll;
+      topoll = num_handles - first;
+      if (topoll == 0) break;
+    }
+
+    // is the time limit over? Do we need to update the poll timeout
+    if (!forever) {
+      int tl = time_left(&due);
+      if (tl < 0) {
+        break;
+      }
+      if (tl < PROCESSX_INTERRUPT_INTERVAL) {
+        ts = tl;
+      }
+    }
+
+    R_CheckUserInterrupt();
+
+  } while (1);
+
+  // we don't know which finished, need to check
+  if (topoll > 0) {
+    for (i = 0; i < num_handles; i++) {
+      if (cdata.pfds[i] != INVALID_HANDLE_VALUE) {
+	ret = WaitForSingleObject(cdata.pfds[i], 0);
+	if (ret == WAIT_FAILED) {
+	  ps__set_error_from_windows_error(0);
+	  ps__throw_error();
+	}
+	if (ret == WAIT_OBJECT_0) {
+	  LOGICAL(res)[i] = 1;
+	}
+      }
+    }
+  }
+
+  psll__wait_cleanup(&cdata);
+  UNPROTECT(2);
+  return res;
+}
+
+SEXP ps__stat(SEXP paths, SEXP follow) {
+  Rf_error("ps__stat is not implemented on Windows");
+}
+
+SEXP ps__mount_point(SEXP paths) {
+  R_xlen_t i, len = Rf_xlength(paths);
+  SEXP res = PROTECT(Rf_allocVector(STRSXP, len));
+
+  for (i = 0; i < len; i++) {
+    const char *cpath = CHAR(STRING_ELT(paths, i));
+    wchar_t *wpath;
+    int iret = ps__utf8_to_utf16(cpath, &wpath);
+    if (iret) {
+      ps__throw_error();
+    }
+
+    // look up mount point
+    wchar_t volume[MAX_PATH + 1];
+    BOOL ok = GetVolumePathNameW(
+      wpath,
+      volume,
+      sizeof(volume)/sizeof(wchar_t) - 1
+    );
+    if (!ok) {
+      ps__set_error_from_windows_error(0);
+      ps__throw_error();
+    }
+    SET_STRING_ELT(res, i, ps__utf16_to_charsxp(volume, -1));
+  }
+
+  UNPROTECT(1);
+  return res;
+}
diff --git a/src/library/ps/src/arch/macos/apps.m b/src/library/ps/src/arch/macos/apps.m
new file mode 100644
index 000000000..e776dc5e3
--- /dev/null
+++ b/src/library/ps/src/arch/macos/apps.m
@@ -0,0 +1,71 @@
+#include <CoreFoundation/CoreFoundation.h>
+#import <AppKit/AppKit.h>
+
+#include <R.h>
+#include <Rinternals.h>
+
+SEXP ps__list_apps(void) {
+  // need to run the event loop a bit, to process updates for the
+  // currently running applications
+  CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true);
+  NSWorkspace *ws = [NSWorkspace sharedWorkspace];
+  NSArray *apps = [ws runningApplications];
+
+  const char *nms[] = {
+    "name",
+    "bundle_identifier",
+    "bundle_url",
+    "arch",
+    "executable_url",
+    "launch_date",
+    "finished_launching",
+    "pid",
+    "active",
+    "activation_policy",
+    ""
+  };
+  SEXP res = PROTECT(Rf_mkNamed(VECSXP, nms));
+  NSUInteger count = [apps count];
+  SET_VECTOR_ELT(res, 0, Rf_allocVector(STRSXP, count));
+  SET_VECTOR_ELT(res, 1, Rf_allocVector(STRSXP, count));
+  SET_VECTOR_ELT(res, 2, Rf_allocVector(STRSXP, count));
+  SET_VECTOR_ELT(res, 3, Rf_allocVector(INTSXP, count));
+  SET_VECTOR_ELT(res, 4, Rf_allocVector(STRSXP, count));
+  SET_VECTOR_ELT(res, 5, Rf_allocVector(STRSXP, count));
+  SET_VECTOR_ELT(res, 6, Rf_allocVector(LGLSXP, count));
+  SET_VECTOR_ELT(res, 7, Rf_allocVector(INTSXP, count));
+  SET_VECTOR_ELT(res, 8, Rf_allocVector(LGLSXP, count));
+  SET_VECTOR_ELT(res, 9, Rf_allocVector(STRSXP, count));
+
+  for (NSUInteger i = 0; i < count; i++) {
+    NSRunningApplication *app = [apps objectAtIndex:i];
+
+    const char *name = [app.localizedName UTF8String];
+    SET_STRING_ELT(VECTOR_ELT(res, 0), i, name ? Rf_mkCharCE(name, CE_UTF8) : NA_STRING);
+    const char *bid = [app.bundleIdentifier UTF8String];
+    SET_STRING_ELT(VECTOR_ELT(res, 1), i, bid ? Rf_mkCharCE(bid, CE_UTF8) : NA_STRING);
+    const char *burl = app.bundleURL ? [app.bundleURL.absoluteString UTF8String] : 0;
+    SET_STRING_ELT(VECTOR_ELT(res, 2), i, burl ? Rf_mkCharCE(burl, CE_UTF8) : NA_STRING);
+    INTEGER(VECTOR_ELT(res, 3))[i] = app.executableArchitecture;
+    const char *eurl = app.executableURL ? [app.executableURL.absoluteString UTF8String] : 0;
+    SET_STRING_ELT(VECTOR_ELT(res, 4), i, eurl ? Rf_mkCharCE(eurl, CE_UTF8) : NA_STRING);
+    const char *ld = app.launchDate ? [app.launchDate.description UTF8String] : 0;
+    SET_STRING_ELT(VECTOR_ELT(res, 5), i, ld ? Rf_mkCharCE(ld, CE_UTF8) : NA_STRING);
+    LOGICAL(VECTOR_ELT(res, 6))[i] = app.finishedLaunching;
+    INTEGER(VECTOR_ELT(res, 7))[i] = app.processIdentifier;
+    LOGICAL(VECTOR_ELT(res, 8))[i] = app.active;
+
+    if (app.activationPolicy == NSApplicationActivationPolicyRegular) {
+      SET_STRING_ELT(VECTOR_ELT(res, 9), i, Rf_mkChar("regular"));
+    } else if (app.activationPolicy == NSApplicationActivationPolicyAccessory) {
+      SET_STRING_ELT(VECTOR_ELT(res, 9), i, Rf_mkChar("accessory"));
+    } else if (app.activationPolicy == NSApplicationActivationPolicyProhibited) {
+      SET_STRING_ELT(VECTOR_ELT(res, 9), i, Rf_mkChar("prohibited"));
+    } else {
+      SET_STRING_ELT(VECTOR_ELT(res, 9), i, NA_STRING);
+    }
+  }
+
+  UNPROTECT(1);
+  return res;
+}
diff --git a/src/library/ps/src/arch/macos/disk.c b/src/library/ps/src/arch/macos/disk.c
new file mode 100644
index 000000000..d9a446529
--- /dev/null
+++ b/src/library/ps/src/arch/macos/disk.c
@@ -0,0 +1,163 @@
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/storage/IOBlockStorageDriver.h>
+#include <IOKit/storage/IOMedia.h>
+#include <IOKit/IOBSD.h>
+
+#include <R.h>
+#include <Rinternals.h>
+#include <Rdefines.h>
+
+#include "../../ps-internal.h"
+
+SEXP ps__disk_io_counters(void) {
+  CFDictionaryRef parent_dict;
+  CFDictionaryRef props_dict;
+  CFDictionaryRef stats_dict;
+  io_registry_entry_t parent;
+  io_registry_entry_t disk;
+  io_iterator_t disk_list;
+
+  SEXP res = PROTECT(Rf_allocVector(VECSXP, 20));
+  SEXP nms = PROTECT(Rf_allocVector(STRSXP, 20));
+  int idx = 0;
+
+  // Get list of disks
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  if (IOServiceGetMatchingServices(kIOMasterPortDefault,
+                                   IOServiceMatching(kIOMediaClass),
+                                   &disk_list) != kIOReturnSuccess) {
+    ps__set_error("IOKIT unable to get the list of disks");
+    goto error;
+  }
+# pragma GCC diagnostic pop
+
+// Iterate over disks
+  while ((disk = IOIteratorNext(disk_list)) != 0) {
+    if (IORegistryEntryGetParentEntry(disk, kIOServicePlane, &parent)
+        != kIOReturnSuccess) {
+      ps__set_error("IOKIT: unable to get the disk's parent.");
+      IOObjectRelease(disk);
+      goto error;
+    }
+
+    if (IOObjectConformsTo(parent, "IOBlockStorageDriver")) {
+      if (IORegistryEntryCreateCFProperties(
+            disk,
+            (CFMutableDictionaryRef *) &parent_dict,
+            kCFAllocatorDefault,
+            kNilOptions
+          ) != kIOReturnSuccess) {
+        ps__set_error("IOKIT: unable to get the parent's properties.");
+        IOObjectRelease(disk);
+        IOObjectRelease(parent);
+        goto error;
+      }
+
+      if (IORegistryEntryCreateCFProperties(
+            parent,
+            (CFMutableDictionaryRef *) &props_dict,
+            kCFAllocatorDefault,
+            kNilOptions
+          ) != kIOReturnSuccess) {
+        ps__set_error("IOKIT: unable to get the disk properties.");
+        CFRelease(props_dict);
+        IOObjectRelease(disk);
+        IOObjectRelease(parent);
+        goto error;
+      }
+
+      const int kMaxDiskNameSize = 64;
+      CFStringRef disk_name_ref = (CFStringRef)CFDictionaryGetValue(
+        parent_dict, CFSTR(kIOBSDNameKey)
+      );
+      char disk_name[kMaxDiskNameSize];
+
+      CFStringGetCString(
+        disk_name_ref,
+        disk_name,
+        kMaxDiskNameSize,
+        CFStringGetSystemEncoding()
+      );
+
+      stats_dict = (CFDictionaryRef)CFDictionaryGetValue(
+        props_dict,
+        CFSTR(kIOBlockStorageDriverStatisticsKey)
+      );
+
+      if (stats_dict == NULL) {
+        ps__set_error("IOKIT: unable to get disk stats.");
+        goto error;
+      }
+
+      CFNumberRef number;
+      int64_t reads = 0;
+      int64_t writes = 0;
+      int64_t read_bytes = 0;
+      int64_t write_bytes = 0;
+      int64_t read_time = 0;
+      int64_t write_time = 0;
+
+      // Get disk reads/writes
+      if ((number = (CFNumberRef)CFDictionaryGetValue(
+           stats_dict,
+           CFSTR(kIOBlockStorageDriverStatisticsReadsKey)))) {
+        CFNumberGetValue(number, kCFNumberSInt64Type, &reads);
+      }
+      if ((number = (CFNumberRef)CFDictionaryGetValue(
+           stats_dict,
+           CFSTR(kIOBlockStorageDriverStatisticsWritesKey)))) {
+        CFNumberGetValue(number, kCFNumberSInt64Type, &writes);
+      }
+
+      // Get disk bytes read/written
+      if ((number = (CFNumberRef)CFDictionaryGetValue(
+           stats_dict,
+           CFSTR(kIOBlockStorageDriverStatisticsBytesReadKey)))) {
+        CFNumberGetValue(number, kCFNumberSInt64Type, &read_bytes);
+      }
+      if ((number = (CFNumberRef)CFDictionaryGetValue(
+           stats_dict,
+           CFSTR(kIOBlockStorageDriverStatisticsBytesWrittenKey)))) {
+        CFNumberGetValue(number, kCFNumberSInt64Type, &write_bytes);
+      }
+
+      // Get disk time spent reading/writing (nanoseconds)
+      if ((number = (CFNumberRef)CFDictionaryGetValue(
+           stats_dict,
+           CFSTR(kIOBlockStorageDriverStatisticsTotalReadTimeKey)))) {
+        CFNumberGetValue(number, kCFNumberSInt64Type, &read_time);
+      }
+      if ((number = (CFNumberRef)CFDictionaryGetValue(
+           stats_dict,
+           CFSTR(kIOBlockStorageDriverStatisticsTotalWriteTimeKey)))) {
+        CFNumberGetValue(number, kCFNumberSInt64Type, &write_time);
+      }
+
+      SEXP di = ps__build_list(
+        "KKKKKK", reads, writes, read_bytes, write_bytes,
+        read_time / 1000 / 1000, write_time / 1000 / 1000
+      );
+      SET_VECTOR_ELT(res, idx, di);
+      SET_STRING_ELT(nms, idx, Rf_mkCharCE(disk_name, CE_UTF8));
+      idx++;
+
+      CFRelease(parent_dict);
+      IOObjectRelease(parent);
+      CFRelease(props_dict);
+      IOObjectRelease(disk);
+    }
+  }
+
+  IOObjectRelease (disk_list);
+
+  SET_NAMES(res, nms);
+
+  UNPROTECT(2);
+  return res;
+
+error:
+  ps__throw_error();
+  return R_NilValue;
+}
diff --git a/src/library/ps/src/cleancall.c b/src/library/ps/src/cleancall.c
new file mode 100644
index 000000000..8dad21a93
--- /dev/null
+++ b/src/library/ps/src/cleancall.c
@@ -0,0 +1,165 @@
+#define R_NO_REMAP
+#include <Rinternals.h>
+
+#include "cleancall.h"
+
+
+#if (defined(R_VERSION) && R_VERSION < R_Version(3, 4, 0))
+ SEXP R_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot) {
+   fn_ptr ptr;
+   ptr.fn = p;
+   return R_MakeExternalPtr(ptr.p, tag, prot);
+ }
+ DL_FUNC R_ExternalPtrAddrFn(SEXP s) {
+   fn_ptr ptr;
+   ptr.p = R_ExternalPtrAddr(s);
+   return ptr.fn;
+ }
+#endif
+
+// The R API does not have a setter for function pointers
+
+SEXP cleancall_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot) {
+    fn_ptr tmp;
+    tmp.fn = p;
+    return R_MakeExternalPtr(tmp.p, tag, prot);
+}
+
+void cleancall_SetExternalPtrAddrFn(SEXP s, DL_FUNC p) {
+    fn_ptr ptr;
+    ptr.fn = p;
+    R_SetExternalPtrAddr(s, ptr.p);
+}
+
+
+// Initialised at load time with the `.Call` primitive
+SEXP cleancall_fns_dot_call = NULL;
+
+static SEXP callbacks = NULL;
+
+void cleancall_init(void) {
+  cleancall_fns_dot_call = Rf_findVar(Rf_install(".Call"), R_BaseEnv);
+  callbacks = R_NilValue;
+}
+
+struct eval_args {
+  SEXP call;
+  SEXP env;
+};
+
+static SEXP eval_wrap(void* data) {
+  struct eval_args* args = (struct eval_args*) data;
+  return Rf_eval(args->call, args->env);
+}
+
+
+SEXP cleancall_call(SEXP args, SEXP env) {
+  SEXP call = PROTECT(Rf_lcons(cleancall_fns_dot_call, args));
+  struct eval_args data = { call, env };
+
+  SEXP out = r_with_cleanup_context(&eval_wrap, &data);
+
+  UNPROTECT(1);
+  return out;
+}
+
+
+// Preallocate a callback
+static void push_callback(SEXP stack) {
+  SEXP top = CDR(stack);
+
+  SEXP early_handler = PROTECT(Rf_allocVector(LGLSXP, 1));
+  SEXP fn_extptr = PROTECT(cleancall_MakeExternalPtrFn(NULL, R_NilValue,
+                                                       R_NilValue));
+  SEXP data_extptr = PROTECT(R_MakeExternalPtr(NULL, early_handler,
+                                               R_NilValue));
+  SEXP cb = Rf_cons(Rf_cons(fn_extptr, data_extptr), top);
+
+  SETCDR(stack, cb);
+
+  UNPROTECT(3);
+}
+
+struct data_wrapper {
+  SEXP (*fn)(void* data);
+  void *data;
+  SEXP callbacks;
+  int success;
+};
+
+static void call_exits(void* data) {
+  // Remove protecting node. Don't remove the preallocated callback on
+  // the top as it might contain a handler when something went wrong.
+  SEXP top = CDR(callbacks);
+
+  // Restore old stack
+  struct data_wrapper* state = data;
+  callbacks = (SEXP) state->callbacks;
+
+  // Handlers should not jump
+  while (top != R_NilValue) {
+    SEXP cb = CAR(top);
+    top = CDR(top);
+
+    void (*fn)(void*) = (void (*)(void*)) R_ExternalPtrAddrFn(CAR(cb));
+    void *data = (void*) R_ExternalPtrAddr(CDR(cb));
+    int early_handler = LOGICAL(R_ExternalPtrTag(CDR(cb)))[0];
+
+    // Check for empty pointer in preallocated callbacks
+    if (fn) {
+      if (!early_handler || !state->success) fn(data);
+    }
+  }
+}
+
+static SEXP with_cleanup_context_wrap(void *data) {
+  struct data_wrapper* cdata = data;
+  SEXP ret = cdata->fn(cdata->data);
+  cdata->success = 1;
+  return ret;
+}
+
+SEXP r_with_cleanup_context(SEXP (*fn)(void* data), void* data) {
+  // Preallocate new stack before changing `callbacks` to avoid
+  // leaving the global variable in a bad state if alloc fails
+  SEXP new = PROTECT(Rf_cons(R_NilValue, R_NilValue));
+  push_callback(new);
+
+  SEXP old = callbacks;
+  callbacks = new;
+
+  struct data_wrapper state = { fn, data, old, 0 };
+
+  SEXP out = R_ExecWithCleanup(with_cleanup_context_wrap, &state,
+                               &call_exits, &state);
+
+  UNPROTECT(1);
+  return out;
+}
+
+static void call_save_handler(void (*fn)(void *data), void* data,
+                              int early) {
+  if (Rf_isNull(callbacks)) {
+    fn(data);
+    Rf_error("Internal error: Exit handler pushed outside "
+             "of an exit context");
+  }
+
+  SEXP cb = CADR(callbacks);
+
+  // Update pointers
+  cleancall_SetExternalPtrAddrFn(CAR(cb), (DL_FUNC) fn);
+  R_SetExternalPtrAddr(CDR(cb), data);
+  LOGICAL(R_ExternalPtrTag(CDR(cb)))[0] = early;
+
+  // Preallocate the next callback in case the allocator jumps
+  push_callback(callbacks);
+}
+
+void r_call_on_exit(void (*fn)(void* data), void* data) {
+  call_save_handler(fn, data, /* early = */ 0);
+}
+
+void r_call_on_early_exit(void (*fn)(void* data), void* data) {
+  call_save_handler(fn, data, /* early = */ 1);
+}
diff --git a/src/library/ps/src/cleancall.h b/src/library/ps/src/cleancall.h
new file mode 100644
index 000000000..b60b12a71
--- /dev/null
+++ b/src/library/ps/src/cleancall.h
@@ -0,0 +1,51 @@
+#ifndef CLEANCALL_H
+#define CLEANCALL_H
+
+#include <Rversion.h>
+#include <Rinternals.h>
+#include <R_ext/Rdynload.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// --------------------------------------------------------------------
+// Internals
+// --------------------------------------------------------------------
+
+typedef union {void* p; DL_FUNC fn;} fn_ptr;
+
+#if (defined(R_VERSION) && R_VERSION < R_Version(3, 4, 0))
+ SEXP R_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot);
+ DL_FUNC R_ExternalPtrAddrFn(SEXP s);
+#endif
+
+// --------------------------------------------------------------------
+// API for packages that embed cleancall
+// --------------------------------------------------------------------
+
+// The R API does not have a setter for external function pointers
+SEXP cleancall_MakeExternalPtrFn(DL_FUNC p, SEXP tag, SEXP prot);
+void cleancall_SetExternalPtrAddrFn(SEXP s, DL_FUNC p);
+
+#define CLEANCALL_METHOD_RECORD  \
+  {"cleancall_call", (DL_FUNC) &cleancall_call, 2}
+
+SEXP cleancall_call(SEXP args, SEXP env);
+void cleancall_init(void);
+
+// --------------------------------------------------------------------
+// Public API
+// --------------------------------------------------------------------
+
+#define R_CLEANCALL_SUPPORT 1
+
+SEXP r_with_cleanup_context(SEXP (*fn)(void* data), void* data);
+void r_call_on_exit(void (*fn)(void* data), void* data);
+void r_call_on_early_exit(void (*fn)(void* data), void* data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/library/ps/src/dummy.c b/src/library/ps/src/dummy.c
index 32ecb539a..ee077d335 100644
--- a/src/library/ps/src/dummy.c
+++ b/src/library/ps/src/dummy.c
@@ -21,6 +21,7 @@ SEXP ps__dummy(const char *what) {
 #ifndef PS__WINDOWS
 SEXP ps__pids(void)          { return ps__dummy("ps_pids"); }
 SEXP psll_memory_uss(SEXP p) { return ps__dummy("psll_memory_uss"); }
+SEXP ps__disk_io_counters(void) { return ps__dummy("ps__get_disk_io_counters"); }
 #endif
 #endif
 #endif
@@ -61,6 +62,13 @@ SEXP ps__memory_maps(SEXP p) { return ps__dummy("ps__memory_maps"); }
 #endif
 #endif
 
+/* Only implemented on macOS */
+#ifndef PS__MACOS
+#if defined(PS__WINDOWS) || defined(PS__LINUX)
+SEXP ps__list_apps(void) { return ps__dummy("ps__list_apps"); }
+#endif
+#endif
+
 /* All C functions called from R */
 #ifndef PS__MACOS
 #ifndef PS__LINUX
@@ -73,10 +81,14 @@ SEXP ps__users(void) { return ps__dummy("ps_users"); }
 SEXP ps__loadavg(SEXP x) { return ps__dummy("ps_loadavg"); }
 SEXP ps__tty_size(void) { return ps__dummy("ps_tty_size"); }
 SEXP ps__disk_partitions(SEXP x) { return ps__dummy("ps_disk_partitions"); }
+SEXP ps__disk_io_counters(void) { return ps__dummy("ps__get_disk_io_counters"); }
 SEXP ps__disk_usage(void) { return ps__dummy("ps_disk_usage"); }
+SEXP ps__fs_info(SEXP x, SEXP y, SEXP z) { return ps__dummy("ps_fs_info"); }
 SEXP ps__system_cpu_times(void) { return ps__dummy("ps_system_cpu_times"); }
 SEXP ps__system_memory(void) { return ps__dummy("ps_system_memory"); }
 SEXP ps__system_swap(void) { return ps__dummy("ps_system_swap"); }
+SEXP ps__stat(SEXP x, SEXP f) { return ps__dummy("ps_fs_stat"); }
+SEXP ps__mount_point(SEXP x) { return ps__dummy("ps_fs_mount_point"); }
 
 SEXP psll_handle(SEXP x, SEXP y) { return ps__dummy("ps_handle"); }
 SEXP psll_format(SEXP x) { return ps__dummy("ps_format"); }
@@ -100,7 +112,7 @@ SEXP psll_send_signal(SEXP x, SEXP y) { return ps__dummy("ps_send_signal"); }
 SEXP psll_suspend(SEXP x) { return ps__dummy("ps_suspend"); }
 SEXP psll_resume(SEXP x) { return ps__dummy("ps_resume"); }
 SEXP psll_terminate(SEXP x) { return ps__dummy("ps_terminate"); }
-SEXP psll_kill(SEXP x) { return ps__dummy("ps_kill"); }
+SEXP psll_kill(SEXP x, SEXP grace) { return ps__dummy("ps_kill"); }
 SEXP psll_num_fds(SEXP x) { return ps__dummy("ps_num_fds"); }
 SEXP psll_open_files(SEXP x) { return ps__dummy("ps_open_files"); }
 SEXP psll_interrupt(SEXP x, SEXP y, SEXP z) { return ps__dummy("ps_interrupt"); }
@@ -110,9 +122,9 @@ SEXP psll_set_nice(SEXP x, SEXP y) { return ps__dummy("ps_set_nice"); }
 SEXP psll_memory_uss(SEXP p) { return ps__dummy("psll_memory_uss"); }
 SEXP psll_get_cpu_aff(SEXP p) { return ps__dummy("psll_get_cpu_aff"); }
 SEXP psll_set_cpu_aff(SEXP p) { return ps__dummy("psll_set_cpu_aff"); }
+SEXP psll_wait(SEXP pps, SEXP timeout) { return ps__dummy("psll_wait"); }
 
 SEXP ps__init(SEXP x, SEXP y) { return R_NilValue; /* this needs to run to load package */ }
-SEXP ps__kill_if_env(SEXP x, SEXP y, SEXP z, SEXP a) { return ps__dummy("ps__kill_if_env"); }
 SEXP ps__find_if_env(SEXP x, SEXP y, SEXP z) { return ps__dummy("ps__find_if_env"); }
 SEXP ps__memory_maps(SEXP p) { return ps__dummy("ps__memory_maps"); }
 
@@ -125,6 +137,7 @@ SEXP psw__realpath(SEXP x) { return ps__dummy("psw__realpath"); }
 SEXP psll_dlls(SEXP x) { return ps__dummy("psll_dlls"); }
 
 SEXP ps__inet_ntop(SEXP x, SEXP y) { return ps__dummy("ps__inet_ntop"); }
+SEXP ps__list_apps(void) { return ps__dummy("ps__list_apps"); }
 #endif
 #endif
 #endif
diff --git a/src/library/ps/src/extra.c b/src/library/ps/src/extra.c
index 9ba6949f7..a7c8d3395 100644
--- a/src/library/ps/src/extra.c
+++ b/src/library/ps/src/extra.c
@@ -20,16 +20,13 @@ SEXP ps__last_error;
 
 /* TODO: these should throw real error objects */
 
-void *ps__set_error_impl(const char *class, int system_errno,
-			 long pid, const char *msg, ...) {
-  va_list args;
+void *ps__vset_error_impl(const char *class, int system_errno,
+			 long pid, const char *msg, va_list args) {
   const char *ps_error = "ps_error", *error = "error", *condition = "condition";
   SEXP rclass;
 
-  va_start(args, msg);
   vsnprintf(ps__last_error_string,
 	    sizeof(ps__last_error_string) - 1, msg, args);
-  va_end(args);
 
   SET_VECTOR_ELT(ps__last_error, 0, mkString(ps__last_error_string));
   if (class) {
@@ -44,11 +41,21 @@ void *ps__set_error_impl(const char *class, int system_errno,
   return NULL;
 }
 
+void *ps__set_error_impl(const char *class, int system_errno,
+			 long pid, const char *msg, ...) {
+  va_list args;
+
+  va_start(args, msg);
+  void *ret = ps__vset_error_impl(class, system_errno, pid, msg, args);
+  va_end(args);
+  return ret;
+}
+
 void *ps__set_error(const char *msg, ...) {
   va_list args;
 
   va_start(args, msg);
-  ps__set_error_impl(0, 0, NA_INTEGER, msg, args);
+  ps__vset_error_impl(0, 0, NA_INTEGER, msg, args);
   va_end(args);
 
   return NULL;
@@ -66,6 +73,11 @@ void *ps__access_denied(const char *msg) {
 			    msg && strlen(msg) ? msg : "Permission denied");
 }
 
+void *ps__access_denied_pid(long pid, const char *msg) {
+  return ps__set_error_impl("access_denied", 0, pid,
+			    msg && strlen(msg) ? msg : "Permission denied");
+}
+
 void *ps__zombie_process(long pid) {
   return ps__set_error_impl("zombie_process", 0, pid,
 			    "Process is a zombie, pid %ld", pid);
diff --git a/src/library/ps/src/init.c b/src/library/ps/src/init.c
index 4bc9f8aca..fea2a3dcc 100644
--- a/src/library/ps/src/init.c
+++ b/src/library/ps/src/init.c
@@ -7,8 +7,18 @@
 
 #include "ps-internal.h"
 #include "common.h"
+#include "config.h"
+#include "cleancall.h"
+
+#ifdef PS__MACOS
+#include <mach/mach_time.h>
+extern struct mach_timebase_info PS_MACH_TIMEBASE_INFO;
+#endif
+
 
 static const R_CallMethodDef callMethods[]  = {
+  CLEANCALL_METHOD_RECORD,
+
   /* System api */
   { "ps__os_type",            (DL_FUNC) ps__os_type,            0 },
   { "ps__pids",               (DL_FUNC) ps__pids,               0 },
@@ -21,9 +31,13 @@ static const R_CallMethodDef callMethods[]  = {
   { "ps__tty_size",           (DL_FUNC) ps__tty_size,           0 },
   { "ps__disk_partitions",    (DL_FUNC) ps__disk_partitions,    1 },
   { "ps__disk_usage",         (DL_FUNC) ps__disk_usage,         1 },
+  { "ps__disk_io_counters",   (DL_FUNC) ps__disk_io_counters,   0 },
+  { "ps__fs_info",            (DL_FUNC) ps__fs_info,            3 },
   { "ps__system_memory",      (DL_FUNC) ps__system_memory,      0 },
   { "ps__system_swap",        (DL_FUNC) ps__system_swap,        0 },
-
+  { "ps__list_apps",          (DL_FUNC) ps__list_apps,          0 },
+  { "ps__stat",               (DL_FUNC) ps__stat,               2 },
+  { "ps__mount_point",        (DL_FUNC) ps__mount_point,        1 },
   /* ps_handle API */
   { "psll_pid",          (DL_FUNC) psll_pid,          1 },
   { "psll_handle",       (DL_FUNC) psll_handle,       2 },
@@ -50,7 +64,7 @@ static const R_CallMethodDef callMethods[]  = {
   { "psll_suspend",      (DL_FUNC) psll_suspend,      1 },
   { "psll_resume",       (DL_FUNC) psll_resume,       1 },
   { "psll_terminate",    (DL_FUNC) psll_terminate,    1 },
-  { "psll_kill",         (DL_FUNC) psll_kill,         1 },
+  { "psll_kill",         (DL_FUNC) psll_kill,         2 },
   { "psll_num_fds",      (DL_FUNC) psll_num_fds,      1 },
   { "psll_open_files",   (DL_FUNC) psll_open_files,   1 },
   { "psll_interrupt",    (DL_FUNC) psll_interrupt,    3 },
@@ -60,10 +74,10 @@ static const R_CallMethodDef callMethods[]  = {
   { "psll_dlls",         (DL_FUNC) psll_dlls,         1 },
   { "psll_get_cpu_aff",  (DL_FUNC) psll_get_cpu_aff,  1 },
   { "psll_set_cpu_aff",  (DL_FUNC) psll_set_cpu_aff,  2 },
+  { "psll_wait",         (DL_FUNC) psll_wait,         2 },
 
   /* Utils */
   { "ps__init",          (DL_FUNC) ps__init,          2 },
-  { "ps__kill_if_env",   (DL_FUNC) ps__kill_if_env,   4 },
   { "ps__find_if_env",   (DL_FUNC) ps__find_if_env,   3 },
   { "ps__inet_ntop",     (DL_FUNC) ps__inet_ntop,     2 },
   { "ps__memory_maps",   (DL_FUNC) ps__memory_maps,   1 },
@@ -78,10 +92,14 @@ static const R_CallMethodDef callMethods[]  = {
   { NULL, NULL, 0 }
 };
 
+int ps_pidfd_open_support = PS_MAYBE;
+
 /*
  * Called on module import on all platforms.
  */
 void R_init_ps(DllInfo *dll) {
+  cleancall_init();
+
   if (getenv("R_PS_DEBUG") != NULL) PS__DEBUG = 1;
   if (getenv("R_PS_TESTING") != NULL) PS__TESTING = 1;
 
@@ -96,6 +114,10 @@ void R_init_ps(DllInfo *dll) {
   R_PreserveObject(ps__last_error);
   UNPROTECT(1);
 
+#ifdef PS__MACOS
+  mach_timebase_info(&PS_MACH_TIMEBASE_INFO);
+#endif
+
   R_registerRoutines(dll, NULL, callMethods, NULL, NULL);
   R_useDynamicSymbols(dll, FALSE);
   R_forceSymbols(dll, TRUE);
diff --git a/src/library/ps/src/ps-internal.h b/src/library/ps/src/ps-internal.h
index 820660d70..f0ca55b26 100644
--- a/src/library/ps/src/ps-internal.h
+++ b/src/library/ps/src/ps-internal.h
@@ -5,6 +5,8 @@
 #include "config.h"
 #include "ps.h"
 
+#define PROCESSX_INTERRUPT_INTERVAL 200
+
 #ifdef PS__MACOS
 
 #include <signal.h>
@@ -67,6 +69,12 @@ SEXP ps__define_errno(void);
 SEXP ps__define_socket_address_families(void);
 SEXP ps__define_socket_types(void);
 
+#define PS_MAYBE 0
+#define PS_YEAH 1
+#define PS_NOPE 2
+
+extern int ps_pidfd_open_support;
+
 /* Errors */
 
 extern SEXP ps__last_error;
@@ -83,6 +91,7 @@ void *ps__set_error_from_errno(void);
 SEXP ps__throw_error(void);
 
 void *ps__access_denied(const char *msg);
+void *ps__access_denied_pid(long pid, const char *msg);
 void *ps__no_such_process(long pid, const char *name);
 void *ps__zombie_process(long pid);
 void *ps__no_memory(const char *msg);
diff --git a/src/library/ps/src/ps.h b/src/library/ps/src/ps.h
index 0228291b2..a5bffc1d7 100644
--- a/src/library/ps/src/ps.h
+++ b/src/library/ps/src/ps.h
@@ -36,7 +36,7 @@ SEXP psll_send_signal(SEXP p, SEXP sig);
 SEXP psll_suspend(SEXP p);
 SEXP psll_resume(SEXP p);
 SEXP psll_terminate(SEXP p);
-SEXP psll_kill(SEXP p);
+SEXP psll_kill(SEXP p, SEXP grace);
 SEXP psll_num_fds(SEXP p);
 SEXP psll_open_files(SEXP p);
 SEXP psll_interrupt(SEXP p, SEXP ctrlc, SEXP interrupt_path);
@@ -46,6 +46,7 @@ SEXP psll_set_nice(SEXP p, SEXP value);
 SEXP psll_dlls(SEXP p);
 SEXP psll_get_cpu_aff(SEXP p);
 SEXP psll_set_cpu_aff(SEXP p, SEXP affinity);
+SEXP psll_wait(SEXP p, SEXP timeout);
 
 /* System API */
 
@@ -59,14 +60,18 @@ SEXP ps__users(void);
 SEXP ps__tty_size(void);
 SEXP ps__disk_partitions(SEXP all);
 SEXP ps__disk_usage(SEXP paths);
+SEXP ps__disk_io_counters(void);
+SEXP ps__fs_info(SEXP path, SEXP abspath, SEXP mps);
 SEXP ps__system_memory(void);
 SEXP ps__system_swap(void);
 SEXP ps__loadavg(SEXP counter_name);
+SEXP ps__list_apps(void);
+SEXP ps__stat(SEXP path, SEXP follow);
+SEXP ps__mount_point(SEXP paths);
 
 /* Generic utils used from R */
 
 SEXP ps__init(SEXP psenv, SEXP constenv);
-SEXP ps__kill_if_env(SEXP marker, SEXP after, SEXP pid, SEXP sig);
 SEXP ps__find_if_env(SEXP marker, SEXP after, SEXP pid);
 SEXP ps__inet_ntop(SEXP raw, SEXP fam);
 SEXP ps__memory_maps(SEXP p);
diff --git a/src/library/ps/src/px.c b/src/library/ps/src/px.c
index 932469e8e..8ce6ddbe6 100644
--- a/src/library/ps/src/px.c
+++ b/src/library/ps/src/px.c
@@ -34,6 +34,10 @@ void usage(void) {
 	  "echo from fd to another fd\n");
   fprintf(stderr, "  getenv <var>               -- "
 	  "environment variable to stdout\n");
+  fprintf(stderr, "  sigterm ignore             -- "
+	  "ignore SIGTERM\n");
+  fprintf(stderr, "  sigterm sleep <seconds>    -- "
+	  "sleep a number of seconds on SIGTERM, then quit\n");
 }
 
 void cat2(int f, const char *s) {
@@ -91,6 +95,35 @@ int echo_from_fd(int fd1, int fd2, int nbytes) {
   return 0;
 }
 
+#ifdef _WIN32
+void sigterm_ignore(void) { }
+void sigterm_sleep(double fnum) { }
+#else
+#include <signal.h>
+
+double sig_sleep_secs;
+
+void sigterm_ignore(void) {
+  signal(SIGTERM, SIG_IGN);
+}
+
+void sig_handler_sleep(int sig, siginfo_t *info, void *ucontext) {
+  double fnum = sig_sleep_secs;
+  int num = (int) fnum;
+  sleep(num);
+  fnum = fnum - num;
+  if (fnum > 0) usleep((useconds_t)(fnum * 1000.0 * 1000.0));
+}
+
+void sigterm_sleep(double fnum) {
+  sig_sleep_secs = fnum;
+  struct sigaction sig = {{ 0 }};
+  sig.sa_flags = SA_SIGINFO;
+  sig.sa_sigaction = &sig_handler_sleep;
+  sigaction(SIGTERM, &sig, NULL);
+}
+#endif
+
 int main(int argc, const char **argv) {
 
   int num, idx, ret, fd, fd2, nbytes;
@@ -173,6 +206,30 @@ int main(int argc, const char **argv) {
       printf("%s\n", getenv(argv[++idx]));
       fflush(stdout);
 
+    } else if (!strcmp("sigterm", cmd)) {
+      if (idx + 1 >= argc) {
+        fprintf(stderr, "Missing argument(s) for 'sigterm'\n");
+        return 10;
+      }
+      idx++;
+      if (!strcmp("ignore", argv[idx])) {
+        sigterm_ignore();
+      } else if (!strcmp("sleep", argv[idx])) {
+        if (idx + 2 >= argc) {
+          fprintf(stderr, "Missing argument for 'sigterm sleep'\n");
+          return 11;
+        }
+        idx++;
+        ret = sscanf(argv[idx], "%lf", &fnum);
+        if (ret != 1) {
+          fprintf(stderr, "Invalid seconds for px sigterm sleep: '%s'\n", argv[idx]);
+          return 12;
+        }
+        sigterm_sleep(fnum);
+      } else {
+        fprintf(stderr, "Invalid 'sigterm' subcommand");
+        return 13;
+      }
     } else {
       fprintf(stderr, "Unknown px command: '%s'\n", cmd);
       return 2;
diff --git a/src/library/ps/tools/linux-fs-types.txt b/src/library/ps/tools/linux-fs-types.txt
new file mode 100644
index 000000000..373f8efe9
--- /dev/null
+++ b/src/library/ps/tools/linux-fs-types.txt
@@ -0,0 +1,85 @@
+name id
+adfs 44533
+affs 44543
+afs 1397113167
+anon_inode_fs 151263540
+autofs 391
+bdevfs 1650746742
+befs 1111905073
+bfs 464386766
+binfmtfs 1112100429
+bpf_fs 3405662737
+btrfs 2435016766
+btrfs_test 1936880249
+cgroup 2613483
+cgroup2 1667723888
+cifs_number 4283649346
+coda 1937076805
+coh 19920823
+cramfs 684539205
+debugfs 1684170528
+devfs 4979
+devpts 7377
+ecryptfs 61791
+efivarfs 3730735588
+efs 4278867
+ext 4989
+ext2_old 61265
+ext2 61267
+ext3 61267
+ext4 61267
+f2fs 4076150800
+fuse 1702057286
+futexfs 195894762
+hfs 16964
+hostfs 12648430
+hpfs 4187351113
+hugetlbfs 2508478710
+isofs 38496
+jffs2 29366
+jfs 827541066
+minix 4991
+minix2 5007
+minix2 9320
+minix22 9336
+minix3 19802
+mqueue 427819522
+msdos 19780
+mtd_inode_fs 288389204
+ncp 22092
+nfs 26985
+nilfs 13364
+nsfs 1853056627
+ntfs_sb 1397118030
+ocfs2 1952539503
+openprom 40865
+overlayfs 2035054128
+pipefs 1346981957
+proc 40864
+pstorefs 1634035564
+qnx4 47
+qnx6 1746473250
+ramfs 2240043254
+reiserfs 1382369651
+romfs 29301
+securityfs 1935894131
+selinux 4185718668
+smack 1128357203
+smb 20859
+smb2_number 4266872130
+sockfs 1397703499
+squashfs 1936814952
+sysfs 1650812274
+sysv2 19920822
+sysv4 19920821
+tmpfs 16914836
+tracefs 1953653091
+udf 352400198
+ufs 72020
+usbdevice 40866
+v9fs 16914839
+vxfs 2768370933
+xenfs 2881100148
+xenix 19920820
+xfs 1481003842
+_xiafs 19911021