Skip to content

S
Startup Init Lite

OpenHarmony / Startup Init Lite
接近 2 年 前同步成功

通知 3
Star 37
Fork 0
S
Startup Init Lite
“74691789e9e5ee782adb003642f66699603b20e2”上不存在“paddle/operators/mul_op.cu.cc”
提交 e08b5e82 编写于 作者: M Mupceet
浏览文件
操作

fix control fd bugs 

Signed-off-by: NMupceet <laiguizhong@huawei.com>
上级 753744ec
隐藏空白更改
内联 并排
Showing with 163 addition and 196 deletion
interfaces/innerkits/control_fd/control_fd.h 100755 → 100644
浏览文件 @ e08b5e82
......@@ -18,6 +18,9 @@
#include <stdint.h>
#include <fcntl.h>
#include <limits.h>
#include "list.h"
#include "loop_event.h"
#ifdef __cplusplus
......@@ -29,19 +32,28 @@ extern "C" {
#define INIT_CONTROL_FD_SOCKET_PATH "/dev/unix/socket/init_control_fd"
#define CONTROL_FD_FIFO_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
#define FIFO_BUF_SIZE 4096
#define FIFO_PATH_SIZE 128
#define PTY_BUF_SIZE 4096
#define PTY_PATH_SIZE 128
typedef struct CmdService_ {
TaskHandle serverTask;
struct ListNode head;
} CmdService;
typedef struct CmdAgent_ {
TaskHandle task;
WatcherHandle input; // watch stdin
WatcherHandle reader; // watch read pipe
WatcherHandle reader; // watch read pty
int ptyFd;
} CmdAgent;
typedef struct CmdTask_ {
TaskHandle task;
struct ListNode item;
int ptyFd;
pid_t pid;
} CmdTask;
typedef void (* CallbackControlFdProcess)(uint16_t type, const char *serviceCmd, const void *context);
typedef enum {
......@@ -55,14 +67,13 @@ typedef enum {
typedef struct {
uint16_t msgSize;
uint16_t type;
pid_t pid;
char fifoName[FIFO_PATH_SIZE];
char ptyName[PTY_PATH_SIZE];
char cmd[0];
} CmdMessage;
void CmdServiceInit(const char *socketPath, CallbackControlFdProcess func);
void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd, const char *fifoName);
void DestroyCmdFifo(int rfd, int wfd, const char *readPath, const char *writePath);
void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd);
void CmdServiceProcessDelClient(pid_t pid);
#ifdef __cplusplus
#if __cplusplus
......
interfaces/innerkits/control_fd/control_fd_client.c
浏览文件 @ e08b5e82
......@@ -17,9 +17,11 @@
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
#include <limits.h>
......@@ -29,76 +31,46 @@
#include "init_utils.h"
#include "securec.h"
static char g_FifoReadPath[FIFO_PATH_SIZE] = {0};
static int g_FifoReadFd = -1;
static char g_FifoWritePath[FIFO_PATH_SIZE] = {0};
static int g_FifoWriteFd = -1;
static void ProcessFifoWrite(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
static void ProcessPtyWrite(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
{
if ((fd < 0) || (events == NULL) || (context == NULL)) {
BEGET_LOGE("[control_fd] Invalid fifo write parameter");
return;
}
int fifow = *((int *)context);
if (fifow < 0) {
BEGET_LOGE("[control_fd] invalid fifo write fd");
return;
}
char rbuf[FIFO_BUF_SIZE] = {0};
int rlen = read(fd, rbuf, FIFO_BUF_SIZE - 1);
CmdAgent *agent = (CmdAgent *)context;
char rbuf[PTY_BUF_SIZE] = {0};
int rlen = read(fd, rbuf, PTY_BUF_SIZE - 1);
int ret = fflush(stdin);
BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
if (rlen > 0) {
int wlen = write(fifow, rbuf, rlen);
int wlen = write(agent->ptyFd, rbuf, rlen);
BEGET_ERROR_CHECK(wlen == rlen, return, "[control_fd] Failed write fifo err=%d", errno);
}
printf("#");
ret = fflush(stdout);
BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
*events = Event_Read;
}
static void ProcessFifoRead(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
static void ProcessPtyRead(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
{
if ((fd < 0) || (events == NULL)) {
if ((fd < 0) || (events == NULL) || (context == NULL)) {
BEGET_LOGE("[control_fd] Invalid fifo read parameter");
return;
}
char buf[FIFO_BUF_SIZE] = {0};
int readlen = read(fd, buf, FIFO_BUF_SIZE - 1);
CmdAgent *agent = (CmdAgent *)context;
char buf[PTY_BUF_SIZE] = {0};
int readlen = read(fd, buf, PTY_BUF_SIZE - 1);
if (readlen > 0) {
fprintf(stdout, "%s", buf);
} else {
DestroyCmdFifo(g_FifoReadFd, g_FifoWriteFd, g_FifoReadPath, g_FifoWritePath);
(void)close(agent->ptyFd);
return;
}
int ret = fflush(stdout);
BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
printf("#");
ret = fflush(stdout);
BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
*events = Event_Read;
}
void DestroyCmdFifo(int rfd, int wfd, const char *readPath, const char *writePath)
{
if (rfd >= 0) {
(void)close(rfd);
}
if (wfd >= 0) {
(void)close(wfd);
}
if (readPath != NULL) {
BEGET_CHECK_ONLY_ELOG(unlink(readPath) == 0, "Failed unlink fifo %s", readPath);
}
if (writePath != NULL) {
BEGET_CHECK_ONLY_ELOG(unlink(writePath) == 0, "Failed unlink fifo %s", writePath);
}
}
static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
{
BEGET_LOGI("[control_fd] CmdOnRecvMessage %s len %d.", (char *)buffer, buffLen);
......@@ -112,7 +84,11 @@ static void CmdOnConntectComplete(const TaskHandle client)
static void CmdOnClose(const TaskHandle task)
{
BEGET_LOGI("[control_fd] CmdOnClose");
DestroyCmdFifo(g_FifoReadFd, g_FifoWriteFd, g_FifoReadPath, g_FifoWritePath);
CmdAgent *agent = (CmdAgent *)LE_GetUserData(task);
BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Invalid agent");
(void)close(agent->ptyFd);
agent->ptyFd = -1;
LE_StopLoop(LE_GetDefaultLoop());
}
static void CmdDisConnectComplete(const TaskHandle client)
......@@ -120,54 +96,9 @@ static void CmdDisConnectComplete(const TaskHandle client)
BEGET_LOGI("[control_fd] CmdDisConnectComplete");
}
static void CmdAgentInit(WatcherHandle handle, const char *path, bool read, ProcessWatchEvent func)
{
if (path == NULL) {
BEGET_LOGE("[control_fd] Invalid parameter");
return;
}
BEGET_LOGI("[control_fd] client open %s", (read ? "read" : "write"));
char *realPath = GetRealPath(path);
if (realPath == NULL) {
BEGET_LOGE("[control_fd] Failed get real path %s", path);
return;
}
if (read == true) {
g_FifoReadFd = open(realPath, O_RDONLY | O_TRUNC | O_NONBLOCK);
BEGET_ERROR_CHECK(g_FifoReadFd >= 0, free(realPath); return, "[control_fd] Failed to open fifo read");
BEGET_LOGI("[control_fd] g_FifoReadFd is %d", g_FifoReadFd);
} else {
g_FifoWriteFd = open(realPath, O_WRONLY | O_TRUNC);
BEGET_ERROR_CHECK(g_FifoWriteFd >= 0, free(realPath); return, "[control_fd] Failed to open fifo write");
BEGET_LOGI("[control_fd] g_FifoWriteFd is %d", g_FifoWriteFd);
}
free(realPath);
// start watcher for stdin
LE_WatchInfo info = {};
info.flags = 0;
info.events = Event_Read;
info.processEvent = func;
if (read == true) {
info.fd = g_FifoReadFd; // read fifo0
BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &handle, &info, NULL) == LE_SUCCESS,
return, "[control_fd] Failed le_loop start watcher fifo read");
} else {
info.fd = STDIN_FILENO; // read stdin and write fifo1
BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &handle, &info, &g_FifoWriteFd) == LE_SUCCESS,
return, "[control_fd] Failed le_loop start watcher stdin");
}
return;
}
static void CmdOnSendMessageComplete(const TaskHandle task, const BufferHandle handle)
{
BEGET_LOGI("[control_fd] CmdOnSendMessageComplete");
CmdAgent *agent = (CmdAgent *)LE_GetUserData(task);
BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Invalid agent");
CmdAgentInit(agent->input, g_FifoWritePath, false, ProcessFifoWrite);
printf("#");
int ret = fflush(stdout);
BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
}
static CmdAgent *CmdAgentCreate(const char *server)
......@@ -194,85 +125,86 @@ static CmdAgent *CmdAgentCreate(const char *server)
return agent;
}
static int CreateFifo(const char *pipeName)
{
if (pipeName == NULL) {
BEGET_LOGE("[control_fd] Invalid parameter");
return -1;
}
// create fifo for cmd
CheckAndCreateDir(pipeName);
int ret = mkfifo(pipeName, CONTROL_FD_FIFO_MODE);
if (ret != 0) {
if (errno != EEXIST) {
return -1;
}
}
return 0;
}
static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd, const char *fifoName)
static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd, const char *ptyName)
{
if ((agent == NULL) || (cmd == NULL) || (fifoName == NULL)) {
if ((agent == NULL) || (cmd == NULL) || (ptyName == NULL)) {
BEGET_LOGE("[control_fd] Invalid parameter");
return -1;
}
int ret = 0;
BufferHandle handle = NULL;
uint32_t bufferSize = sizeof(CmdMessage) + strlen(cmd) + FIFO_PATH_SIZE + 1;
uint32_t bufferSize = sizeof(CmdMessage) + strlen(cmd) + PTY_PATH_SIZE + 1;
handle = LE_CreateBuffer(LE_GetDefaultLoop(), bufferSize);
char *buff = (char *)LE_GetBufferInfo(handle, NULL, NULL);
BEGET_ERROR_CHECK(buff != NULL, return -1, "[control_fd] Failed get buffer info");
CmdMessage *message = (CmdMessage *)buff;
message->msgSize = bufferSize;
message->type = type;
message->pid = getpid();
ret = strcpy_s(message->fifoName, FIFO_PATH_SIZE - 1, fifoName);
ret = strcpy_s(message->ptyName, PTY_PATH_SIZE - 1, ptyName);
BEGET_ERROR_CHECK(ret == 0, LE_FreeBuffer(LE_GetDefaultLoop(), agent->task, handle);
return -1, "[control_fd] Failed to copy fifo name %s", fifoName);
ret = strcpy_s(message->cmd, bufferSize - sizeof(CmdMessage) - FIFO_PATH_SIZE, cmd);
return -1, "[control_fd] Failed to copy pty name %s", ptyName);
ret = strcpy_s(message->cmd, bufferSize - sizeof(CmdMessage) - PTY_PATH_SIZE, cmd);
BEGET_ERROR_CHECK(ret == 0, LE_FreeBuffer(LE_GetDefaultLoop(), agent->task, handle);
return -1, "[control_fd] Failed to copy cmd %s", cmd);
ret = LE_Send(LE_GetDefaultLoop(), agent->task, handle, bufferSize);
BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed LE_Send msg type %d, pid %d, cmd %s",
message->type, message->pid, message->cmd);
BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed LE_Send msg type %d, cmd %s",
message->type, message->cmd);
return 0;
}
static int CmdMakeFifoInit(const char *fifoPath)
static int InitPtyInterface(CmdAgent *agent, uint16_t type, const char *cmd)
{
if (fifoPath == NULL) {
BEGET_LOGE("[control_fd] Invalid parameter");
if ((cmd == NULL) || (agent == NULL)) {
return -1;
}
int ret = sprintf_s(g_FifoReadPath, sizeof(g_FifoReadPath) - 1, "/dev/fifo/%s0.%d", fifoPath, getpid());
BEGET_ERROR_CHECK(ret > 0, return -1, "[control_fd] Failed sprintf_s err=%d", errno);
ret = CreateFifo(g_FifoReadPath);
BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed create fifo err=%d", errno);
ret = sprintf_s(g_FifoWritePath, sizeof(g_FifoWritePath) - 1, "/dev/fifo/%s1.%d", fifoPath, getpid());
BEGET_ERROR_CHECK(ret > 0, return -1, "[control_fd] Failed sprintf_s err=%d", errno);
ret = CreateFifo(g_FifoWritePath);
BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed create fifo err=%d", errno);
// initialize terminal
struct termios term;
int ret = tcgetattr(STDIN_FILENO, &term);
BEGET_ERROR_CHECK(ret == 0, return -1, "Failed tcgetattr stdin, err=%d", errno);
cfmakeraw(&term);
term.c_cc[VTIME] = 0;
term.c_cc[VMIN] = 1;
ret = tcsetattr(STDIN_FILENO, TCSANOW, &term);
BEGET_ERROR_CHECK(ret == 0, return -1, "Failed tcsetattr term, err=%d", errno);
// open master pty and get slave pty
int pfd = open("/dev/ptmx", O_RDWR | O_CLOEXEC);
BEGET_ERROR_CHECK(pfd >= 0, return -1, "Failed open pty err=%d", errno);
BEGET_ERROR_CHECK(grantpt(pfd) >= 0, close(pfd); return -1, "Failed to call grantpt");
BEGET_ERROR_CHECK(unlockpt(pfd) >= 0, close(pfd); return -1, "Failed to call unlockpt");
char ptsbuffer[PTY_PATH_SIZE] = {0};
ret = ptsname_r(pfd, ptsbuffer, sizeof(ptsbuffer));
BEGET_ERROR_CHECK(ret >= 0, close(pfd); return -1, "Failed to get pts name err=%d", errno);
BEGET_LOGI("ptsbuffer is %s", ptsbuffer);
agent->ptyFd = pfd;
LE_WatchInfo info = {};
info.flags = 0;
info.events = Event_Read;
info.processEvent = ProcessPtyRead;
info.fd = pfd; // read ptmx
BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &agent->reader, &info, agent) == LE_SUCCESS,
close(pfd); return -1, "[control_fd] Failed le_loop start watcher ptmx read");
info.processEvent = ProcessPtyWrite;
info.fd = STDIN_FILENO; // read stdin and write ptmx
BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &agent->input, &info, agent) == LE_SUCCESS,
close(pfd); return -1, "[control_fd] Failed le_loop start watcher stdin read and write ptmx");
ret = SendCmdMessage(agent, type, cmd, ptsbuffer);
BEGET_ERROR_CHECK(ret == 0, close(pfd); return -1, "[control_fd] Failed send message");
return 0;
}
void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd, const char *fifoName)
void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd)
{
if ((socketPath == NULL) || (cmd == NULL)) {
BEGET_LOGE("[control_fd] Invalid parameter");
}
BEGET_LOGI("[control_fd] CmdAgentInit");
int ret = CmdMakeFifoInit(fifoName);
BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed init fifo");
CmdAgent *agent = CmdAgentCreate(socketPath);
BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Failed to create agent");
CmdAgentInit(agent->reader, g_FifoReadPath, true, ProcessFifoRead);
ret = SendCmdMessage(agent, type, cmd, fifoName);
BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed send message");
int ret = InitPtyInterface(agent, type, cmd);
if (ret != 0) {
return;
}
LE_RunLoop(LE_GetDefaultLoop());
BEGET_LOGI("Cmd Client exit ");
LE_CloseStreamTask(LE_GetDefaultLoop(), agent->task);
free(agent);
DestroyCmdFifo(g_FifoReadFd, g_FifoWriteFd, g_FifoReadPath, g_FifoWritePath);
}
interfaces/innerkits/control_fd/control_fd_service.c 100755 → 100644
浏览文件 @ e08b5e82
......@@ -15,7 +15,9 @@
#include <fcntl.h>
#include <limits.h>
#include <stdbool.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <termios.h>
#include <unistd.h>
#include "beget_ext.h"
......@@ -27,20 +29,12 @@ static CmdService g_cmdService;
CallbackControlFdProcess g_controlFdFunc = NULL;
static int ReadFifoPath(const char *name, bool read, pid_t pid, char *resolvedPath)
static void OnClose(const TaskHandle task)
{
if ((name == NULL) || (pid < 0) || resolvedPath == NULL) {
return -1;
}
int flag = read ? 1 : 0;
char path[PATH_MAX] = {0};
int ret = sprintf_s(path, sizeof(path) - 1, "/dev/fifo/%s%d.%d", name, flag, pid);
BEGET_ERROR_CHECK(ret > 0, return -1, "[control_fd] Failed sprintf_s err=%d", errno);
char *realPath = realpath(path, resolvedPath);
BEGET_ERROR_CHECK(realPath != NULL, return -1, "[control_fd] Failed get real path %s, err=%d", path, errno);
int flags = read ? (O_RDONLY | O_TRUNC | O_NONBLOCK) : (O_WRONLY | O_TRUNC);
int fd = open(resolvedPath, flags);
return fd;
CmdTask *agent = (CmdTask *)LE_GetUserData(task);
BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Can not get agent");
OH_ListRemove(&agent->item);
OH_ListInit(&agent->item);
}
static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
......@@ -48,33 +42,35 @@ static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint3
if (buffer == NULL) {
return;
}
CmdTask *agent = (CmdTask *)LE_GetUserData(task);
BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Can not get agent");
// parse msg to exec
CmdMessage *msg = (CmdMessage *)buffer;
if ((msg->type < 0) || (msg->type >= ACTION_MAX) || (msg->cmd[0] == '\0') || (msg->fifoName[0] == '\0')) {
BEGET_LOGE("[control_fd] Failed msg ");
if ((msg->type < 0) || (msg->type >= ACTION_MAX) || (msg->cmd[0] == '\0') || (msg->ptyName[0] == '\0')) {
BEGET_LOGE("[control_fd] Received msg is invaild");
return;
}
char readPath[PATH_MAX] = {0};
int reader = ReadFifoPath(msg->fifoName, true, msg->pid, readPath); // read
BEGET_ERROR_CHECK(reader > 0, return, "[control_fd] Failed to open fifo read, err=%d", errno);
char writePath[PATH_MAX] = {0};
int writer = ReadFifoPath(msg->fifoName, false, msg->pid, writePath); // write
BEGET_ERROR_CHECK(writer > 0, return, "[control_fd] Failed to open fifo write, err=%d", errno);
pid_t pid = fork();
if (pid == 0) {
(void)dup2(reader, STDIN_FILENO);
(void)dup2(writer, STDOUT_FILENO);
(void)dup2(writer, STDERR_FILENO); // Redirect fd to 0, 1, 2
(void)close(reader);
(void)close(writer);
agent->pid = fork();
if (agent->pid == 0) {
OpenConsole();
char *realPath = GetRealPath(msg->ptyName);
BEGET_ERROR_CHECK(realPath != NULL, return, "Failed get realpath, err=%d", errno);
char *strl = strstr(realPath, "/dev/pts");
BEGET_ERROR_CHECK(strl != NULL, return, "pty slave path %s is invaild", realPath);
int fd = open(realPath, O_RDWR);
free(realPath);
BEGET_ERROR_CHECK(fd >= 0, return, "Failed open %s, err=%d", realPath, errno);
(void)dup2(fd, STDIN_FILENO);
(void)dup2(fd, STDOUT_FILENO);
(void)dup2(fd, STDERR_FILENO); // Redirect fd to 0, 1, 2
(void)close(fd);
g_controlFdFunc(msg->type, msg->cmd, NULL);
exit(0);
} else if (pid < 0) {
} else if (agent->pid < 0) {
BEGET_LOGE("[control_fd] Failed fork service");
}
DestroyCmdFifo(reader, writer, readPath, writePath);
return;
}
......@@ -102,18 +98,20 @@ static int CmdOnIncommingConntect(const LoopHandle loop, const TaskHandle server
TaskHandle client = NULL;
LE_StreamInfo info = {};
info.baseInfo.flags = TASK_STREAM | TASK_PIPE | TASK_CONNECT;
info.baseInfo.close = NULL;
info.baseInfo.userDataSize = sizeof(CmdAgent);
info.baseInfo.close = OnClose;
info.baseInfo.userDataSize = sizeof(CmdTask);
info.disConntectComplete = NULL;
info.sendMessageComplete = NULL;
info.recvMessage = CmdOnRecvMessage;
int ret = LE_AcceptStreamClient(LE_GetDefaultLoop(), server, &client, &info);
BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed accept stream")
CmdAgent *agent = (CmdAgent *)LE_GetUserData(client);
CmdTask *agent = (CmdTask *)LE_GetUserData(client);
BEGET_ERROR_CHECK(agent != NULL, return -1, "[control_fd] Invalid agent");
agent->task = client;
OH_ListInit(&agent->item);
ret = SendMessage(LE_GetDefaultLoop(), agent->task, "connect success.");
BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed send msg");
OH_ListAddTail(&g_cmdService.head, &agent->item);
return 0;
}
......@@ -123,6 +121,7 @@ void CmdServiceInit(const char *socketPath, CallbackControlFdProcess func)
BEGET_LOGE("[control_fd] Invalid parameter");
return;
}
OH_ListInit(&g_cmdService.head);
LE_StreamServerInfo info = {};
info.baseInfo.flags = TASK_STREAM | TASK_SERVER | TASK_PIPE;
info.server = (char *)socketPath;
......@@ -135,3 +134,21 @@ void CmdServiceInit(const char *socketPath, CallbackControlFdProcess func)
g_controlFdFunc = func;
(void)LE_CreateStreamServer(LE_GetDefaultLoop(), &g_cmdService.serverTask, &info);
}
static int ClientTraversalProc(ListNode *node, void *data)
{
CmdTask *info = ListEntry(node, CmdTask, item);
int pid = *(int *)data;
return pid - info->pid;
}
void CmdServiceProcessDelClient(pid_t pid)
{
ListNode *node = OH_ListFind(&g_cmdService.head, (void *)&pid, ClientTraversalProc);
if (node != NULL) {
CmdTask *agent = ListEntry(node, CmdTask, item);
OH_ListRemove(&agent->item);
OH_ListInit(&agent->item);
LE_CloseTask(LE_GetDefaultLoop(), agent->task);
}
}
services/begetctl/dump_service.c
浏览文件 @ e08b5e82
......@@ -29,7 +29,7 @@ static int main_cmd(BShellHandle shell, int argc, char **argv)
}
if (strcmp(argv[0], "dump_service") == 0) {
printf("dump service info \n");
CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_DUMP, argv[1], "FIFO");
CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_DUMP, argv[1]);
} else {
BShellCmdHelp(shell, argc, argv);
}
......
services/begetctl/modulectl.c 100755 → 100644
浏览文件 @ e08b5e82
......@@ -45,7 +45,7 @@ static int ModuleDisplayCmd(BShellHandle shell, int argc, char **argv)
BShellCmdHelp(shell, argc, argv);
return 0;
}
CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_MODULEMGR, argv[0], "FIFO");
CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_MODULEMGR, argv[0]);
return 0;
}
......
services/begetctl/sandbox.cpp
浏览文件 @ e08b5e82
......@@ -128,7 +128,7 @@ static void RunCmd(const std::string &serviceName, const std::string &namespaceN
EnterExec(processName);
} else if (namespaceName.empty() && processName.empty() && !serviceName.empty()) {
std::cout << "enter sandbox service name " << serviceName << std::endl;
CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_SANDBOX, serviceName.c_str(), "FIFO");
CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_SANDBOX, serviceName.c_str());
} else {
Usage();
}
......
services/include/init_utils.h
浏览文件 @ e08b5e82
......@@ -75,6 +75,7 @@ int StringReplaceChr(char *strl, char oldChr, char newChr);
int GetMapValue(const char *name, const InitArgInfo *infos, int argNum, int defValue);
const InitArgInfo *GetServieStatusMap(int *size);
uint32_t GetRandom(void);
void OpenConsole(void);
#ifdef __cplusplus
#if __cplusplus
}
......
services/init/init_common_service.c
浏览文件 @ e08b5e82
......@@ -117,24 +117,6 @@ static int SetPerms(const Service *service)
return SERVICE_SUCCESS;
}
static void OpenConsole(void)
{
const int stdError = 2;
setsid();
WaitForFile("/dev/console", WAIT_MAX_SECOND);
int fd = open("/dev/console", O_RDWR);
if (fd >= 0) {
ioctl(fd, TIOCSCTTY, 0);
dup2(fd, 0);
dup2(fd, 1);
dup2(fd, stdError); // Redirect fd to 0, 1, 2
close(fd);
} else {
INIT_LOGE("Open /dev/console failed. err = %d", errno);
}
return;
}
static int WritePid(const Service *service)
{
const int maxPidStrLen = 50;
......
services/init/standard/init_signal_handler.c
浏览文件 @ e08b5e82
......@@ -15,6 +15,7 @@
#include <signal.h>
#include <sys/wait.h>
#include "control_fd.h"
#include "init_adapter.h"
#include "init_log.h"
#include "init_param.h"
......@@ -41,6 +42,7 @@ static void ProcessSignal(const struct signalfd_siginfo *siginfo)
if (WIFEXITED(procStat)) {
INIT_LOGE("Child process %d exit with code : %d", sigPID, WEXITSTATUS(procStat));
}
CmdServiceProcessDelClient(sigPID);
Service* service = GetServiceByPid(sigPID);
INIT_LOGI("SigHandler, SIGCHLD received, Service:%s pid:%d uid:%d status:%d.",
service == NULL ? "Unknown" : service->name,
......
services/utils/init_utils.c
浏览文件 @ e08b5e82
......@@ -23,6 +23,7 @@
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
......@@ -555,3 +556,23 @@ uint32_t GetRandom()
close(fd);
return ulSeed;
}
void OpenConsole(void)
{
#ifndef __LITEOS_M__
const int stdError = 2;
setsid();
WaitForFile("/dev/console", WAIT_MAX_SECOND);
int fd = open("/dev/console", O_RDWR);
if (fd >= 0) {
ioctl(fd, TIOCSCTTY, 0);
dup2(fd, 0);
dup2(fd, 1);
dup2(fd, stdError); // Redirect fd to 0, 1, 2
close(fd);
} else {
INIT_LOGE("Open /dev/console failed. err = %d", errno);
}
return;
#endif
}
test/unittest/BUILD.gn
浏览文件 @ e08b5e82
......@@ -163,6 +163,7 @@ ohos_unittest("init_unittest") {
"//base/startup/init_lite/interfaces/innerkits/include/syspara",
"//base/startup/init_lite/interfaces/innerkits/fd_holder",
"//base/startup/init_lite/interfaces/innerkits/syspara",
"//base/startup/init_lite/interfaces/innerkits/control_fd",
"//base/startup/init_lite/services/begetctl",
"//base/startup/init_lite/services/begetctl/shell",
"//base/startup/init_lite/services/include",
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或