logwrapper module

概述

使用伪终端的方式来处理子进程的log输出，logwrapper会等待子进程执行完毕之后再退出

源码解析

1. logwrap模块

1.1 logwrap_fork_execvp

// {"/system/bin/vdc","cryptfs", "encryptFstab", attempted_entry.blk_device, attempted_entry.mount_point}
// logwrap_fork_execvp(argv.size(), argv.data(), ret, false, LOG_ALOG, false, nullptr);	ret为null
int logwrap_fork_execvp(int argc, const char* const* argv, int* status, bool forward_signals,
                        int log_target, bool abbreviated, const char* file_path) {
    pid_t pid;
    int parent_ptty;
    sigset_t oldset;
    int rc = 0;

    rc = pthread_mutex_lock(&fd_mutex);
    if (rc) {
        ERROR("failed to lock signal_fd mutex\n");
        goto err_lock;
    }
// 打开一个伪终端设备
    /* Use ptty instead of socketpair so that STDOUT is not buffered */
    parent_ptty = TEMP_FAILURE_RETRY(posix_openpt(O_RDWR | O_CLOEXEC));
    if (parent_ptty < 0) {
        ERROR("Cannot create parent ptty\n");
        rc = -1;
        goto err_open;
    }

    char child_devname[64];
    // grantpt：改变伪终端的mode和owner，授予对从属伪终端的访问权限
    // unlockpt：解锁一个伪终端主从对
    // ptsname_r：获取从伪终端的名字
    if (grantpt(parent_ptty) || unlockpt(parent_ptty) ||
        ptsname_r(parent_ptty, child_devname, sizeof(child_devname)) != 0) {
        ERROR("Problem with /dev/ptmx\n");
        rc = -1;
        goto err_ptty;
    }
// forward_signals为false，不走这里
    if (forward_signals) {
        // Block these signals until we have the child pid and our signal handlers set up.
        block_signals(&oldset);
    }
// 创建子进程
    pid = fork();
    if (pid < 0) {
        ERROR("Failed to fork\n");
        rc = -1;
        goto err_fork;
    } else if (pid == 0) {// 子进程
        pthread_mutex_unlock(&fd_mutex);
        if (forward_signals) {
            unblock_signals(&oldset);
        }
// 创建会话，并设置进程组id
        setsid();
// 所以，子进程和伪终端的slave相连接
        int child_ptty = TEMP_FAILURE_RETRY(open(child_devname, O_RDWR | O_CLOEXEC));
        if (child_ptty < 0) {
            FATAL_CHILD("Cannot open child_ptty: %s\n", strerror(errno));
        }
        close(parent_ptty);
// 设置标准输出和错误为伪终端
        // 只设置了错误和输出，表示是log输出信息
        dup2(child_ptty, 1);
        dup2(child_ptty, 2);
        close(child_ptty);
// 子进程函数
        child(argc, argv);
    } else {// 父进程
        if (forward_signals) {
            setup_signal_handlers(pid);
            unblock_signals(&oldset);
        }
// 父进程函数，
        rc = parent(argv[0], parent_ptty, pid, status, log_target, abbreviated, file_path,
                    forward_signals);

        if (forward_signals) {
            restore_signal_handlers();
        }
    }

err_fork:
    if (forward_signals) {
        unblock_signals(&oldset);
    }
err_ptty:
    close(parent_ptty);
err_open:
    pthread_mutex_unlock(&fd_mutex);
err_lock:
    return rc;
}

1.2 child-直接执行execvp函数

static void child(int argc, const char* const* argv) {
    // create null terminated argv_child array
    char* argv_child[argc + 1];
    memcpy(argv_child, argv, argc * sizeof(char*));
    argv_child[argc] = nullptr;
// 执行程序
    if (execvp(argv_child[0], argv_child)) {
        FATAL_CHILD("executing %s failed: %s\n", argv_child[0], strerror(errno));
    }
}

1.3 parent-处理子进程的log输出

