| /* |
| * Copyright (c) 2010, The Android Open Source Project |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google, Inc. nor the names of its contributors |
| * may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| #include <ctype.h> |
| #include <dirent.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <libgen.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include <pwd.h> |
| #include <sys/stat.h> |
| |
| #define BUF_MAX 1024 |
| #define CMD_DISPLAY_MAX (9 + 1) |
| #define USER_DISPLAY_MAX (10 + 1) |
| |
| struct pid_info_t { |
| pid_t pid; |
| char user[USER_DISPLAY_MAX]; |
| |
| char cmdline[CMD_DISPLAY_MAX]; |
| |
| char path[PATH_MAX]; |
| ssize_t parent_length; |
| }; |
| |
| static void print_header() |
| { |
| printf("%-9s %5s %10s %4s %9s %18s %9s %10s %s\n", |
| "COMMAND", |
| "PID", |
| "USER", |
| "FD", |
| "TYPE", |
| "DEVICE", |
| "SIZE/OFF", |
| "NODE", |
| "NAME"); |
| } |
| |
| static void print_symlink(const char* name, const char* path, struct pid_info_t* info) |
| { |
| static ssize_t link_dest_size; |
| static char link_dest[PATH_MAX]; |
| |
| strlcat(info->path, path, sizeof(info->path)); |
| if ((link_dest_size = readlink(info->path, link_dest, sizeof(link_dest)-1)) < 0) { |
| if (errno == ENOENT) |
| goto out; |
| |
| snprintf(link_dest, sizeof(link_dest), "%s (readlink: %s)", info->path, strerror(errno)); |
| } else { |
| link_dest[link_dest_size] = '\0'; |
| } |
| |
| // Things that are just the root filesystem are uninteresting (we already know) |
| if (!strcmp(link_dest, "/")) |
| goto out; |
| |
| const char* fd = name; |
| char rw = ' '; |
| char locks = ' '; // TODO: read /proc/locks |
| |
| const char* type = "unknown"; |
| char device[32] = "?"; |
| char size_off[32] = "?"; |
| char node[32] = "?"; |
| |
| struct stat sb; |
| if (lstat(link_dest, &sb) != -1) { |
| switch ((sb.st_mode & S_IFMT)) { |
| case S_IFSOCK: type = "sock"; break; // TODO: what domain? |
| case S_IFLNK: type = "LINK"; break; |
| case S_IFREG: type = "REG"; break; |
| case S_IFBLK: type = "BLK"; break; |
| case S_IFDIR: type = "DIR"; break; |
| case S_IFCHR: type = "CHR"; break; |
| case S_IFIFO: type = "FIFO"; break; |
| } |
| snprintf(device, sizeof(device), "%d,%d", (int) sb.st_dev, (int) sb.st_rdev); |
| snprintf(node, sizeof(node), "%d", (int) sb.st_ino); |
| snprintf(size_off, sizeof(size_off), "%d", (int) sb.st_size); |
| } |
| |
| if (!name) { |
| // We're looking at an fd, so read its flags. |
| fd = path; |
| char fdinfo_path[PATH_MAX]; |
| snprintf(fdinfo_path, sizeof(fdinfo_path), "/proc/%d/fdinfo/%s", info->pid, path); |
| FILE* fp = fopen(fdinfo_path, "r"); |
| if (fp != NULL) { |
| int pos; |
| unsigned flags; |
| |
| if (fscanf(fp, "pos: %d flags: %o", &pos, &flags) == 2) { |
| flags &= O_ACCMODE; |
| if (flags == O_RDONLY) rw = 'r'; |
| else if (flags == O_WRONLY) rw = 'w'; |
| else rw = 'u'; |
| } |
| fclose(fp); |
| } |
| } |
| |
| printf("%-9s %5d %10s %4s%c%c %9s %18s %9s %10s %s\n", |
| info->cmdline, info->pid, info->user, fd, rw, locks, type, device, size_off, node, link_dest); |
| |
| out: |
| info->path[info->parent_length] = '\0'; |
| } |
| |
| // Prints out all file that have been memory mapped |
| static void print_maps(struct pid_info_t* info) |
| { |
| FILE *maps; |
| size_t offset; |
| char device[10]; |
| long int inode; |
| char file[PATH_MAX]; |
| |
| strlcat(info->path, "maps", sizeof(info->path)); |
| |
| maps = fopen(info->path, "r"); |
| if (!maps) |
| goto out; |
| |
| while (fscanf(maps, "%*x-%*x %*s %zx %s %ld %s\n", &offset, device, &inode, file) == 4) { |
| // We don't care about non-file maps |
| if (inode == 0 || !strcmp(device, "00:00")) |
| continue; |
| |
| printf("%-9s %5d %10s %4s %9s %18s %9zd %10ld %s\n", |
| info->cmdline, info->pid, info->user, "mem", |
| "REG", device, offset, inode, file); |
| } |
| |
| fclose(maps); |
| |
| out: |
| info->path[info->parent_length] = '\0'; |
| } |
| |
| // Prints out all open file descriptors |
| static void print_fds(struct pid_info_t* info) |
| { |
| static char* fd_path = "fd/"; |
| strlcat(info->path, fd_path, sizeof(info->path)); |
| |
| int previous_length = info->parent_length; |
| info->parent_length += strlen(fd_path); |
| |
| DIR *dir = opendir(info->path); |
| if (dir == NULL) { |
| char msg[BUF_MAX]; |
| snprintf(msg, sizeof(msg), "%s (opendir: %s)", info->path, strerror(errno)); |
| printf("%-9s %5d %10s %4s %9s %18s %9s %10s %s\n", |
| info->cmdline, info->pid, info->user, "FDS", |
| "", "", "", "", msg); |
| goto out; |
| } |
| |
| struct dirent* de; |
| while ((de = readdir(dir))) { |
| if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) |
| continue; |
| |
| print_symlink(NULL, de->d_name, info); |
| } |
| closedir(dir); |
| |
| out: |
| info->parent_length = previous_length; |
| info->path[info->parent_length] = '\0'; |
| } |
| |
| static void lsof_dumpinfo(pid_t pid) |
| { |
| int fd; |
| struct pid_info_t info; |
| struct stat pidstat; |
| struct passwd *pw; |
| |
| info.pid = pid; |
| snprintf(info.path, sizeof(info.path), "/proc/%d/", pid); |
| info.parent_length = strlen(info.path); |
| |
| // Get the UID by calling stat on the proc/pid directory. |
| if (!stat(info.path, &pidstat)) { |
| pw = getpwuid(pidstat.st_uid); |
| if (pw) { |
| strlcpy(info.user, pw->pw_name, sizeof(info.user)); |
| } else { |
| snprintf(info.user, USER_DISPLAY_MAX, "%d", (int)pidstat.st_uid); |
| } |
| } else { |
| strcpy(info.user, "???"); |
| } |
| |
| // Read the command line information; each argument is terminated with NULL. |
| strlcat(info.path, "cmdline", sizeof(info.path)); |
| fd = open(info.path, O_RDONLY); |
| if (fd < 0) { |
| fprintf(stderr, "Couldn't read %s\n", info.path); |
| return; |
| } |
| |
| char cmdline[PATH_MAX]; |
| int numRead = read(fd, cmdline, sizeof(cmdline) - 1); |
| close(fd); |
| |
| if (numRead < 0) { |
| fprintf(stderr, "Error reading cmdline: %s: %s\n", info.path, strerror(errno)); |
| return; |
| } |
| |
| cmdline[numRead] = '\0'; |
| |
| // We only want the basename of the cmdline |
| strlcpy(info.cmdline, basename(cmdline), sizeof(info.cmdline)); |
| |
| // Read each of these symlinks |
| print_symlink("cwd", "cwd", &info); |
| print_symlink("txt", "exe", &info); |
| print_symlink("rtd", "root", &info); |
| print_fds(&info); |
| print_maps(&info); |
| } |
| |
| int lsof_main(int argc, char *argv[]) |
| { |
| long int pid = 0; |
| char* endptr; |
| if (argc == 2) { |
| pid = strtol(argv[1], &endptr, 10); |
| } |
| |
| print_header(); |
| |
| if (pid) { |
| lsof_dumpinfo(pid); |
| } else { |
| DIR *dir = opendir("/proc"); |
| if (dir == NULL) { |
| fprintf(stderr, "Couldn't open /proc\n"); |
| return -1; |
| } |
| |
| struct dirent* de; |
| while ((de = readdir(dir))) { |
| if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) |
| continue; |
| |
| // Only inspect directories that are PID numbers |
| pid = strtol(de->d_name, &endptr, 10); |
| if (*endptr != '\0') |
| continue; |
| |
| lsof_dumpinfo(pid); |
| } |
| closedir(dir); |
| } |
| |
| return 0; |
| } |