35#ifdef LOSCFG_FILE_MODE
40#ifdef LOSCFG_SHELL_DMESG
54#define UART_IOC_MAGIC 'u'
55#define UART_CFG_ATTR _IOW(UART_IOC_MAGIC, 5, int)
56#define UART_CFG_PRIVATE _IOW(UART_IOC_MAGIC, 6, int)
72#define SHELL_ENTRYID_INVALID 0xFFFFFFFF
73#define SHELL_TASK_PRIORITY 9
74#define CONSOLE_CIRBUF_EVENT 0x02U
75#define CONSOLE_SEND_TASK_EXIT 0x04U
76#define CONSOLE_SEND_TASK_RUNNING 0x10U
78#define SHELL_ENTRY_NAME "ShellEntry"
79#define SHELL_ENTRY_NAME_LEN 10
81#define MIN(a, b) ((a) < (b) ? (a) : (b))
97 if ((filep == NULL) || (filep->f_vnode == NULL) || (filep->f_vnode->data == NULL)) {
103 struct drv_data *drv = (
struct drv_data *)filep->f_vnode->data;
104 *privFilep = (
struct file *)drv->priv;
105 if (((*privFilep)->f_vnode == NULL) || ((*privFilep)->f_vnode->data == NULL)) {
112 drv = (
struct drv_data *)(*privFilep)->f_vnode->data;
114 *filepOps = (
const struct file_operations_vfs *)drv->ops;
124 struct file *filep = NULL;
127 INT32 ret = fs_getfilep(fd, &filep);
133 if (consoleCB == NULL) {
137 (VOID)memcpy_s(termios,
sizeof(
struct termios), &consoleCB->
consoleTermios,
sizeof(
struct termios));
143 struct file *filep = NULL;
148 INT32 ret = fs_getfilep(fd, &filep);
154 if (consoleCB == NULL) {
158 (VOID)memcpy_s(&consoleCB->
consoleTermios,
sizeof(
struct termios), termios,
sizeof(
struct termios));
169 (consoleCB->
refCount) += flag ? 1 : -1;
180 struct termios consoleTermios = {0};
185 consoleTermios.c_lflag |= ICANON | ECHO;
194 struct termios consoleTermios = {0};
199 consoleTermios.c_lflag &= ~(ICANON | ECHO);
222 PRINT_ERR(
"console is free\n");
239 struct Vnode *vnode = NULL;
249 if (
g_console[CONSOLE_SERIAL - 1]->devVnode == vnode) {
251 }
else if (
g_console[CONSOLE_TELNET - 1]->devVnode == vnode) {
261 if ((deviceName != NULL) &&
262 (strlen(deviceName) == strlen(SERIAL)) &&
263 (!strncmp(deviceName, SERIAL, strlen(SERIAL)))) {
264 return CONSOLE_SERIAL;
266#ifdef LOSCFG_NET_TELNET
267 else if ((deviceName != NULL) &&
268 (strlen(deviceName) == strlen(TELNET)) &&
269 (!strncmp(deviceName, TELNET, strlen(TELNET)))) {
270 return CONSOLE_TELNET;
278#define CONSOLE_SERIAL_1 "/dev/console1"
279#define CONSOLE_TELNET_2 "/dev/console2"
283 if (fullpath == NULL) {
287 len = strlen(fullpath);
288 if ((len == strlen(CONSOLE_SERIAL_1)) &&
289 (!strncmp(fullpath, CONSOLE_SERIAL_1, strlen(CONSOLE_SERIAL_1)))) {
290 return CONSOLE_SERIAL;
292#ifdef LOSCFG_NET_TELNET
293 else if ((len == strlen(CONSOLE_TELNET_2)) &&
294 (!strncmp(fullpath, CONSOLE_TELNET_2, strlen(CONSOLE_TELNET_2)))) {
295 return CONSOLE_TELNET;
310 (VOID)memset_s(console->
fifo, CONSOLE_FIFO_SIZE, 0, CONSOLE_FIFO_SIZE);
324 ret = memcpy_s(buffer, bufLen, console->
fifo + console->
fifoOut, readNum);
326 PRINTK(
"%s,%d memcpy_s failed\n", __FUNCTION__, __LINE__);
334 return (
INT32)readNum;
340 if (fops->open == NULL) {
348 ret = fops->open(filep);
349 return (ret < 0) ? -EPERM : ret;
354 const struct file_operations_vfs *fops)
359 (VOID)fops->write(filep, &ch, 1);
378 }
else if (ch == 0x5b) {
383 }
else if (ch == 0x41) {
388 }
else if (ch == 0x42) {
393 }
else if (ch == 0x43) {
398 }
else if (ch == 0x44) {
421 (VOID)fops->write(filep,
"\b \b", 3);
423 (VOID)fops->write(filep, &ch, EACH_CHAR);
430 if ((readcount == EACH_CHAR) && (consoleCB->
fifoIn <= (CONSOLE_FIFO_SIZE - 3))) {
444 if ((consoleId > CONSOLE_NUM) || (consoleId <= 0)) {
449 if (consoleCB->
pgrpId < 0) {
456 CHAR *buffer,
size_t bufLen)
459 INT32 needreturn = LOS_NOK;
463 if (fops->read == NULL) {
469 ret = fops->read(filep, buffer, bufLen);
470 return (ret < 0) ? -EPERM : ret;
482 ret = fops->read(filep, &ch, EACH_CHAR);
506 if (needreturn == LOS_OK)
520 if (fops->read == NULL) {
528 ret = fops->read(filep, buffer, bufLen);
529 return (ret < 0) ? -EPERM : ret;
536 if (fops->write == NULL) {
540 ret = fops->write(filep, buffer, bufLen);
541 return (ret < 0) ? -EPERM : ret;
548 if ((fops == NULL) || (fops->close == NULL)) {
556 ret = fops->close(filep);
557 return ret < 0 ? -EPERM : ret;
563 if (fops->ioctl == NULL) {
567 ret = fops->ioctl(filep, cmd, arg);
568 return (ret < 0) ? -EPERM : ret;
574 if (fops->poll == NULL) {
582 ret = fops->poll(filep, fds);
583 return (ret < 0) ? -EPERM : ret;
591 struct file *privFilep = NULL;
592 const struct file_operations_vfs *fileOps = NULL;
595 if (consoleID == (
UINT32)-1) {
621 struct file *privFilep = NULL;
622 const struct file_operations_vfs *fileOps = NULL;
643 struct file *privFilep,
644 const struct file_operations_vfs *fileOps)
650 ret =
FilepRead(privFilep, fileOps, buffer, bufLen);
654 ret =
UserFilepRead(consoleCB, privFilep, fileOps, buffer, bufLen);
666 struct file *privFilep = NULL;
668 CHAR *sbuffer = NULL;
669 BOOL userBuf = FALSE;
670 const struct file_operations_vfs *fileOps = NULL;
672 if ((buffer == NULL) || (bufLen == 0)) {
677 if (bufLen > CONSOLE_FIFO_SIZE) {
678 bufLen = CONSOLE_FIFO_SIZE;
688 if (consoleCB == NULL) {
690 if (consoleCB == NULL) {
700 if (sbuffer == NULL) {
705 ret =
DoRead(consoleCB, sbuffer, bufLen, privFilep, fileOps);
722 if ((userBuf) && (sbuffer != NULL)) {
733 size_t toWrite = bufLen;
736#ifdef LOSCFG_SHELL_DMESG
744 while (written < (
INT32)bufLen) {
746 if ((buffer[written] ==
'\n') || (buffer[written] ==
'\r')) {
770 CHAR *sbuffer = NULL;
771 BOOL userBuf = FALSE;
773 struct file *privFilep = NULL;
774 const struct file_operations_vfs *fileOps = NULL;
776 if ((buffer == NULL) || (bufLen == 0)) {
781 if (bufLen > CONSOLE_FIFO_SIZE) {
782 bufLen = CONSOLE_FIFO_SIZE;
788 if ((ret != ENOERR) || (fileOps->write == NULL) || (filep->
f_priv == NULL)) {
800 if (sbuffer == NULL) {
809 ret =
DoWrite(cirBufSendCB, sbuffer, bufLen);
818 if (userBuf && sbuffer != NULL) {
828 struct termios kerTermios;
841#define DEFAULT_WINDOW_SIZE_COL 80
842#define DEFAULT_WINDOW_SIZE_ROW 24
845 struct winsize kws = {
846 .ws_col = DEFAULT_WINDOW_SIZE_COL,
847 .ws_row = DEFAULT_WINDOW_SIZE_ROW
850 return (
LOS_CopyFromKernel((VOID *)arg,
sizeof(
struct winsize), &kws,
sizeof(
struct winsize)) != 0) ?
856 struct file *filep = NULL;
859 INT32 ret = fs_getfilep(0, &filep);
865 if (consoleCB == NULL) {
890 struct file *privFilep = NULL;
892 const struct file_operations_vfs *fileOps = NULL;
900 if (fileOps->ioctl == NULL) {
906 if (consoleCB == NULL) {
912 case CONSOLE_CONTROL_RIGHTS_CAPTURE:
915 case CONSOLE_CONTROL_RIGHTS_RELEASE:
918 case CONSOLE_CONTROL_CAPTURE_LINE:
921 case CONSOLE_CONTROL_CAPTURE_CHAR:
924 case CONSOLE_CONTROL_REG_USERTASK:
943 if ((cmd == UART_CFG_ATTR || cmd == UART_CFG_PRIVATE)
948 ret = fileOps->ioctl(privFilep, cmd, arg);
966 struct file *privFilep = NULL;
967 const struct file_operations_vfs *fileOps = NULL;
975 ret =
FilepPoll(privFilep, fileOps, fds);
996#ifndef CONFIG_DISABLE_POLL
1010 struct termios consoleTermios = {0};
1013 if ((deviceName != NULL) &&
1014 (strlen(deviceName) == strlen(SERIAL)) &&
1015 (!strncmp(deviceName, SERIAL, strlen(SERIAL)))) {
1020 consoleTermios.c_lflag |= ICANON | ECHO;
1021 consoleTermios.c_cc[VINTR] = 3;
1024#ifdef LOSCFG_NET_TELNET
1025 else if ((deviceName != NULL) &&
1026 (strlen(deviceName) == strlen(TELNET)) &&
1027 (!strncmp(deviceName, TELNET, strlen(TELNET)))) {
1031 consoleTermios.c_lflag |= ICANON | ECHO;
1032 consoleTermios.c_cc[VINTR] = 3;
1041 struct Vnode *vnode = NULL;
1042 struct file *filep = NULL;
1046 if (ret != LOS_OK) {
1051 filep = files_allocate(vnode, O_RDWR, 0, consoleCB, FILE_START_FD);
1052 if (filep == NULL) {
1056 filep->ops = (
struct file_operations_vfs *)((
struct drv_data *)vnode->
data)->ops;
1057 consoleCB->
fd = filep->fd;
1071 struct file *filep = NULL;
1072 struct Vnode *vnode = NULL;
1073 struct file_operations_vfs *devOps = NULL;
1077 if (filep == NULL) {
1085 if (ret != LOS_OK) {
1087 PRINTK(
"!! can not find %s\n", consoleCB->
name);
1103 (VOID)memset_s(filep,
sizeof(
struct file), 0,
sizeof(
struct file));
1106 filep->f_vnode = vnode;
1114 devOps = (
struct file_operations_vfs *)((
struct drv_data*)vnode->
data)->ops;
1115 if (devOps != NULL && devOps->open != NULL) {
1116 (VOID)devOps->open(filep);
1123 if (ret != LOS_OK) {
1140 return unregister_driver(consoleCB->
name);
1152 if (cirBufSendCB == NULL) {
1159 goto ERROR_WITH_SENDCB;
1161 (VOID)memset_s(fifo, CONSOLE_CIRCBUF_SIZE, 0, CONSOLE_CIRCBUF_SIZE);
1163 cirBufCB = &cirBufSendCB->
cirBufCB;
1165 if (ret != LOS_OK) {
1166 goto ERROR_WITH_FIFO;
1170 return cirBufSendCB;
1202 initParam.
uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
1203 initParam.
pcName = (consoleCB->
consoleID == CONSOLE_SERIAL) ?
"SendToSer" :
"SendToTelnet";
1204 initParam.
uwResved = LOS_TASK_STATUS_DETACHED;
1207 if (ret != LOS_OK) {
1213 LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
1229 if (consoleCB == NULL) {
1238 if (consoleCB->
name == NULL) {
1239 PRINT_ERR(
"consoleCB->name malloc failed\n");
1249 consoleCB->
name = NULL;
1257 if (consoleCB == NULL) {
1258 PRINT_ERR(
"console malloc error.\n");
1262 ret = snprintf_s(consoleCB->
name, CONSOLE_NAMELEN, CONSOLE_NAMELEN - 1,
1265 PRINT_ERR(
"consoleCB->name snprintf_s failed\n");
1270 if (ret != LOS_OK) {
1271 PRINT_ERR(
"console OsConsoleBufInit error. %d\n", ret);
1276 if (ret != LOS_OK) {
1277 PRINT_ERR(
"creat sem for uart failed\n");
1282 if (ret != LOS_OK) {
1283 PRINT_ERR(
"console OsConsoleDevInit error. %d\n", ret);
1288 if (ret != LOS_OK) {
1289 PRINT_ERR(
"console OsConsoleFileInit error. %d\n", ret);
1298 if (ret != LOS_OK) {
1299 PRINT_ERR(
"OsConsoleDevDeinit failed!\n");
1314 (VOID)files_close(consoleCB->
fd);
1316 if (ret != LOS_OK) {
1317 PRINT_ERR(
"OsConsoleDevDeinit failed!\n");
1322 consoleCB->
name = NULL;
1339 if (consoleID == -1) {
1340 PRINT_ERR(
"device is full.\n");
1345 if (consoleCB == NULL) {
1346 PRINT_ERR(
"%s, %d\n", __FUNCTION__, __LINE__);
1359 if (ret != LOS_OK) {
1360 PRINT_ERR(
"%s, %d\n", __FUNCTION__, __LINE__);
1384 if (consoleCB == NULL) {
1407 if (ret != LOS_OK) {
1408 PRINT_ERR(
"%s, Failed to system_console_deinit\n", __FUNCTION__);
1427 if (consoleID == 0) {
1429 }
else if ((consoleID == CONSOLE_TELNET) || (consoleID == CONSOLE_SERIAL)) {
1432#if defined (LOSCFG_DRIVERS_USB_SERIAL_GADGET) || defined (LOSCFG_DRIVERS_USB_ETH_SER_GADGET)
1433 else if ((
SerialTypeGet() == SERIAL_TYPE_USBTTY_DEV) && (userial_mask_get() == 1)) {
1445 if (shellEntryId == SHELL_ENTRYID_INVALID) {
1450 (strlen(taskCB->
taskName) == SHELL_ENTRY_NAME_LEN &&
1451 strncmp(taskCB->
taskName, SHELL_ENTRY_NAME, SHELL_ENTRY_NAME_LEN) == 0);
1466 return (
g_console[consoleID - 1]->shellEntryId == taskID) ? LOS_OK : LOS_NOK;
1471 if (consoleCB == NULL) {
1472 PRINT_ERR(
"%s: Input parameter is illegal\n", __FUNCTION__);
1475 return ioctl(consoleCB->
fd, CONSOLE_CMD_RD_BLOCK_SERIAL, CONSOLE_RD_NONBLOCK) == 0;
1481 if (consoleCB == NULL) {
1482 PRINT_ERR(
"%s: Input parameter is illegal\n", __FUNCTION__);
1485 return ioctl(consoleCB->
fd, CONSOLE_CMD_RD_BLOCK_SERIAL, CONSOLE_RD_BLOCK) != 0;
1491 if (consoleCB == NULL) {
1492 PRINT_ERR(
"%s: Input parameter is illegal\n", __FUNCTION__);
1495 return ioctl(consoleCB->
fd, CONSOLE_CMD_RD_BLOCK_TELNET, CONSOLE_RD_NONBLOCK) == 0;
1501 if (consoleCB == NULL) {
1502 PRINT_ERR(
"%s: Input parameter is illegal\n", __FUNCTION__);
1505 return ioctl(consoleCB->
fd, CONSOLE_CMD_RD_BLOCK_TELNET, CONSOLE_RD_BLOCK) != 0;
1510 if (consoleCB == NULL) {
1511 PRINT_ERR(
"%s: Input parameter is illegal\n", __FUNCTION__);
1528 if (
g_console[CONSOLE_TELNET - 1] != NULL) {
1529 consoleID = CONSOLE_TELNET;
1531 }
else if (consoleID == 0) {
1532 if (
g_console[CONSOLE_SERIAL - 1] != NULL) {
1533 consoleID = CONSOLE_SERIAL;
1534 }
else if (
g_console[CONSOLE_TELNET - 1] != NULL) {
1535 consoleID = CONSOLE_TELNET;
1537 PRINTK(
"No console dev used.\n");
1548 if (consoleID != CONSOLE_TELNET) {
1549 consoleID = CONSOLE_SERIAL;
1563 if ((newTaskID >= LOSCFG_BASE_CORE_TSK_LIMIT) || (curTaskID >= LOSCFG_BASE_CORE_TSK_LIMIT)) {
1574 struct file *privFilep = NULL;
1575 struct file *filep = NULL;
1576 const struct file_operations_vfs *fileOps = NULL;
1579 ret = fs_getfilep(fd, &filep);
1582 if ((fileOps == NULL) || (fileOps->write == NULL)) {
1586 (VOID)fileOps->write(privFilep, buffer, bufLen);
1607 LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
1608 if (ret == CONSOLE_CIRBUF_EVENT) {
1617 (VOID)memset_s(buf, size + 1, 0, size + 1);
1623 }
else if (ret == CONSOLE_SEND_TASK_EXIT) {
1632#ifdef LOSCFG_KERNEL_SMP
1638 INT32 waitTime = 3000;
1640 for (i = 0; i < CONSOLE_NUM; i++) {
1642 if (console == NULL) {
1646 if (OS_TID_CHECK_INVALID(console->
sendTaskID)) {
1650 taskCB = OS_TCB_FROM_TID(console->
sendTaskID);
1651 while ((waitTime > 0) && (taskCB->
taskEvent == NULL) && (taskID != console->
sendTaskID)) {
1663 for (i = 0; i < CONSOLE_NUM; i++) {
1665 if (console == NULL) {
unsigned int OsShellInit(void)
int OsShellDeinit(ShellCB *shellCB)
STATIC CONSOLE_CB * OsGetConsoleByDevice(const CHAR *deviceName)
BOOL SetTelnetNonBlock(const CONSOLE_CB *consoleCB)
无锁方式设置远程登录
STATIC const struct file_operations_vfs g_consoleDevOps
STATIC UINT8 g_taskConsoleIDArray[LOSCFG_BASE_CORE_TSK_LIMIT]
task 控制台ID池,同步task数量,理论上每个task都可以有一个自己的控制台
INT32 ConsoleTcSetAttr(INT32 fd, INT32 actions, const struct termios *termios)
设置控制台 模式值
INT32 FilepOpen(struct file *filep, const struct file_operations_vfs *fops)
打开串口或远程登录
STATIC UINT32 ConsoleRefcountGet(const CONSOLE_CB *consoleCB)
STATIC UINT32 OsConsoleDelete(CONSOLE_CB *consoleCB)
删除控制台
STATIC VOID ConsoleCirBufDelete(CirBufSendCB *cirBufSendCB)
删除循环buf
STATIC INT32 UserShellCheckUDRL(const CHAR ch, INT32 *lastTokenType)
用户shell检查上下左右键
VOID KillPgrp(UINT16 consoleId)
杀死进程组
STATIC UINT32 OsConsoleBufInit(CONSOLE_CB *consoleCB)
控制台缓存初始化,创建一个 发送任务
INT32 GetFilepOps(const struct file *filep, struct file **privFilep, const struct file_operations_vfs **filepOps)
STATIC VOID StoreReadChar(CONSOLE_CB *consoleCB, char ch, INT32 readcount)
存储读取的字符
STATIC VOID EchoToTerminal(CONSOLE_CB *consoleCB, struct file *filep, const struct file_operations_vfs *fops, char ch)
输出到终端
INT32 ConsoleTaskReg(INT32 consoleID, UINT32 taskID)
任务注册控制台,每个shell任务都有属于自己的控制台
STATIC INT32 ConsoleSetSW(CONSOLE_CB *consoleCB, unsigned long arg)
STATIC VOID OsConsoleCBDeinit(CONSOLE_CB *consoleCB)
释放控制台描述符初始化时所占用的内核空间
STATIC VOID OsConsoleBufDeinit(CONSOLE_CB *consoleCB)
控制台buf去初始化
STATIC CirBufSendCB * ConsoleCirBufCreate(VOID)
创建一个控制台循环buf
STATIC INT32 IsNeedContinue(CONSOLE_CB *consoleCB, char ch, INT32 *lastTokenType)
是否需要继续
STATIC INT32 OsConsoleFullpathToID(const CHAR *fullpath)
通过路径找到控制台ID
BOOL is_nonblock(const CONSOLE_CB *consoleCB)
STATIC INT32 OsGetConsoleID(const CHAR *deviceName)
获取控制台ID,(/dev/console1 = SERIAL, /dev/console2 = telnet)
VOID OsWakeConsoleSendTask(VOID)
唤醒控制台发送任务
STATIC INT32 ConsoleReadFifo(CHAR *buffer, CONSOLE_CB *console, size_t bufLen)
读取
STATIC VOID ConsoleFifoClearup(CONSOLE_CB *console)
STATIC INT32 UserFilepRead(CONSOLE_CB *consoleCB, struct file *filep, const struct file_operations_vfs *fops, CHAR *buffer, size_t bufLen)
使用参数buffer将控制台的buf接走
STATIC ssize_t ConsoleRead(struct file *filep, CHAR *buffer, size_t bufLen)
任务从控制台读数据,例如 Shell Entry 任务会从此读数据
STATIC VOID ConsoleRefcountSet(CONSOLE_CB *consoleCB, BOOL flag)
设置控制台引用次数,也表示占用控制台的数量
STATIC UINT32 ConsoleSendTask(UINTPTR param)
控制台发送任务
INT32 ConsoleUpdateFd(VOID)
控制台更新文件句柄
STATIC ssize_t ConsoleWrite(struct file *filep, const CHAR *buffer, size_t bufLen)
用户任务写数据到控制台
STATIC INT32 ConsoleOpen(struct file *filep)
对 file_operations_vfs->open 的实现函数,也就是说这是 打开控制台的实体函数.
INT32 system_console_deinit(const CHAR *deviceName)
控制台结束前的处理 和 system_console_init成对出现,像控制台的析构函数
@ STAT_ESC_KEY
控制按键,只有 ESC 是
@ STAT_MULTI_KEY
多个按键,只有 [ 是
BOOL SetSerialBlock(const CONSOLE_CB *consoleCB)
锁方式设置串口
STATIC INT32 ConsoleCtrlCaptureChar(CONSOLE_CB *consoleCB)
铺捉到 ctrl + 右方向键(>)
STATIC VOID OsConsoleTermiosInit(CONSOLE_CB *consoleCB, const CHAR *deviceName)
termios 结构是在POSIX规范中定义的标准接口,它类似于系统V中的termio接口, 通过设置termios类型的数据结构中的值和使用一小组函数调用,你就可以对终端接口进行控制。
BOOL ConsoleEnable(VOID)
控制台使能
BOOL IsConsoleOccupied(const CONSOLE_CB *consoleCB)
控制台是否被占用
INT32 ConsoleTcGetAttr(INT32 fd, struct termios *termios)
获取控制台 模式值
STATIC CONSOLE_CB * OsConsoleCBInit(UINT32 consoleID)
控制台描述符初始化
BOOL SetSerialNonBlock(const CONSOLE_CB *consoleCB)
无锁方式设置串口
CONSOLE_CB * OsGetConsoleByTaskID(UINT32 taskID)
获取参数任务的控制台控制块(描述符)
INT32 system_console_init(const CHAR *deviceName)
初始化系统控制台并返回 stdinfd stdoutfd stderrfd ,和system_console_deinit成对出现,像控制台的构造函数
CONSOLE_CB * g_console[CONSOLE_NUM]
控制台全局变量,控制台是共用的, 默认为 2个
STATIC CONSOLE_CB * OsConsoleCreate(UINT32 consoleID, const CHAR *deviceName)
创建一个控制台,这个函数的goto语句贼多
INT32 FilepPoll(struct file *filep, const struct file_operations_vfs *fops, poll_table *fds)
STATIC INT32 ConsoleGetWinSize(unsigned long arg)
STATIC INLINE VOID UserEndOfRead(CONSOLE_CB *consoleCB, struct file *filep, const struct file_operations_vfs *fops)
向控制台buf中写入结束字符
STATIC INT32 ConsoleCtrlRightsCapture(CONSOLE_CB *consoleCB)
STATIC INT32 ConsoleGetTermios(unsigned long arg)
INT32 FilepIoctl(struct file *filep, const struct file_operations_vfs *fops, INT32 cmd, unsigned long arg)
STATIC INT32 OsConsoleFileInit(CONSOLE_CB *consoleCB)
控制台文件实例初始化
STATIC INT32 ConsoleIoctl(struct file *filep, INT32 cmd, unsigned long arg)
INT32 ConsoleSetPgrp(CONSOLE_CB *consoleCB, unsigned long arg)
STATIC VOID ConsoleFifoLenUpdate(CONSOLE_CB *console)
控制台buf长度更新
VOID OsSetConsoleID(UINT32 newTaskID, UINT32 curTaskID)
设置控制台ID
BOOL SetTelnetBlock(const CONSOLE_CB *consoleCB)
锁方式设置远程登录
STATIC INT32 ConsoleCtrlCaptureLine(CONSOLE_CB *consoleCB)
铺捉到 ctrl + 字符, 例如 ctrl + c
STATIC INT32 ConsoleClose(struct file *filep)
关闭控制台
INT32 FilepWrite(struct file *filep, const struct file_operations_vfs *fops, const CHAR *buffer, size_t bufLen)
写数据到串口或远程登录
CONSOLE_CB * OsGetConsoleByID(INT32 consoleID)
获取参数控制台ID 获取对应的控制台控制块(描述符)
VOID OsWaitConsoleSendTaskPend(UINT32 taskID)
STATIC ssize_t DoWrite(CirBufSendCB *cirBufSendCB, CHAR *buffer, size_t bufLen)
STATIC INT32 ConsoleCtrlRightsRelease(CONSOLE_CB *consoleCB)
BOOL IsShellEntryRunning(UINT32 shellEntryId)
STATIC INT32 OsConsoleDevInit(CONSOLE_CB *consoleCB, const CHAR *deviceName)
INT32 ConsoleGetPgrp(CONSOLE_CB *consoleCB, unsigned long arg)
对控制台i/o操作
STATIC ssize_t WriteToTerminal(const CONSOLE_CB *consoleCB, const CHAR *buffer, size_t bufLen)
将buf内容写到终端设备
INT32 FilepClose(struct file *filep, const struct file_operations_vfs *fops)
关闭串口或远程登录
STATIC ssize_t DoRead(CONSOLE_CB *consoleCB, CHAR *buffer, size_t bufLen, struct file *privFilep, const struct file_operations_vfs *fileOps)
STATIC INT32 ConsolePoll(struct file *filep, poll_table *fds)
STATIC UINT32 OsConsoleDevDeinit(const CONSOLE_CB *consoleCB)
注销控制台设备
STATIC SPIN_LOCK_INIT(g_consoleSpin)
初始化控制台自旋锁
STATIC BOOL ConsoleFifoEmpty(const CONSOLE_CB *console)
INT32 FilepRead(struct file *filep, const struct file_operations_vfs *fops, CHAR *buffer, size_t bufLen)
从串口或远程登录中读数据
INT32 OsLogMemcpyRecord(const CHAR *buf, UINT32 logLen)
内存拷贝日志
UINT32 OsCheckConsoleLock(VOID)
LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventDestroy(PEVENT_CB_S eventCB)
销毁指定的事件控制块
LITE_OS_SEC_TEXT UINT32 LOS_EventRead(PEVENT_CB_S eventCB, UINT32 eventMask, UINT32 mode, UINT32 timeout)
读取指定事件类型,超时时间为相对时间:单位为Tick
LITE_OS_SEC_TEXT UINT32 LOS_EventWrite(PEVENT_CB_S eventCB, UINT32 events)
写指定的事件类型
LITE_OS_SEC_TEXT_INIT UINT32 LOS_EventInit(PEVENT_CB_S eventCB)
初始化一个事件控制块
VOID * LOS_MemAlloc(VOID *pool, UINT32 size)
从指定内存池中申请size长度的内存,注意这可不是从内核堆空间中申请内存
UINT8 * m_aucSysMem1
系统动态内存池地址的起始地址 @note_thinking 能否不要用 0,1来命名核心变量 ???
UINT32 LOS_MemFree(VOID *pool, VOID *ptr)
释放从指定动态内存中申请的内存
UINT8 * m_aucSysMem0
异常交互动态内存池地址的起始地址,当不支持异常交互特性时,m_aucSysMem0等于m_aucSysMem1。
LITE_OS_SEC_TEXT_INIT UINT32 LOS_SemCreate(UINT16 count, UINT32 *semHandle)
对外接口 创建信号量
LITE_OS_SEC_TEXT UINT32 LOS_SemPost(UINT32 semHandle)
对外接口 释放指定的信号量
LITE_OS_SEC_TEXT UINT32 LOS_SemPend(UINT32 semHandle, UINT32 timeout)
对外接口 申请指定的信号量,并设置超时时间
LITE_OS_SEC_TEXT_INIT UINT32 LOS_SemDelete(UINT32 semHandle)
对外接口 删除指定的信号量,参数就是 semID
LITE_OS_SEC_BSS UINT32 g_taskMaxNum
任务最大数量 默认128个
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
恢复挂起的任务,使该任务进入ready状态
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskID)
外部接口,对OsTaskSuspend的封装
LITE_OS_SEC_BSS LosTaskCB * g_taskCBArray
外部变量 任务池 默认128个
LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
创建任务,并使该任务进入ready状态,如果就绪队列中没有更高优先级的任务,则运行该任务
VOID *(* TSK_ENTRY_FUNC)(UINTPTR param1, UINTPTR param2, UINTPTR param3, UINTPTR param4)
Define the type of a task entrance function.
LITE_OS_SEC_TEXT_MINOR VOID LOS_Mdelay(UINT32 msecs)
以ms为单位的忙等,但可以被优先级更高的任务抢占
UINT32 LOS_CirBufRead(CirBuf *cirbufCB, CHAR *buf, UINT32 size)
读取循环buf的数据
UINT32 LOS_CirBufWrite(CirBuf *cirbufCB, const CHAR *buf, UINT32 size)
写入数据到循环buf区
UINT32 LOS_CirBufInit(CirBuf *cirbufCB, CHAR *fifo, UINT32 size)
初始化循环buf
UINT32 LOS_CirBufUsedSize(CirBuf *cirbufCB)
返回循环buf已使用的大小
VOID LOS_CirBufDeinit(CirBuf *cirbufCB)
删除初始化操作,其实就是清0
UINT32 OsGetSystemStatus(VOID)
获取系统状态
LITE_OS_SEC_TEXT UINT32 OsGetUserInitProcessID(VOID)
获取用户态进程的根进程,所有用户进程都是g_processCBArray[g_userInitProcess] fork来的
LITE_OS_SEC_TEXT INT32 OsSetCurrProcessGroupID(UINT32 gid)
STATIC INLINE LosTaskCB * OsCurrTaskGet(VOID)
STATIC INLINE BOOL OsPreemptable(VOID)
int OsKillLock(pid_t pid, int sig)
给发送信号过程加锁
VOID LOS_SpinUnlockRestore(SPIN_LOCK_S *lock, UINT32 intSave)
VOID LOS_SpinLockSave(SPIN_LOCK_S *lock, UINT32 *intSave)
STATIC INLINE LosTaskCB * OsGetTaskCB(UINT32 taskID)
通过任务ID获取任务实体,task由任务池分配,本质是个数组,彼此都挨在一块
STATIC INLINE BOOL OsTaskIsUnused(const LosTaskCB *taskCB)
任务是否在使用
STATIC INLINE BOOL LOS_IsUserAddressRange(VADDR_T vaddr, size_t len)
虚拟地址[vaddr,vaddr + len]是否在用户空间
STATIC INLINE BOOL LOS_IsUserAddress(VADDR_T vaddr)
虚拟地址是否在用户空间
CHAR * name
名称 例如: /dev/console1
UINT32 consoleID
控制台ID 例如 : 1 | 串口 , 2 | 远程登录
UINT32 shellEntryId
负责接受来自终端信息的 "ShellEntry"任务,这个值在运行过程中可能会被换掉,它始终指向当前正在运行的shell客户端
UINT32 currentLen
当前fifo位置
CirBufSendCB * cirBufSendCB
循环缓冲发送控制块
UINT8 fifo[CONSOLE_FIFO_SIZE]
termios 规范模式(ICANON mode )下使用 size:1K
struct Vnode * devVnode
索引节点
UINT32 refCount
引用次数,用于判断控制台是否被占用
UINT32 sendTaskID
创建任务通过事件接收数据, 见于OsConsoleBufInit
UINT32 fifoIn
对fifo的标记,输入位置
struct termios consoleTermios
行规程
UINT32 fifoOut
对fifo的标记,输出位置
CHAR taskName[OS_TCB_NAME_LEN]
vnode并不包含文件名,因为 vnode和文件名是 1:N 的关系
TSK_ENTRY_FUNC pfnTaskEntry
size_t LOS_ArchCopyToUser(void *dst, const void *src, size_t len)
从内核空间拷贝到用户空间
size_t LOS_ArchCopyFromUser(void *dst, const void *src, size_t len)
INT32 LOS_CopyFromKernel(VOID *dest, UINT32 max, const VOID *src, UINT32 count)
将内核数据拷贝到用户空间
int VnodeHold(void)
拿锁,封装互斥量
int VnodeLookup(const char *path, struct Vnode **vnode, uint32_t flags)
通过路径查询vnode节点
UINT32 SerialTypeGet(VOID)