openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge "Lose lsof to toybox."

This commit is contained in:
Elliott Hughes 2015-09-11 20:44:48 +00:00 committed by Gerrit Code Review
parent 31139af04f 42325f073c
commit 059544f6a8
2 changed files with 0 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
toolbox/Android.mk
View File

@ -43,7 +43,6 @@ OUR_TOOLS := \
iftop \
ioctl \
log \
lsof \
nandread \
newfs_msdos \
ps \

296
toolbox/lsof.c
View File

@ -1,296 +0,0 @@
/*
* 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;
}