// parent(argv[0], parent_ptty, pid, status, log_target, abbreviated, file_path, forward_signals);
// vdc,伪终端，子进程pid，status是null,LOG_ALOG，abbreviated是false，file_path是null，forward_signals是false
static int parent(const char* tag, int parent_read, pid_t pid, int* chld_sts, int log_target,
                  bool abbreviated, const char* file_path, bool forward_signals) {
    int status = 0;
    char buffer[4096];
    struct pollfd poll_fds[] = {
            {// 伪终端master设备的fd
                    .fd = parent_read,
                    .events = POLLIN,
            },
    };
    int rc = 0;
    int fd;

    struct log_info log_info;

    int a = 0;  // start index of unprocessed data
    int b = 0;  // end index of unprocessed data
    int sz;
    bool found_child = false;
    // There is a very small chance that opening child_ptty in the child will fail, but in this case
    // POLLHUP will not be generated below.  Therefore, we use a 1 second timeout for poll() until
    // we receive a message from child_ptty.  If this times out, we call waitpid() with WNOHANG to
    // check the status of the child process and exit appropriately if it has terminated.
    bool received_messages = false;
    char tmpbuf[256];
// tag为命令名字vdc（/system/bin/vdc取basename vdc）
    log_info.btag = basename(tag);
    if (!log_info.btag) {
        log_info.btag = tag;
    }
// 这里为false
    if (abbreviated && (log_target == LOG_NONE)) {
        abbreviated = 0;
    }
    if (abbreviated) {
        init_abbr_buf(&log_info.a_buf);
    }
// 这是将log打印到串口上
    if (log_target & LOG_KLOG) {
        snprintf(log_info.klog_fmt, sizeof(log_info.klog_fmt), "<6>%.*s: %%s\n", MAX_KLOG_TAG,
                 log_info.btag);
    }
// 这个file_path是将log打印到文件中
    if ((log_target & LOG_FILE) && !file_path) {
        /* No file_path specified, clear the LOG_FILE bit */
        log_target &= ~LOG_FILE;
    }

    if (log_target & LOG_FILE) {
        fd = open(file_path, O_WRONLY | O_CREAT | O_CLOEXEC, 0664);
        if (fd < 0) {
            ERROR("Cannot log to file %s\n", file_path);
            log_target &= ~LOG_FILE;
        } else {
            lseek(fd, 0, SEEK_END);
            log_info.fp = fdopen(fd, "a");
        }
    }
// log_target为LOG_ALOG
    log_info.log_target = log_target;
    log_info.abbreviated = abbreviated;
// 第一次为false
    while (!found_child) {
        // 第一次为false
        int timeout = received_messages ? -1 : 1000;
        // 等待子进程往slave设备写东西，然后父进程就可以从master设备读东西了
        if (TEMP_FAILURE_RETRY(poll(poll_fds, arraysize(poll_fds), timeout)) < 0) {
            ERROR("poll failed\n");
            rc = -1;
            goto err_poll;
        }
// 从master设备读东西
        if (poll_fds[0].revents & POLLIN) {
            received_messages = true;
            sz = TEMP_FAILURE_RETRY(read(parent_read, &buffer[b], sizeof(buffer) - 1 - b));

            sz += b;
            // Log one line at a time
            for (b = 0; b < sz; b++) {
                if (buffer[b] == ‘\r‘) {
                    if (abbreviated) {
                        /* The abbreviated logging code uses newline as
                         * the line separator.  Lucikly, the pty layer
                         * helpfully cooks the output of the command
                         * being run and inserts a CR before NL.  So
                         * I just change it to NL here when doing
                         * abbreviated logging.
                         */
                        buffer[b] = ‘\n‘;
                    } else {
                        buffer[b] = ‘\0‘;
                    }
                } else if (buffer[b] == ‘\n‘) {
                    buffer[b] = ‘\0‘;
                    // 打印log信息
                    log_line(&log_info, &buffer[a], b - a);
                    a = b + 1;
                }
            }

            if (a == 0 && b == sizeof(buffer) - 1) {
                // buffer is full, flush
                buffer[b] = ‘\0‘;
                log_line(&log_info, &buffer[a], b - a);
                b = 0;
            } else if (a != b) {
                // Keep left-overs
                b -= a;
                memmove(buffer, &buffer[a], b);
                a = 0;
            } else {
                a = 0;
                b = 0;
            }
        }

        if (!received_messages || (poll_fds[0].revents & POLLHUP)) {
            int ret;
            sigset_t oldset;

            if (forward_signals) {
                // Our signal handlers forward these signals to ‘child_pid‘, but waitpid() may reap
                // the child, so we must block these signals until we either 1) conclude that the
                // child is still running or 2) determine the child has been reaped and we have
                // reset the signals to their original disposition.
                block_signals(&oldset);
            }
// 这里说明子进程退出了
            int flags = (poll_fds[0].revents & POLLHUP) ? 0 : WNOHANG;
            ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, flags));
            if (ret < 0) {
                rc = errno;
                ALOG(LOG_ERROR, "logwrap", "waitpid failed with %s\n", strerror(errno));
                goto err_waitpid;
            }// waitpid成功了，返回子进程的pid号码
            if (ret > 0) {
                found_child = true;
            }

            if (forward_signals) {
                if (found_child) {
                    restore_signal_handlers();
                }
                unblock_signals(&oldset);
            }
        }
    }
// chld_sts为null
    if (chld_sts != nullptr) {
        *chld_sts = status;
    } else {// 指出子进程是否正常退出
        if (WIFEXITED(status))
            rc = WEXITSTATUS(status);
        else
            rc = -ECHILD;
    }

    // Flush remaining data
    if (a != b) {// 输出剩下的log
        buffer[b] = ‘\0‘;
        log_line(&log_info, &buffer[a], b - a);
    }

    /* All the output has been processed, time to dump the abbreviated output */
    if (abbreviated) {
        print_abbr_buf(&log_info);
    }
// 输出子进程退出的原因
    if (WIFEXITED(status)) {
        if (WEXITSTATUS(status)) {
            snprintf(tmpbuf, sizeof(tmpbuf), "%s terminated by exit(%d)\n", log_info.btag,
                     WEXITSTATUS(status));
            do_log_line(&log_info, tmpbuf);
        }
    } else {
        if (WIFSIGNALED(status)) {
            snprintf(tmpbuf, sizeof(tmpbuf), "%s terminated by signal %d\n", log_info.btag,
                     WTERMSIG(status));
            do_log_line(&log_info, tmpbuf);
        } else if (WIFSTOPPED(status)) {
            snprintf(tmpbuf, sizeof(tmpbuf), "%s stopped by signal %d\n", log_info.btag,
                     WSTOPSIG(status));
            do_log_line(&log_info, tmpbuf);
        }
    }

err_waitpid:
err_poll:
    if (log_target & LOG_FILE) {
        fclose(log_info.fp); /* Also closes underlying fd */
    }
    if (abbreviated) {
        free_abbr_buf(&log_info.a_buf);
    }
    return rc;
}

1.4 log_line-输出log

static void log_line(struct log_info* log_info, char* line, int len) {
    if (log_info->abbreviated) {
        add_line_to_abbr_buf(&log_info->a_buf, line, len);
    } else {
        do_log_line(log_info, line);
    }
}

1.5 do_log_line-输出log到文件，串口或者logcat上

static void do_log_line(struct log_info* log_info, const char* line) {
    // 这个是串口
    if (log_info->log_target & LOG_KLOG) {
        klog_write(6, log_info->klog_fmt, line);
    }// logcat
    if (log_info->log_target & LOG_ALOG) {
        ALOG(LOG_INFO, log_info->btag, "%s", line);
    }// 文件上
    if (log_info->log_target & LOG_FILE) {
        fprintf(log_info->fp, "%s\n", line);
    }
}

问题

补充

1. linux伪终端

伪终端是运行在用户态的软件仿真终端（图片来源：

父子进程之间通过伪终端来进行通信：子进程往slave设备写，父进程往master设备读，就可以读到子进程打印出来的log信息了

参考

1. Linux 终端(TTY)
https://www.cnblogs.com/sparkdev/p/11460821.html
2. Linux 伪终端(pty)
https://www.cnblogs.com/sparkdev/p/11605804.html

原文：https://www.cnblogs.com/pyjetson/p/14978924.html