los_syscall.h 文件参考

浏览源代码.

类型定义
typedef int(*	PollFun) (struct pollfd *fds, nfds_t nfds, int timeout)

函数
unsigned int	SysGetGroupId (void)
unsigned int	SysGetTid (void)
	获取当前任务ID 更多...
void	SysSchedYield (int type)
int	SysSchedGetScheduler (int id, int flag)
int	SysSchedSetScheduler (int id, int policy, int prio, int flag)
int	SysSchedGetParam (int id, int flag)
int	SysSchedSetParam (int id, unsigned int prio, int flag)
int	SysSetProcessPriority (int which, int who, unsigned int prio)
int	SysGetProcessPriority (int which, int who)
int	SysSchedGetPriorityMin (int policy)
int	SysSchedGetPriorityMax (int policy)
int	SysSchedRRGetInterval (int pid, struct timespec *tp)
int	SysWait (int pid, USER int *status, int options, void *rusage)
int	SysWaitid (idtype_t type, int pid, USER siginfo_t *info, int options, void *rusage)
int	SysFork (void)
int	SysVfork (void)
unsigned int	SysGetPID (void)
unsigned int	SysGetPPID (void)
int	SysSetGroupID (unsigned int gid)
int	SysGetGroupID (void)
int	SysGetUserID (void)
	获取用户ID 更多...
int	SysGetEffUserID (void)
int	SysGetEffGID (void)
int	SysSetUserID (int uid)
int	SysGetRealEffSaveUserID (int *ruid, int *euid, int *suid)
int	SysGetRealEffSaveGroupID (int *rgid, int *egid, int *sgid)
int	SysSetRealEffUserID (int ruid, int euid)
int	SysSetRealEffGroupID (int rgid, int egid)
int	SysSetRealEffSaveGroupID (int rgid, int egid, int sgid)
int	SysSetRealEffSaveUserID (int ruid, int euid, int suid)
int	SysGetGroups (int size, int list[])
int	SysSetGroups (int size, int list[])
int	SysGetCurrProcessGroupID (void)
	获取当前进程组ID 更多...
int	SysGetProcessGroupID (unsigned int pid)
	获取指定进程的组ID,为0时返回当前进程ID 更多...
int	SysSetProcessGroupID (unsigned int pid, unsigned int gid)
	为指定进程设置进程组ID 更多...
unsigned int	SysCreateUserThread (const TSK_ENTRY_FUNC func, const UserTaskParam *userParam, bool joinable)
int	SysSetThreadArea (const char *area)
char *	SysGetThreadArea (void)
int	SysUserThreadSetDetach (unsigned int taskID)
int	SysUserThreadDetach (unsigned int taskID)
int	SysThreadJoin (unsigned int taskID)
void	SysUserExitGroup (int status)
void	SysThreadExit (int status)
int	SysFutex (const unsigned int *uAddr, unsigned int flags, int val, unsigned int absTime, const unsigned int *newUserAddr)
	SysFutex 操作用户态快速互斥锁 系统调用 更多...
int	SysSchedGetAffinity (int id, unsigned int *cpuset, int flag)
int	SysSchedSetAffinity (int id, const unsigned short cpuset, int flag)
mqd_t	SysMqOpen (const char *mqName, int openFlag, mode_t mode, struct mq_attr *attr)
	打开一个消息队列,由posix接口封装 更多...
int	SysMqClose (mqd_t personal)
	关闭一个消息队列 更多...
int	SysMqGetSetAttr (mqd_t mqd, const struct mq_attr *new, struct mq_attr *old)
	封装posix的标准接口，获取和设置消息队列的属性 更多...
int	SysMqUnlink (const char *mqName)
int	SysMqSend (mqd_t personal, const char *msgPtr, size_t msgLen, unsigned int msgPrio)
int	SysMqTimedSend (mqd_t personal, const char *msg, size_t msgLen, unsigned int msgPrio, const struct timespec *absTimeout)
	定时时间发送消息,任务将被阻塞,等待被唤醒写入消息 更多...
ssize_t	SysMqTimedReceive (mqd_t personal, char *msg, size_t msgLen, unsigned int *msgPrio, const struct timespec *absTimeout)
	定时接收消息,任务将被阻塞,等待被唤醒读取 更多...
int	SysMqNotify (mqd_t personal, const struct sigevent *sigev)
int	SysSigAction (int sig, const sigaction_t *restrict sa, sigaction_t *restrict old, size_t sigsetsize)
	注册信号,鸿蒙内核只捕捉了SIGSYS 信号 更多...
int	SysSigprocMask (int how, const sigset_t_l *restrict setl, sigset_t_l *restrict oldl, size_t sigsetsize)
	系统调用之进程信号屏蔽, 什么意思?简单说就是 一个信号来了进程要不要处理,屏蔽就是不处理,注意不能屏蔽SIGKILL和SIGSTOP信号,必须要处理. 更多...
int	SysKill (pid_t pid, int sig)
	系统调用之向进程发送信号 更多...
int	SysPthreadKill (pid_t pid, int sig)
	系统调用之之向进程发送信号 更多...
int	SysSigTimedWait (const sigset_t_l *setl, siginfo_t *info, const struct timespec *timeout, size_t sigsetsize)
int	SysPause (void)
	系统调用之暂停任务 更多...
int	SysSigPending (sigset_t_l *setl)
	获取阻塞当前任务的信号集 更多...
int	SysSigSuspend (sigset_t_l *setl)
int	SysMkFifo (const char *pathName, mode_t mode)
int	SysSocket (int domain, int type, int protocol)
int	SysBind (int s, const struct sockaddr *name, socklen_t namelen)
int	SysConnect (int s, const struct sockaddr *name, socklen_t namelen)
int	SysListen (int sockfd, int backlog)
int	SysAccept (int socket, struct sockaddr *address, socklen_t *addressLen)
int	SysGetSockName (int s, struct sockaddr *name, socklen_t *namelen)
int	SysGetPeerName (int s, struct sockaddr *name, socklen_t *namelen)
ssize_t	SysSend (int s, const void *dataptr, size_t size, int flags)
ssize_t	SysSendTo (int s, const void *dataptr, size_t size, int flags, const struct sockaddr *to, socklen_t tolen)
ssize_t	SysRecv (int socket, void *buffer, size_t length, int flags)
ssize_t	SysRecvFrom (int socket, void *buffer, size_t length, int flags, struct sockaddr *address, socklen_t *addressLen)
int	SysShutdown (int socket, int how)
int	SysSetSockOpt (int socket, int level, int optName, const void *optValue, socklen_t optLen)
int	SysGetSockOpt (int sockfd, int level, int optName, void *optValue, socklen_t *optLen)
ssize_t	SysSendMsg (int s, const struct msghdr *message, int flags)
ssize_t	SysRecvMsg (int s, struct msghdr *message, int flags)
void *	SysMmap (void *addr, size_t size, int prot, int flags, int fd, size_t offset)
	系统调用|申请虚拟内存(分配线性地址区间) 鸿蒙与Linux标准库的差异 http://weharmonyos.com/zh-cn/device-dev/kernel/%E4%B8%8ELinux%E6%A0%87%E5%87%86%E5%BA%93%E7%9A%84%E5%B7%AE%E5%BC%82/ 更多...
int	SysMunmap (void *addr, size_t size)
	释放虚拟内存 更多...
int	SysMprotect (void *vaddr, size_t len, int prot)
	修改访问权限 更多...
void *	SysMremap (void *oldAddr, size_t oldLen, size_t newLen, int flags, void *newAddr)
void *	SysBrk (void *addr)
	brk也是申请堆内存的一种方式,一般小于 128K 会使用它 更多...
int	SysShmGet (key_t key, size_t size, int shmflg)
	得到一个共享内存标识符或创建一个共享内存对象 更多...
void *	SysShmAt (int shmid, const void *shmaddr, int shmflg)
int	SysShmCtl (int shmid, int cmd, struct shmid_ds *buf)
	完成对共享内存的控制 此函数可以对shmid指定的共享存储进行多种操作（删除、取信息、加锁、解锁等） 更多...
int	SysShmDt (const void *shmaddr)
	与shmat函数相反，是用来断开与共享内存附加点的地址，禁止本进程访问此片共享内存 更多...
int	SysUname (struct utsname *name)
int	SysInfo (struct sysinfo *info)
	系统信息 更多...
int	SysNanoSleep (const struct timespec *rqtp, struct timespec *rmtp)
clock_t	SysTimes (struct tms *buf)
time_t	SysTime (time_t *tloc)
int	SysSetiTimer (int which, const struct itimerval *value, struct itimerval *ovalue)
int	SysGetiTimer (int which, struct itimerval *value)
int	SysTimerCreate (clockid_t clockID, struct ksigevent *evp, timer_t *timerID)
int	SysTimerGettime (timer_t timerID, struct itimerspec *value)
int	SysTimerGetoverrun (timer_t timerID)
int	SysTimerDelete (timer_t timerID)
int	SysClockSettime (clockid_t clockID, const struct timespec *tp)
int	SysClockGettime (clockid_t clockID, struct timespec *tp)
	获取系统时间 更多...
int	SysClockGetres (clockid_t clockID, struct timespec *tp)
int	SysClockNanoSleep (clockid_t clk, int flags, const struct timespec *req, struct timespec *rem)
int	SysUtime (const char *path, const struct utimbuf *ptimes)
int	SysTimerSettime (timer_t timerID, int flags, const struct itimerspec *value, struct itimerspec *oldValue)
int	SysClockSettime64 (clockid_t clockID, const struct timespec64 *tp)
int	SysClockGettime64 (clockid_t clockID, struct timespec64 *tp)
int	SysClockGetres64 (clockid_t clockID, struct timespec64 *tp)
int	SysClockNanoSleep64 (clockid_t clk, int flags, const struct timespec64 *req, struct timespec64 *rem)
int	SysTimerGettime64 (timer_t timerID, struct itimerspec64 *value)
int	SysTimerSettime64 (timer_t timerID, int flags, const struct itimerspec64 *value, struct itimerspec64 *oldValue)
int	fp_open (char *fullpath, int oflags, mode_t mode)
int	do_open (int dirfd, const char *path, int oflags, mode_t mode)
int	do_unlink (int dirfd, const char *pathname)
int	do_mkdir (int dirfd, const char *pathname, mode_t mode)
int	do_rmdir (int dirfd, const char *pathname)
int	do_rename (int oldfd, const char *oldpath, int newfd, const char *newpath)
int	do_select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout, PollFun poll)
int	do_readdir (int fd, struct dirent **de, unsigned int count)
ssize_t	preadv (int __fd, const struct iovec *__iov, int __count, off_t __offset)
ssize_t	pwritev (int __fd, const struct iovec *__iov, int __count, off_t __offset)
int	chattr (const char *pathname, struct IATTR *attr)
int	SysClose (int fd)
ssize_t	SysRead (int fd, void *buf, size_t nbytes)
	系统调用|读文件:从文件中读取nbytes长度的内容到buf中(用户空间) 更多...
ssize_t	SysWrite (int fd, const void *buf, size_t nbytes)
	系统调用|写文件:将buf中(用户空间)nbytes长度的内容写到文件中 更多...
int	SysOpen (const char *path, int oflags,...)
	系统调用|打开文件, 正常情况下返回进程的FD值 更多...
int	SysCreat (const char *pathname, mode_t mode)
	创建文件,从实现看 SysCreat 和 SysOpen 并没有太大的区别,只有打开方式的区别 SysCreat函数完全可以被SysOpen函数替代 更多...
int	SysLink (const char *path1, const char *path2)
ssize_t	SysReadlink (const char *pathname, char *buf, size_t bufsize)
int	SysSymlink (const char *target, const char *linkpath)
int	SysLinkat (int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags)
int	SysSymlinkat (const char *target, int dirfd, const char *linkpath)
ssize_t	SysReadlinkat (int dirfd, const char *pathname, char *buf, size_t bufsize)
int	SysUnlink (const char *pathname)
	删除链:删除由装入点管理的文件 更多...
int	SysExecve (const char *fileName, char *const *argv, char *const *envp)
	动态加载程序过程 更多...
int	SysFchdir (int fd)
int	SysChdir (const char *path)
int	SysUtimensat (int fd, const char *path, struct timespec times[2], int flag)
int	SysFchmodat (int fd, const char *path, mode_t mode, int flag)
int	SysFchmod (int fd, mode_t mode)
int	SysChmod (const char *path, mode_t mode)
int	SysFchownat (int fd, const char *path, uid_t owner, gid_t group, int flag)
int	SysFchown (int fd, uid_t owner, gid_t group)
int	SysChown (const char *pathname, uid_t owner, gid_t group)
off_t	SysLseek (int fd, off_t offset, int whence)
	移动文件指针 更多...
off64_t	SysLseek64 (int fd, int offsetHigh, int offsetLow, off64_t *result, int whence)
int	SysMount (const char *source, const char *target, const char *filesystemtype, unsigned long mountflags, const void *data)
	SysMount 挂载文件系统 挂载是指将一个存储设备挂接到一个已存在的路径上。我们要访问存储设备中的文件，必须将文件所在的分区挂载到一个已存在的路径上， 然后通过这个路径来访问存储设备。如果只有一个存储设备，则可以直接挂载到根目录 / 上,变成根文件系统 更多...
int	SysUmount (const char *target)
	卸载文件系统,当某个文件系统不需要再使用了，那么可以将它卸载掉。 更多...
int	SysAccess (const char *path, int amode)
	确定文件的可存取性 更多...
int	SysFaccessat (int fd, const char *filename, int amode, int flag)
int	SysRename (const char *oldpath, const char *newpath)
	重命名文件 更多...
int	SysMkdir (const char *pathname, mode_t mode)
	创建目录 更多...
int	SysRmdir (const char *pathname)
	删除目录 更多...
int	SysDup (int fd)
int	SysUmount2 (const char *target, int flags)
	卸载文件系统 更多...
int	SysIoctl (int fd, int req, void *arg)
	I/O总控制函数 更多...
int	SysFcntl (int fd, int cmd, void *arg)
int	SysDup2 (int fd1, int fd2)
	复制文件描述符 更多...
int	SysSelect (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
	SysSelect 系统调用|文件系统|select .鸿蒙liteos目前也支持epoll方式 更多...
int	SysPselect6 (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const long data[2])
int	SysTruncate (const char *path, off_t length)
	系统调用|文件系统|截断功能 更多...
int	SysFtruncate (int fd, off_t length)
	系统调用|文件系统|截断功能 更多...
int	SysStatfs (const char *path, struct statfs *buf)
	获取指定路径下文件的文件系统信息 更多...
int	SysStatfs64 (const char *path, size_t sz, struct statfs *buf)
	获取文件系统信息 更多...
int	SysFstatfs (int fd, struct statfs *buf)
int	SysFstatfs64 (int fd, size_t sz, struct statfs *buf)
int	SysStat (const char *path, struct kstat *buf)
	获取文件状态信息 更多...
int	SysLstat (const char *path, struct kstat *buffer)
	参见SysStat 更多...
int	SysFstat (int fields, struct kstat *buf)
	参见SysStat 更多...
int	SysStatx (int fd, const char *restrict path, int flag, unsigned mask, struct statx *restrict stx)
int	SysFsync (int fd)
	把文件在内存中的部分写回磁盘 更多...
ssize_t	SysReadv (int fd, const struct iovec *iov, int iovcnt)
	通过FD读入数据到缓冲数组中,fd为进程描述符 更多...
ssize_t	SysWritev (int fd, const struct iovec *iov, int iovcnt)
	将缓冲数组里的数据写入文件 更多...
int	SysPipe (int pipefd[2])
int	SysFormat (const char *dev, int sectors, int option)
int	SysFstat64 (int fd, struct kstat *buf)
int	SysFstatat64 (int fd, const char *restrict path, struct kstat *restrict buf, int flag)
int	SysFcntl64 (int fd, int cmd, void *arg)
int	SysPoll (struct pollfd *fds, nfds_t nfds, int timeout)
	SysPoll I/O多路转换 更多...
int	SysPpoll (struct pollfd *fds, nfds_t nfds, const struct timespec *tmo_p, const sigset_t *sigmask, int nsig)
int	SysPrctl (int option,...)
	对进程进行特定操作 更多...
ssize_t	SysPread64 (int fd, void *buf, size_t nbytes, off64_t offset)
	对进程进行特定操作 更多...
ssize_t	SysPwrite64 (int fd, const void *buf, size_t nbytes, off64_t offset)
int	SysEpollCreate (int size)
int	SysEpollCreate1 (int size)
int	SysEpollCtl (int epfd, int op, int fd, struct epoll_event *ev)
int	SysEpollWait (int epfd, struct epoll_event *evs, int maxevents, int timeout)
int	SysEpollPwait (int epfd, struct epoll_event *evs, int maxevents, int timeout, const sigset_t *mask)
char *	SysGetcwd (char *buf, size_t n)
ssize_t	SysSendFile (int outfd, int infd, off_t *offset, size_t count)
int	SysTruncate64 (const char *path, off64_t length)
	系统调用|文件系统|截断功能 更多...
int	SysFtruncate64 (int fd, off64_t length)
int	SysOpenat (int dirfd, const char *path, int oflags,...)
int	SysMkdirat (int dirfd, const char *pathname, mode_t mode)
int	SysUnlinkat (int dirfd, const char *pathname, int flag)
int	SysRenameat (int oldfd, const char *oldpath, int newdfd, const char *newpath)
int	SysFallocate (int fd, int mode, off_t offset, off_t len)
int	SysFallocate64 (int fd, int mode, off64_t offset, off64_t len)
ssize_t	SysPreadv (int fd, const struct iovec *iov, int iovcnt, long loffset, long hoffset)
ssize_t	SysPwritev (int fd, const struct iovec *iov, int iovcnt, long loffset, long hoffset)
void	SysSync (void)
	将内存缓冲区数据写回硬盘 更多...
int	SysGetdents64 (int fd, struct dirent *de_user, unsigned int count)
int	do_opendir (const char *path, int oflags)
char *	SysRealpath (const char *path, char *resolvedPath)
int	SysUmask (int mask)
int	SysShellExec (const char *msgName, const char *cmdString)
	执行 shell 命令 更多...
int	SysReboot (int magic, int magic2, int type)
	重启系统 更多...
int	SysGetrusage (int what, struct rusage *ru)
long	SysSysconf (int name)
	系统配置 更多...
int	SysUgetrlimit (int resource, unsigned long long k_rlim[2])
int	SysSetrlimit (int resource, unsigned long long k_rlim[2])

详细描述

什么情况下会发生从用户态向内核态切换。这里细分为3种情况:

1、发生系统调用时

这是处于用户态的进程主动请求切换到内核态的一种方式。用户态的进程通过系统调用
申请使用操作系统提供的系统调用服务例程来处理任务。而系统调用的机制，其核心仍
是使用了操作系统为用户特别开发的一个中断机制来实现的，即软中断。

2、产生异常时

当CPU执行运行在用户态下的程序时，发生了某些事先不可知的异常，这时会触发由当前
运行的进程切换到处理此异常的内核相关的程序中，也就是转到了内核态，如缺页异常。

3、外设产生中断时

当外围设备完成用户请求的操作后，会向CPU发出相应的中断信号，这时CPU会暂停执行下
一条即将要执行的指令转而去执行与中断信号对应的处理程序，如果先前执行的指令是
用户态下的程序，那么这个转换的过程自然也就发生了由用户态到内核态的切换。
比如硬盘读写操作的完成，系统会切换到硬盘读写的中断处理程序中执行后续操作等。
可以看到上述三种由用户态切换到内核态的情况中，只有系统调用是进程主动请求发生切换的，
中断和异常都是被动的。

https://blog.csdn.net/piyongduo3393/article/details/89378243

在文件 los_syscall.h 中定义.

类型定义说明

PollFun

typedef int(* PollFun) (struct pollfd *fds, nfds_t nfds, int timeout)

在文件 los_syscall.h 第 237 行定义.

函数说明

chattr()

int chattr	(	const char *	pathname,
		struct IATTR *	attr
	)

在文件 vfs_chattr.c 第 58 行定义.

{
    struct Vnode *vnode = NULL;
    int ret;
 
    if (pathname == NULL || attr == NULL) {
        set_errno(EINVAL);
        return VFS_ERROR;
    }
 
    VnodeHold();
    ret = VnodeLookup(pathname, &vnode, 0);
    if (ret != LOS_OK) {
        goto errout_with_lock;
    }
 
    if ((vnode->originMount) && (vnode->originMount->mountFlags & MS_RDONLY)) {
        ret = -EROFS;
        goto errout_with_lock;
    }
 
    /* The way we handle the stat depends on the type of vnode that we
     * are dealing with.
     */
 
    if (vnode->vop != NULL && vnode->vop->Chattr != NULL) {
        ret = vnode->vop->Chattr(vnode, attr);
    } else {
        ret = -ENOSYS;
    }
    VnodeDrop();
 
    if (ret < 0) {
        goto errout;
    }
 
    return OK;
 
    /* Failure conditions always set the errno appropriately */
 
errout_with_lock:
    VnodeDrop();
errout:
    set_errno(-ret);
    return VFS_ERROR;
}

do_mkdir()

int do_mkdir	(	int	dirfd,
		const char *	pathname,
		mode_t	mode
	)

这是这个函数的调用关系图:

do_open()

int do_open	(	int	dirfd,
		const char *	path,
		int	oflags,
		mode_t	mode
	)

这是这个函数的调用关系图:

do_opendir()

int do_opendir	(	const char *	path,
		int	oflags
	)

这是这个函数的调用关系图:

do_readdir()

int do_readdir	(	int	fd,
		struct dirent **	de,
		unsigned int	count
	)

这是这个函数的调用关系图:

do_rename()

int do_rename	(	int	oldfd,
		const char *	oldpath,
		int	newfd,
		const char *	newpath
	)

这是这个函数的调用关系图:

do_rmdir()

int do_rmdir	(	int	dirfd,
		const char *	pathname
	)

这是这个函数的调用关系图:

do_select()

int do_select	(	int	nfds,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	exceptfds,
		struct timeval *	timeout,
		PollFun	poll
	)

这是这个函数的调用关系图:

do_unlink()

int do_unlink	(	int	dirfd,
		const char *	pathname
	)

这是这个函数的调用关系图:

fp_open()

int fp_open	(	char *	fullpath,
		int	oflags,
		mode_t	mode
	)

preadv()

ssize_t preadv	(	int	__fd,
		const struct iovec *	__iov,
		int	__count,
		off_t	__offset
	)

在文件 vfs_preadv.c 第 47 行定义.

{
    return vfs_readv(fd, iov, iovcnt, &offset);
}

函数调用图:

这是这个函数的调用关系图:

pwritev()

ssize_t pwritev	(	int	__fd,
		const struct iovec *	__iov,
		int	__count,
		off_t	__offset
	)

在文件 vfs_pwritev.c 第 47 行定义.

{
    return vfs_writev(fd, iov, iovcnt, &offset);
}

函数调用图:

这是这个函数的调用关系图:

SysAccept()

int SysAccept	(	int	socket,
		struct sockaddr *	address,
		socklen_t *	addressLen
	)

在文件 net_syscall.c 第 138 行定义.

{
    int ret;
 
    SOCKET_U2K(socket);
 
    CHECK_ASPACE(addressLen, sizeof(socklen_t));
    CPY_FROM_USER(addressLen);
 
    CHECK_ASPACE(address, LEN(addressLen));
    DUP_FROM_USER_NOCOPY(address, LEN(addressLen));
 
    ret = accept(socket, address, addressLen);
    if (ret == -1) {
        FREE_DUP(address);
        return -get_errno();
    }
 
    CPY_TO_USER(addressLen, close(ret); FREE_DUP(address));
    DUP_TO_USER(address, LEN(addressLen), close(ret); FREE_DUP(address));
    FREE_DUP(address);
 
    SOCKET_K2U(ret);
    return ret;
}

函数调用图:

SysAccess()

int SysAccess	(	const char *	path,
		int	amode
	)

确定文件的可存取性

在文件 fs_syscall.c 第 762 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = access(pathRet, amode);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
 
    return ret;
}

函数调用图:

SysBind()

int SysBind	(	int	s,
		const struct sockaddr *	name,
		socklen_t	namelen
	)

在文件 net_syscall.c 第 79 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
    CHECK_ASPACE(name, namelen);
 
    DUP_FROM_USER(name, namelen);
 
    if (name == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = bind(s, name, namelen);
    }
    FREE_DUP(name);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysBrk()

void * SysBrk

(

void *

addr

)

brk也是申请堆内存的一种方式,一般小于 128K 会使用它

参数

addr

返回

void*

在文件 vm_syscall.c 第 110 行定义.

{
    return LOS_DoBrk(addr);
}

函数调用图:

SysChdir()

int SysChdir

(

const char *

path

)

在文件 fs_syscall.c 第 578 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = chdir(path ? pathRet : NULL);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysChmod()

int SysChmod	(	const char *	path,
		mode_t	mode
	)

在文件 fs_syscall.c 第 2337 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = chmod(pathRet, mode);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysChown()

int SysChown	(	const char *	pathname,
		uid_t	owner,
		gid_t	group
	)

在文件 fs_syscall.c 第 2495 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = chown(pathRet, owner, group);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysClockGetres()

int SysClockGetres	(	clockid_t	clockID,
		struct timespec *	tp
	)

在文件 time_syscall.c 第 308 行定义.

{
    int ret;
    struct timespec stp;
 
    if (tp == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    ret = clock_getres(clockID, &stp);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (LOS_ArchCopyToUser(tp, &stp, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysClockGetres64()

int SysClockGetres64	(	clockid_t	clockID,
		struct timespec64 *	tp
	)

在文件 time_syscall.c 第 462 行定义.

{
    int ret;
    struct timespec t;
    struct timespec64 stp;
 
    if (tp == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    ret = clock_getres(clockID, &t);
    if (ret < 0) {
        return -get_errno();
    }
 
    stp.tv_sec = t.tv_sec;
    stp.tv_nsec = t.tv_nsec;
 
    if (LOS_ArchCopyToUser(tp, &stp, sizeof(struct timespec64))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysClockGettime()

int SysClockGettime	(	clockid_t	clockID,
		struct timespec *	tp
	)

获取系统时间

在文件 time_syscall.c 第 285 行定义.

{
    int ret;
    struct timespec stp;
 
    if (tp == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    ret = clock_gettime(clockID, &stp);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (LOS_ArchCopyToUser(tp, &stp, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysClockGettime64()

int SysClockGettime64	(	clockid_t	clockID,
		struct timespec64 *	tp
	)

在文件 time_syscall.c 第 435 行定义.

{
    int ret;
    struct timespec t;
    struct timespec64 stp;
 
    if (tp == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    ret = clock_gettime(clockID, &t);
    if (ret < 0) {
        return -get_errno();
    }
 
    stp.tv_sec = t.tv_sec;
    stp.tv_nsec = t.tv_nsec;
 
    if (LOS_ArchCopyToUser(tp, &stp, sizeof(struct timespec64))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysClockNanoSleep()

int SysClockNanoSleep	(	clockid_t	clk,
		int	flags,
		const struct timespec *	req,
		struct timespec *	rem
	)

在文件 time_syscall.c 第 331 行定义.

{
    int ret;
    struct timespec sreq;
    struct timespec srem = { 0 };
 
    if (!req || LOS_ArchCopyFromUser(&sreq, req, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    ret = clock_nanosleep(clk, flags, &sreq, rem ? &srem : NULL);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (rem && LOS_ArchCopyToUser(rem, &srem, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysClockNanoSleep64()

int SysClockNanoSleep64	(	clockid_t	clk,
		int	flags,
		const struct timespec64 *	req,
		struct timespec64 *	rem
	)

在文件 time_syscall.c 第 489 行定义.

{
    int ret;
    struct timespec rq;
    struct timespec rm = { 0 };
    struct timespec64 sreq;
    struct timespec64 srem = { 0 };
 
    if (!req || LOS_ArchCopyFromUser(&sreq, req, sizeof(struct timespec64))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    if (req != NULL) {
        rq.tv_sec = (sreq.tv_sec > UINT32_MAX) ? UINT32_MAX : sreq.tv_sec;
        rq.tv_nsec = sreq.tv_nsec;
    }
 
    ret = clock_nanosleep(clk, flags, &rq, rem ? &rm : NULL);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (rem != NULL) {
        srem.tv_sec = rm.tv_sec;
        srem.tv_nsec = rm.tv_nsec;
        if (LOS_ArchCopyToUser(rem, &srem, sizeof(struct timespec64))) {
            errno = EFAULT;
            return -EFAULT;
        }
    }
 
    return ret;
}

函数调用图:

SysClockSettime()

int SysClockSettime	(	clockid_t	clockID,
		const struct timespec *	tp
	)

在文件 time_syscall.c 第 263 行定义.

{
    int ret;
    struct timespec stp;
 
    if (tp == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    if (LOS_ArchCopyFromUser(&stp, tp, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    ret = clock_settime(clockID, &stp);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysClockSettime64()

int SysClockSettime64	(	clockid_t	clockID,
		const struct timespec64 *	tp
	)

在文件 time_syscall.c 第 405 行定义.

{
    int ret;
    struct timespec t;
    struct timespec64 stp;
 
    if (tp == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    if (LOS_ArchCopyFromUser(&stp, tp, sizeof(struct timespec64))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    if (stp.tv_sec > UINT32_MAX) {
        errno = ENOSYS;
        return -ENOSYS;
    }
    t.tv_sec = stp.tv_sec;
    t.tv_nsec = stp.tv_nsec;
 
    ret = clock_settime(clockID, &t);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysClose()

int SysClose

(

int

fd

)

在文件 fs_syscall.c 第 236 行定义.

{
    int ret;
 
    /* Process fd convert to system global fd */
    int sysfd = DisassociateProcessFd(fd);//先解除关联
 
    ret = close(sysfd);//关闭文件,个人认为应该先 close - > DisassociateProcessFd 
    if (ret < 0) {//关闭失败时
        AssociateSystemFd(fd, sysfd);//继续关联
        return -get_errno();
    }
    FreeProcessFd(fd);//释放进程fd
    return ret;
}

函数调用图:

SysConnect()

int SysConnect	(	int	s,
		const struct sockaddr *	name,
		socklen_t	namelen
	)

在文件 net_syscall.c 第 102 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
    CHECK_ASPACE(name, namelen);
 
    DUP_FROM_USER(name, namelen);
 
    if (name == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = connect(s, name, namelen);
    }
    FREE_DUP(name);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysCreat()

int SysCreat	(	const char *	pathname,
		mode_t	mode
	)

创建文件,从实现看 SysCreat 和 SysOpen 并没有太大的区别,只有打开方式的区别
SysCreat函数完全可以被SysOpen函数替代

参数

pathname
mode	常用标签如下: O_CREAT:若文件存在，此标志无用；若不存在，建新文件 O_TRUNC:若文件存在，则长度被截为0，属性不变 O_WRONLY:写文件 O_RDONLY:读文件 O_BINARY:此标志可显示地给出以二进制方式打开文件 O_TEXT :此标志可用于显示地给出以文本方式打开文件 O_RDWR :即读也写 O_APPEND:即读也写，但每次写总是在文件尾添加 *

返回

int

在文件 fs_syscall.c 第 372 行定义.

{
    int ret = 0;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    int procFd = AllocProcessFd();
    if (procFd  < 0) {
        ret = -EMFILE;
        goto OUT;
    }
    // 调用关系 open -> do_open chmod 666 
    ret = open((pathname ? pathRet : NULL), O_CREAT | O_TRUNC | O_WRONLY, mode);
    if (ret < 0) {
        FreeProcessFd(procFd);
        ret = -get_errno();
    } else {
        AssociateSystemFd(procFd, ret);
        ret = procFd;
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysCreateUserThread()

unsigned int SysCreateUserThread	(	const TSK_ENTRY_FUNC	func,
		const UserTaskParam *	userParam,
		bool	joinable
	)

在文件 process_syscall.c 第 882 行定义.

{
    TSK_INIT_PARAM_S param = { 0 };
    int ret;
 
    ret = LOS_ArchCopyFromUser(&(param.userParam), userParam, sizeof(UserTaskParam));
    if (ret != 0) {
        return OS_INVALID_VALUE;
    }
 
    param.pfnTaskEntry = func;
    if (joinable == TRUE) {
        param.uwResved = LOS_TASK_ATTR_JOINABLE;
    } else {
        param.uwResved = LOS_TASK_STATUS_DETACHED;
    }
 
    return OsCreateUserTask(OS_INVALID_VALUE, &param);
}

函数调用图:

SysDup()

int SysDup

(

int

fd

)

在文件 fs_syscall.c 第 871 行定义.

{
    int sysfd = GetAssociatedSystemFd(fd);
    /* Check if the param is valid, note that: socket fd is not support dup2 */
    if ((sysfd < 0) || (sysfd >= CONFIG_NFILE_DESCRIPTORS)) {
        return -EBADF;
    }
 
    int dupfd = AllocProcessFd();
    if (dupfd < 0) {
        return -EMFILE;
    }
 
    files_refer(sysfd);
    AssociateSystemFd(dupfd, sysfd);
    return dupfd;
}

函数调用图:

SysDup2()

int SysDup2	(	int	fd1,
		int	fd2
	)

复制文件描述符

在文件 fs_syscall.c 第 1038 行定义.

{
    int ret;
    int sysfd1 = GetAssociatedSystemFd(fd1);
    int sysfd2 = GetAssociatedSystemFd(fd2);
    //检查参数是否有效，注意：socket fd不支持dup2
    /* Check if the param is valid, note that: socket fd is not support dup2 */
    if ((sysfd1 < 0) || (sysfd1 >= CONFIG_NFILE_DESCRIPTORS) || (CheckProcessFd(fd2) != OK)) {//socket的fd必大于CONFIG_NFILE_DESCRIPTORS
        return -EBADF;
    }
 
    /* Handle special circumstances */
    if (fd1 == fd2) {
        return fd2;
    }
 
    ret = AllocSpecifiedProcessFd(fd2);
    if (ret != OK) {
        return ret;
    }
 
    /* close the sysfd2 in need */
    if (sysfd2 >= 0) {
        ret = close(sysfd2);
        if (ret < 0) {
            AssociateSystemFd(fd2, sysfd2);
            return -get_errno();
        }
    }
 
    files_refer(sysfd1);
    AssociateSystemFd(fd2, sysfd1);
 
    /* if fd1 is not equal to fd2, the FD_CLOEXEC flag associated with fd2 shall be cleared */
    ClearCloexecFlag(fd2);
    return fd2;
}

函数调用图:

SysEpollCreate()

int SysEpollCreate

(

int

size

)

在文件 fs_syscall.c 第 2751 行定义.

{
    (void)size;
    return DoEpollCreate1(0);
}

函数调用图:

SysEpollCreate1()

int SysEpollCreate1

(

int

size

)

在文件 fs_syscall.c 第 2757 行定义.

{
    return DoEpollCreate1(flags);
}

函数调用图:

SysEpollCtl()

int SysEpollCtl	(	int	epfd,
		int	op,
		int	fd,
		struct epoll_event *	ev
	)

在文件 fs_syscall.c 第 2762 行定义.

{
    int ret;
 
    CHECK_ASPACE(ev, sizeof(struct epoll_event));
    CPY_FROM_USER(ev);
 
    fd = GetAssociatedSystemFd(fd);
    epfd = GetAssociatedSystemFd(epfd);
    if ((fd < 0) || (epfd < 0)) {
        ret = -EBADF;
        goto OUT;
    }
 
    ret = epoll_ctl(epfd, op, fd, ev);
    if (ret < 0) {
        ret = -EBADF;
        goto OUT;
    }
 
    CPY_TO_USER(ev);
OUT:
    return (ret == -1) ? -get_errno() : ret;
}

函数调用图:

SysEpollPwait()

int SysEpollPwait	(	int	epfd,
		struct epoll_event *	evs,
		int	maxevents,
		int	timeout,
		const sigset_t *	mask
	)

在文件 fs_syscall.c 第 2810 行定义.

{
    sigset_t_l origMask;
    sigset_t_l setl;
    int ret = 0;
 
    CHECK_ASPACE(mask, sizeof(sigset_t));
 
    if (mask != NULL) {
        ret = LOS_ArchCopyFromUser(&setl, mask, sizeof(sigset_t));
        if (ret != 0) {
            return -EFAULT;
        }
    }
 
    CHECK_ASPACE(evs, sizeof(struct epoll_event));
    CPY_FROM_USER(evs);
 
    epfd = GetAssociatedSystemFd(epfd);
    if (epfd < 0) {
        ret = -EBADF;
        goto OUT;
    }
 
    OsSigprocMask(SIG_SETMASK, &setl, &origMask);
    ret = epoll_wait(epfd, evs, maxevents, timeout);
    if (ret < 0) {
        ret = -get_errno();
    }
 
    OsSigprocMask(SIG_SETMASK, &origMask, NULL);
 
    CPY_TO_USER(evs);
OUT:
    return (ret == -1) ? -get_errno() : ret;
}

函数调用图:

SysEpollWait()

int SysEpollWait	(	int	epfd,
		struct epoll_event *	evs,
		int	maxevents,
		int	timeout
	)

在文件 fs_syscall.c 第 2787 行定义.

{
    int ret = 0;
 
    CHECK_ASPACE(evs, sizeof(struct epoll_event));
    CPY_FROM_USER(evs);
 
    epfd = GetAssociatedSystemFd(epfd);
    if  (epfd < 0) {
        ret = -EBADF;
        goto OUT;
    }
 
    ret = epoll_wait(epfd, evs, maxevents, timeout);
    if (ret < 0) {
        ret = -get_errno();
    }
 
    CPY_TO_USER(evs);
OUT:
    return (ret == -1) ? -get_errno() : ret;
}

函数调用图:

SysExecve()

int SysExecve	(	const char *	fileName,
		char *const *	argv,
		char *const *	envp
	)

动态加载程序过程

在文件 fs_syscall.c 第 548 行定义.

{
    return LOS_DoExecveFile(fileName, argv, envp);
}

函数调用图:

SysFaccessat()

int SysFaccessat	(	int	fd,
		const char *	filename,
		int	amode,
		int	flag
	)

在文件 fs_syscall.c 第 2566 行定义.

{
    int ret;
    struct stat buf;
    struct statfs fsBuf;
    char *fullDirectory = NULL;
 
    ret = GetFullpath(fd, filename, &fullDirectory);
    if (ret < 0) {
        goto OUT;
    }
 
    ret = statfs(fullDirectory, &fsBuf);
    if (ret != 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    if ((fsBuf.f_flags & MS_RDONLY) && ((unsigned int)amode & W_OK)) {
        ret = -EROFS;
        goto OUT;
    }
 
    ret = stat(fullDirectory, &buf);
    if (ret != 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    if (VfsPermissionCheck(buf.st_uid, buf.st_gid, buf.st_mode, amode)) {
        ret = -EACCES;
    }
 
OUT:
    PointerFree(fullDirectory);
 
    return ret;
}

函数调用图:

SysFallocate()

int SysFallocate	(	int	fd,
		int	mode,
		off_t	offset,
		off_t	len
	)

在文件 fs_syscall.c 第 2067 行定义.

{
    int ret;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = fallocate(fd, mode, offset, len);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysFallocate64()

int SysFallocate64	(	int	fd,
		int	mode,
		off64_t	offset,
		off64_t	len
	)

在文件 fs_syscall.c 第 2081 行定义.

{
    int ret;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = fallocate64(fd, mode, offset, len);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysFchdir()

int SysFchdir

(

int

fd

)

在文件 fs_syscall.c 第 554 行定义.

{
    int ret;
    int sysFd;
    struct file *file = NULL;
 
    sysFd = GetAssociatedSystemFd(fd);
    if (sysFd < 0) {
        return -EBADF;
    }
 
    ret = fs_getfilep(sysFd, &file);
    if (ret < 0) {
        return -get_errno();
    }
 
    ret = chdir(file->f_path);
    if (ret < 0) {
        ret = -get_errno();
    }
 
    return ret;
}

函数调用图:

SysFchmod()

int SysFchmod	(	int	fd,
		mode_t	mode
	)

在文件 fs_syscall.c 第 2400 行定义.

{
    int ret;
    int sysFd;
    struct IATTR attr = {
        .attr_chg_mode = mode,
        .attr_chg_valid = CHG_MODE, /* change mode */
    };
    struct file *file = NULL;
 
    sysFd = GetAssociatedSystemFd(fd);
    if (sysFd < 0) {
        return -EBADF;
    }
 
    ret = fs_getfilep(sysFd, &file);
    if (ret < 0) {
        return -get_errno();
    }
 
    ret = chattr(file->f_path, &attr);
    if (ret < 0) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysFchmodat()

int SysFchmodat	(	int	fd,
		const char *	path,
		mode_t	mode,
		int	flag
	)

在文件 fs_syscall.c 第 2361 行定义.

{
    int ret;
    char *pathRet = NULL;
    char *fullpath = NULL;
    struct IATTR attr = {
        .attr_chg_mode = mode,
        .attr_chg_valid = CHG_MODE,
    };
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (fd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        fd = GetAssociatedSystemFd(fd);
    }
 
    ret = vfs_normalize_pathat(fd, pathRet, &fullpath);
    if (ret < 0) {
        goto OUT;
    }
 
    ret = chattr(fullpath, &attr);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    PointerFree(pathRet);
    PointerFree(fullpath);
 
    return ret;
}

函数调用图:

SysFchown()

int SysFchown	(	int	fd,
		uid_t	owner,
		gid_t	group
	)

在文件 fs_syscall.c 第 2461 行定义.

{
    int ret;
    int sysFd;
    struct IATTR attr = {0};
    attr.attr_chg_valid = 0;
    struct file *file = NULL;
 
    sysFd = GetAssociatedSystemFd(fd);
    if (sysFd < 0) {
        return -EBADF;
    }
 
    ret = fs_getfilep(sysFd, &file);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (owner != (uid_t)-1) {
        attr.attr_chg_uid = owner;
        attr.attr_chg_valid |= CHG_UID;
    }
    if (group != (gid_t)-1) {
        attr.attr_chg_gid = group;
        attr.attr_chg_valid |= CHG_GID;
    }
    ret = chattr(file->f_path, &attr);
    if (ret < 0) {
        ret = -get_errno();
    }
 
    return ret;
}

函数调用图:

SysFchownat()

int SysFchownat	(	int	fd,
		const char *	path,
		uid_t	owner,
		gid_t	group,
		int	flag
	)

在文件 fs_syscall.c 第 2428 行定义.

{
    int ret;
    char *fullpath = NULL;
    struct IATTR attr = {
        .attr_chg_valid = 0,
    };
 
    ret = GetFullpath(fd, path, &fullpath);
    if (ret < 0) {
        goto OUT;
    }
 
    if (owner != (uid_t)-1) {
        attr.attr_chg_uid = owner;
        attr.attr_chg_valid |= CHG_UID;
    }
    if (group != (gid_t)-1) {
        attr.attr_chg_gid = group;
        attr.attr_chg_valid |= CHG_GID;
    }
 
    ret = chattr(fullpath, &attr);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    PointerFree(fullpath);
 
    return ret;
}

函数调用图:

SysFcntl()

int SysFcntl	(	int	fd,
		int	cmd,
		void *	arg
	)

用来修改已经打开文件的属性的函数包含5个功能：
1.复制一个已有文件描述符，功能和dup和dup2相同，对应的cmd：F_DUPFD、F_DUPFD_CLOEXEC。
    当使用这两个cmd时，需要传入第三个参数，fcntl返回复制后的文件描述符，此返回值是之前未被占用的描述符，
    并且必须一个大于等于第三个参数值。
    F_DUPFD命令要求返回的文件描述符会清除对应的FD_CLOEXEC
    F_DUPFD_CLOEXEC要求设置新描述符的FD_CLOEXEC标志。

2.获取、设置文件描述符标志，对应的cmd：F_GETFD、F_SETFD。
    用于设置FD_CLOEXEC标志，此标志的含义是：当进程执行exec系统调用后此文件描述符会被自动关闭。

3.获取、设置文件访问状态标志，对应的cmd：F_GETFL、F_SETFL。
    获取当前打开文件的访问标志，设置对应的访问标志，一般常用来设置做非阻塞读写操作。

4.获取、设置记录锁功能，对应的cmd：F_GETLK、F_SETLK、F_SETLKW。

5.获取、设置异步I/O所有权，对应的cmd：F_GETOWN、F_SETOWN。
    获取和设置用来接收SIGIO/SIGURG信号的进程id或者进程组id。返回对应的进程id或者进程组id取负值。
 * 

参数

fd
cmd
arg

返回

int

在文件 fs_syscall.c 第 957 行定义.

{
    /* Process fd convert to system global fd */
    int sysfd = GetAssociatedSystemFd(fd);
 
    int ret = VfsFcntl(fd, cmd, arg);
    if (ret == CONTINE_NUTTX_FCNTL) {
        ret = fcntl(sysfd, cmd, arg);
    }
 
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysFcntl64()

int SysFcntl64	(	int	fd,
		int	cmd,
		void *	arg
	)

在文件 fs_syscall.c 第 2223 行定义.

{
    /* Process fd convert to system global fd */
    int sysfd = GetAssociatedSystemFd(fd);
 
    int ret = VfsFcntl(fd, cmd, arg);
    if (ret == CONTINE_NUTTX_FCNTL) {
        ret = fcntl64(sysfd, cmd, arg);
    }
 
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysFork()

int SysFork

(

void

)

在文件 process_syscall.c 第 350 行定义.

{
    return OsClone(0, 0, 0);
}

函数调用图:

SysFormat()

int SysFormat	(	const char *	dev,
		int	sectors,
		int	option
	)

在文件 fs_syscall.c 第 2173 行定义.

{
    int ret;
    char *devRet = NULL;
 
    if (!IsCapPermit(CAP_FS_FORMAT)) {
        return -EPERM;
    }
 
    if (dev != NULL) {
        ret = UserPathCopy(dev, &devRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = format((dev ? devRet : NULL), sectors, option);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (devRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, devRet);
    }
    return ret;
}

函数调用图:

SysFstat()

int SysFstat	(	int	fields,
		struct kstat *	buf
	)

参见SysStat

在文件 fs_syscall.c 第 1401 行定义.

{
    int ret;
    struct stat bufRet = {0};
    struct file *filep = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = fs_getfilep(fd, &filep);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (filep->f_oflags & O_DIRECTORY) {
        return -EBADF;
    }
 
    ret = stat(filep->f_path, (buf ? (&bufRet) : NULL));
    if (ret < 0) {
        return -get_errno();
    }
 
    ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
    if (ret != 0) {
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysFstat64()

int SysFstat64	(	int	fd,
		struct kstat *	buf
	)

在文件 fs_syscall.c 第 2202 行定义.

{
    int ret;
    struct stat64 bufRet = {0};
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = fstat64(fd, (buf ? (&bufRet) : NULL));
    if (ret < 0) {
        return -get_errno();
    }
 
    ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
    if (ret != 0) {
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysFstatat64()

int SysFstatat64	(	int	fd,
		const char *restrict	path,
		struct kstat *restrict	buf,
		int	flag
	)

在文件 fs_syscall.c 第 2519 行定义.

{
    int ret;
    struct stat bufRet = {0};
    char *pathRet = NULL;
    char *fullpath = NULL;
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (dirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        dirfd = GetAssociatedSystemFd(dirfd);
    }
 
    ret = vfs_normalize_pathat(dirfd, pathRet, &fullpath);
    if (ret < 0) {
        goto OUT;
    }
 
    ret = stat(fullpath, &bufRet);
    if (ret < 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
    if (ret != 0) {
        ret = -EFAULT;
        goto OUT;
    }
 
OUT:
    if (pathRet != NULL) {
        LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
 
    if (fullpath != NULL) {
        free(fullpath);
    }
    return ret;
}

函数调用图:

SysFstatfs()

int SysFstatfs	(	int	fd,
		struct statfs *	buf
	)

在文件 fs_syscall.c 第 2605 行定义.

{
    int ret;
    struct file *filep = NULL;
    struct statfs bufRet = {0};
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = fs_getfilep(fd, &filep);
    if (ret < 0) {
        ret = -get_errno();
        return ret;
    }
 
    ret = statfs(filep->f_path, &bufRet);
    if (ret < 0) {
        ret = -get_errno();
        return ret;
    }
 
    ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct statfs));
    if (ret != 0) {
        ret = -EFAULT;
    }
 
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

SysFstatfs64()

int SysFstatfs64	(	int	fd,
		size_t	sz,
		struct statfs *	buf
	)

在文件 fs_syscall.c 第 2634 行定义.

{
    int ret;
 
    if (sz != sizeof(struct statfs)) {
        ret = -EINVAL;
        return ret;
    }
 
    ret = SysFstatfs(fd, buf);
 
    return ret;
}

函数调用图:

SysFsync()

int SysFsync

(

int

fd

)

把文件在内存中的部分写回磁盘

在文件 fs_syscall.c 第 1437 行定义.

{
    int ret;
    struct file *filep = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    /* Get the file structure corresponding to the file descriptor. */
    ret = fs_getfilep(fd, &filep);
    if (ret < 0) {
        /* The errno value has already been set */
        return -get_errno();
    }
 
    if (filep->f_oflags & O_DIRECTORY) {
        return -EBADF;
    }
 
    /* Perform the fsync operation */
    ret = file_fsync(filep);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysFtruncate()

int SysFtruncate	(	int	fd,
		off_t	length
	)

系统调用|文件系统|截断功能

在文件 fs_syscall.c 第 1258 行定义.

{
    int ret;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = ftruncate(fd, length);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysFtruncate64()

int SysFtruncate64	(	int	fd,
		off64_t	length
	)

在文件 fs_syscall.c 第 1767 行定义.

{
    int ret;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = ftruncate64(fd, length);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysFutex()

int SysFutex	(	const unsigned int *	uAddr,
		unsigned int	flags,
		int	val,
		unsigned int	absTime,
		const unsigned int *	newUserAddr
	)

SysFutex 操作用户态快速互斥锁 系统调用

参数

absTime	绝对时间
flags	操作标识(FUTEX_WAKE | FUTEX_WAIT)
newUserAddr	FUTEX_REQUEUE下调整后带回新的用户空间地址
uAddr	用户态下共享内存的地址,里面存放的是一个对齐的整型计数器
val

返回

参见

在文件 process_syscall.c 第 1022 行定义.

{
    if ((flags & FUTEX_MASK) == FUTEX_REQUEUE) {//调整队列标识
        return -OsFutexRequeue(uAddr, flags, val, absTime, newUserAddr);
    }
 
    if ((flags & FUTEX_MASK) == FUTEX_WAKE) {//唤醒标识
        return -OsFutexWake(uAddr, flags, val);//最多唤醒val个等待在uaddr上进程
    }
    //FUTEX_WAIT
    return -OsFutexWait(uAddr, flags, val, absTime);//设置线程等待 原子性的检查uaddr中计数器的值是否为val,
    //如果是则让进程休眠，直到FUTEX_WAKE或者超时(time-out)。也就是把进程挂到uaddr相对应的等待队列上去。
}

函数调用图:

SysGetCurrProcessGroupID()

int SysGetCurrProcessGroupID

(

void

)

获取当前进程组ID

在文件 process_syscall.c 第 401 行定义.

{
    return LOS_GetCurrProcessGroupID();
}

函数调用图:

SysGetcwd()

char * SysGetcwd	(	char *	buf,
		size_t	n
	)

在文件 fs_syscall.c 第 1706 行定义.

{
    char *ret = NULL;
    char *bufRet = NULL;
    size_t bufLen = n;
    int retVal;
 
    if (bufLen > PATH_MAX) {
        bufLen = PATH_MAX;
    }
 
    bufRet = (char *)LOS_MemAlloc(OS_SYS_MEM_ADDR, bufLen);
    if (bufRet == NULL) {
        return (char *)(intptr_t)-ENOMEM;
    }
    (void)memset_s(bufRet, bufLen, 0, bufLen);
 
    ret = getcwd((buf ? bufRet : NULL), bufLen);
    if (ret == NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
        return (char *)(intptr_t)-get_errno();
    }
 
    retVal = LOS_ArchCopyToUser(buf, bufRet, bufLen);
    if (retVal != 0) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
        return (char *)(intptr_t)-EFAULT;
    }
    ret = buf;
 
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
    return ret;
}

函数调用图:

SysGetdents64()

int SysGetdents64	(	int	fd,
		struct dirent *	de_user,
		unsigned int	count
	)

在文件 fs_syscall.c 第 2239 行定义.

{
    if (!LOS_IsUserAddressRange((VADDR_T)(UINTPTR)de_user, count)) {
        return -EFAULT;
    }
 
    struct dirent *de_knl = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    int ret = do_readdir(fd, &de_knl, count);
    if (ret < 0) {
        return ret;
    }
    if (de_knl != NULL) {
        int cpy_ret = LOS_ArchCopyToUser(de_user, de_knl, ret);
        if (cpy_ret != 0)
        {
            return -EFAULT;
        }
    }
    return ret;
}

函数调用图:

SysGetEffGID()

int SysGetEffGID

(

void

)

在文件 syscall_lookup.h 第 198 行定义.

函数调用图:

SysGetEffUserID()

int SysGetEffUserID

(

void

)

在文件 process_syscall.c 第 411 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    UINT32 intSave;
    int euid;
 
    SCHEDULER_LOCK(intSave);
    euid = (int)OsCurrUserGet()->effUserID;
    SCHEDULER_UNLOCK(intSave);
    return euid;
#else
    return 0;
#endif
}

函数调用图:

SysGetGroupId()

unsigned int SysGetGroupId

(

void

)

SysGetGroupID()

int SysGetGroupID

(

void

)

在文件 syscall_lookup.h 第 151 行定义.

函数调用图:

SysGetGroups()

int SysGetGroups	(	int	size,
		int	list[]
	)

在文件 process_syscall.c 第 799 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    return GetGroups(size, list);
#else
    int group = 0;
    int groupCount = 1;
    int ret;
 
    if (size == 0) {
        return groupCount;
    } else if (list == NULL) {
        return -EFAULT;
    } else if (size < groupCount) {
        return -EINVAL;
    }
 
    ret = LOS_ArchCopyToUser(list, &group, sizeof(int));
    if (ret != 0) {
        return -EFAULT;
    }
 
    return groupCount;
#endif
}

函数调用图:

SysGetiTimer()

int SysGetiTimer	(	int	which,
		struct itimerval *	value
	)

在文件 time_syscall.c 第 137 行定义.

{
    int ret;
    struct itimerval svalue;
 
    if (value == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    ret = getitimer(which, &svalue);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (LOS_ArchCopyToUser(value, &svalue, sizeof(struct itimerval))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysGetPeerName()

int SysGetPeerName	(	int	s,
		struct sockaddr *	name,
		socklen_t *	namelen
	)

在文件 net_syscall.c 第 194 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
 
    CHECK_ASPACE(namelen, sizeof(socklen_t));
    CPY_FROM_USER(namelen);
 
    CHECK_ASPACE(name, LEN(namelen));
    DUP_FROM_USER_NOCOPY(name, LEN(namelen));
 
    if (name == NULL || namelen == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = getpeername(s, name, namelen);
    }
    if (ret == -1) {
        FREE_DUP(name);
        return -get_errno();
    }
 
    CPY_TO_USER(namelen, FREE_DUP(name));
    DUP_TO_USER(name, LEN(namelen), FREE_DUP(name));
    FREE_DUP(name);
    return ret;
}

函数调用图:

SysGetPID()

unsigned int SysGetPID

(

void

)

在文件 process_syscall.c 第 365 行定义.

{
    return LOS_GetCurrProcessID();
}

函数调用图:

SysGetPPID()

unsigned int SysGetPPID

(

void

)

在文件 syscall_lookup.h 第 153 行定义.

函数调用图:

SysGetProcessGroupID()

int SysGetProcessGroupID

(

unsigned int

pid

)

获取指定进程的组ID,为0时返回当前进程ID

在文件 process_syscall.c 第 392 行定义.

{
    if (pid == 0) {
        pid = LOS_GetCurrProcessID();
    }
 
    return LOS_GetProcessGroupID(pid);
}

函数调用图:

SysGetProcessPriority()

int SysGetProcessPriority	(	int	which,
		int	who
	)

在文件 process_syscall.c 第 227 行定义.

{
    if (who == 0) {
        who = (int)LOS_GetCurrProcessID();
    }
 
    return OsGetProcessPriority(which, who);
}

函数调用图:

SysGetRealEffSaveGroupID()

int SysGetRealEffSaveGroupID	(	int *	rgid,
		int *	egid,
		int *	sgid
	)

在文件 process_syscall.c 第 622 行定义.

{
    int ret;
    int realGroupID, effGroupID, saveGroupID;
#ifdef LOSCFG_SECURITY_CAPABILITY
    unsigned int intSave;
 
    SCHEDULER_LOCK(intSave);
    realGroupID = OsCurrUserGet()->gid;
    effGroupID = OsCurrUserGet()->effGid;
    saveGroupID = OsCurrUserGet()->effGid;
    SCHEDULER_UNLOCK(intSave);
#else
    realGroupID = 0;
    effGroupID = 0;
    saveGroupID = 0;
#endif
 
    ret = LOS_ArchCopyToUser(rgid, &realGroupID, sizeof(int));
    if (ret != 0) {
        return -EFAULT;
    }
 
    ret = LOS_ArchCopyToUser(egid, &effGroupID, sizeof(int));
    if (ret != 0) {
        return -EFAULT;
    }
 
    ret = LOS_ArchCopyToUser(sgid, &saveGroupID, sizeof(int));
    if (ret != 0) {
        return -EFAULT;
    }
 
    return 0;
}

函数调用图:

SysGetRealEffSaveUserID()

int SysGetRealEffSaveUserID	(	int *	ruid,
		int *	euid,
		int *	suid
	)

在文件 process_syscall.c 第 441 行定义.

{
    int ret;
    int realUserID, effUserID, saveUserID;
#ifdef LOSCFG_SECURITY_CAPABILITY
    unsigned int intSave;
 
    SCHEDULER_LOCK(intSave);
    realUserID = OsCurrUserGet()->userID;
    effUserID = OsCurrUserGet()->effUserID;
    saveUserID = OsCurrUserGet()->effUserID;
    SCHEDULER_UNLOCK(intSave);
#else
    realUserID = 0;
    effUserID = 0;
    saveUserID = 0;
#endif
 
    ret = LOS_ArchCopyToUser(ruid, &realUserID, sizeof(int));
    if (ret != 0) {
        return -EFAULT;
    }
 
    ret = LOS_ArchCopyToUser(euid, &effUserID, sizeof(int));
    if (ret != 0) {
        return -EFAULT;
    }
 
    ret = LOS_ArchCopyToUser(suid, &saveUserID, sizeof(int));
    if (ret != 0) {
        return -EFAULT;
    }
 
    return 0;
}

函数调用图:

SysGetrusage()

int SysGetrusage	(	int	what,
		struct rusage *	ru
	)

在文件 misc_syscall.c 第 158 行定义.

{
    int ret;
    struct tms time;
    clock_t usec, sec;
    struct rusage kru;
 
    ret = LOS_ArchCopyFromUser(&kru, ru, sizeof(struct rusage));
    if (ret != 0) {
        return -EFAULT;
    }
 
    if (times(&time) == -1) {
        return -EFAULT;
    }
 
    switch (what) {
        case RUSAGE_SELF: {
            usec = time.tms_utime;
            sec = time.tms_stime;
            break;
        }
        case RUSAGE_CHILDREN: {
            usec = time.tms_cutime;
            sec = time.tms_cstime;
            break;
        }
        default:
            return -EINVAL;
    }
    ConvertClocks(&kru.ru_utime, usec);
    ConvertClocks(&kru.ru_stime, sec);
 
    ret = LOS_ArchCopyToUser(ru, &kru, sizeof(struct rusage));
    if (ret != 0) {
        return -EFAULT;
    }
    return 0;
}

函数调用图:

SysGetSockName()

int SysGetSockName	(	int	s,
		struct sockaddr *	name,
		socklen_t *	namelen
	)

在文件 net_syscall.c 第 165 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
 
    CHECK_ASPACE(namelen, sizeof(socklen_t));
    CPY_FROM_USER(namelen);
 
    CHECK_ASPACE(name, LEN(namelen));
    DUP_FROM_USER_NOCOPY(name, LEN(namelen));
 
    if (name == NULL || namelen == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = getsockname(s, name, namelen);
    }
    if (ret == -1) {
        FREE_DUP(name);
        return -get_errno();
    }
 
    CPY_TO_USER(namelen, FREE_DUP(name));
    DUP_TO_USER(name, LEN(namelen), FREE_DUP(name));
    FREE_DUP(name);
    return ret;
}

函数调用图:

SysGetSockOpt()

int SysGetSockOpt	(	int	sockfd,
		int	level,
		int	optName,
		void *	optValue,
		socklen_t *	optLen
	)

在文件 net_syscall.c 第 366 行定义.

{
    int ret;
 
    SOCKET_U2K(sockfd);
 
    CHECK_ASPACE(optLen, sizeof(socklen_t));
    CPY_FROM_USER(optLen);
 
    CHECK_ASPACE(optValue, LEN(optLen));
    DUP_FROM_USER_NOCOPY(optValue, LEN(optLen));
 
    if (optLen == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = getsockopt(sockfd, level, optName, optValue, optLen);
    }
    if (ret == -1) {
        FREE_DUP(optValue);
        return -get_errno();
    }
 
    CPY_TO_USER(optLen, FREE_DUP(optValue));
    DUP_TO_USER(optValue, LEN(optLen), FREE_DUP(optValue));
    FREE_DUP(optValue);
    return ret;
}

函数调用图:

SysGetThreadArea()

char * SysGetThreadArea

(

void

)

在文件 syscall_lookup.h 第 217 行定义.

函数调用图:

SysGetTid()

unsigned int SysGetTid

(

void

)

获取当前任务ID

在文件 process_syscall.c 第 1037 行定义.

{
    return OsCurrTaskGet()->taskID;
}

函数调用图:

SysGetUserID()

int SysGetUserID

(

void

)

获取用户ID

在文件 process_syscall.c 第 406 行定义.

{
    return LOS_GetUserID();
}

函数调用图:

SysInfo()

int SysInfo

(

struct sysinfo *

info

)

系统信息

在文件 misc_syscall.c 第 71 行定义.

{
    int ret;
    struct sysinfo tmpInfo = { 0 };
 
    tmpInfo.totalram = LOS_MemPoolSizeGet(m_aucSysMem1);
    tmpInfo.freeram = LOS_MemPoolSizeGet(m_aucSysMem1) - LOS_MemTotalUsedGet(m_aucSysMem1);
    tmpInfo.sharedram = 0;
    tmpInfo.bufferram = 0;
    tmpInfo.totalswap = 0;
    tmpInfo.freeswap = 0;
 
    ret = LOS_ArchCopyToUser(info, &tmpInfo, sizeof(struct sysinfo));
    if (ret != 0) {
        return -EFAULT;
    }
    return 0;
}

函数调用图:

SysIoctl()

int SysIoctl	(	int	fd,
		int	req,
		void *	arg
	)

I/O总控制函数

在文件 fs_syscall.c 第 902 行定义.

{
    int ret;
    unsigned int size = _IOC_SIZE((unsigned int)req);
    unsigned int dir = _IOC_DIR((unsigned int)req);
    if ((size == 0) && (dir != _IOC_NONE)) {
        return -EINVAL;
    }
 
    if ((dir != _IOC_NONE) && (((void *)(uintptr_t)arg) == NULL)) {
        return -EINVAL;
    }
 
    if ((dir & _IOC_READ) || (dir & _IOC_WRITE)) {
        if (!LOS_IsUserAddressRange((uintptr_t)arg, size)) {
            return -EFAULT;
        }
    }
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = ioctl(fd, req, arg);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysKill()

int SysKill	(	pid_t	pid,
		int	sig
	)

系统调用之向进程发送信号

在文件 ipc_syscall.c 第 302 行定义.

{
    return OsKillLock(pid, sig);
}

函数调用图:

SysLink()

int SysLink	(	const char *	path1,
		const char *	path2
	)

在文件 fs_syscall.c 第 406 行定义.

{
    int ret;
    char *oldpathRet = NULL;
    char *newpathRet = NULL;
 
    if (oldpath != NULL) {
        ret = UserPathCopy(oldpath, &oldpathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (newpath != NULL) {
        ret = UserPathCopy(newpath, &newpathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = link(oldpathRet, newpathRet);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (oldpathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, oldpathRet);
    }
    if (newpathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, newpathRet);
    }
    return ret;
}

函数调用图:

SysLinkat()

int SysLinkat	(	int	olddirfd,
		const char *	oldpath,
		int	newdirfd,
		const char *	newpath,
		int	flags
	)

在文件 fs_syscall.c 第 1870 行定义.

{
    int ret;
    char *oldpathRet = NULL;
    char *newpathRet = NULL;
 
    if (oldpath != NULL) {
        ret = UserPathCopy(oldpath, &oldpathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (newpath != NULL) {
        ret = UserPathCopy(newpath, &newpathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (olddirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        olddirfd = GetAssociatedSystemFd(olddirfd);
    }
 
    if (newdirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        newdirfd = GetAssociatedSystemFd(newdirfd);
    }
 
    ret = linkat(olddirfd, oldpathRet, newdirfd, newpathRet, flags);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (oldpathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, oldpathRet);
    }
    if (newpathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, newpathRet);
    }
    return ret;
}

函数调用图:

SysListen()

int SysListen	(	int	sockfd,
		int	backlog
	)

在文件 net_syscall.c 第 125 行定义.

{
    int ret;
 
    SOCKET_U2K(sockfd);
    ret = listen(sockfd, backlog);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysLseek()

off_t SysLseek	(	int	fd,
		off_t	offset,
		int	whence
	)

移动文件指针

在文件 fs_syscall.c 第 602 行定义.

{
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    return _lseek(fd, offset, whence);
}

函数调用图:

SysLseek64()

off64_t SysLseek64	(	int	fd,
		int	offsetHigh,
		int	offsetLow,
		off64_t *	result,
		int	whence
	)

在文件 fs_syscall.c 第 611 行定义.

{
    off64_t ret;
    off64_t res;
    int retVal;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    ret = _lseek64(fd, offsetHigh, offsetLow, &res, whence);
    if (ret != 0) {
        return ret;
    }
 
    retVal = LOS_ArchCopyToUser(result, &res, sizeof(off64_t));
    if (retVal != 0) {
        return -EFAULT;
    }
 
    return 0;
}

函数调用图:

SysLstat()

int SysLstat	(	const char *	path,
		struct kstat *	buffer
	)

参见SysStat

在文件 fs_syscall.c 第 1370 行定义.

{
    int ret;
    char *pathRet = NULL;
    struct stat bufRet = {0};
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = stat((path ? pathRet : NULL), (buffer ? (&bufRet) : NULL));
    if (ret < 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    ret = LOS_ArchCopyToUser(buffer, &bufRet, sizeof(struct kstat));
    if (ret != 0) {
        ret = -EFAULT;
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysMkdir()

int SysMkdir	(	const char *	pathname,
		mode_t	mode
	)

创建目录

在文件 fs_syscall.c 第 823 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = do_mkdir(AT_FDCWD, (pathname ? pathRet : NULL), mode);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysMkdirat()

int SysMkdirat	(	int	dirfd,
		const char *	pathname,
		mode_t	mode
	)

在文件 fs_syscall.c 第 1841 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (dirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        dirfd = GetAssociatedSystemFd(dirfd);
    }
 
    ret = do_mkdir(dirfd, (pathname ? pathRet : NULL), mode);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysMkFifo()

int SysMkFifo	(	const char *	pathName,
		mode_t	mode
	)

在文件 ipc_syscall.c 第 389 行定义.

{
    int retValue;
    char kPathName[PATH_MAX + 1] = { 0 };
 
    retValue = LOS_StrncpyFromUser(kPathName, pathName, PATH_MAX);
    if (retValue < 0) {
        return retValue;
    }
    return mkfifo(kPathName, mode);
}

函数调用图:

SysMmap()

void * SysMmap	(	void *	addr,
		size_t	size,
		int	prot,
		int	flags,
		int	fd,
		size_t	offset
	)

系统调用|申请虚拟内存(分配线性地址区间)
鸿蒙与Linux标准库的差异 http://weharmonyos.com/zh-cn/device-dev/kernel/%E4%B8%8ELinux%E6%A0%87%E5%87%86%E5%BA%93%E7%9A%84%E5%B7%AE%E5%BC%82/

参数

addr	用来请求使用某个特定的虚拟内存地址。如果取NULL，结果地址就将自动分配（这是推荐的做法）， 否则会降低程序的可移植性，因为不同系统的可用地址范围不一样。
size	内存段的大小。
prot	用于设置内存段的访问权限，有如下权限： PROT_READ：允许读该内存段。 PROT_WRITE：允许写该内存段。 PROT_EXEC：允许执行该内存段。 PROT_NONE：不能访问。
flags	控制程序对内存段的改变所造成的影响，有如下属性： MAP_PRIVATE：标志指定线性区中的页可以被进程独享 MAP_SHARED：标志指定线性区中的页可以被几个进程共享
fd	打开的文件描述符,如果新的线性区将把一个文件映射到内存的情况
offset	用以改变经共享内存段访问的文件中数据的起始偏移值。

返回

void* 成功返回：虚拟内存地址，这地址是页对齐。
失败返回：(void *)-1。

在文件 vm_syscall.c 第 58 行定义.

{
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    return (void *)LOS_MMap((uintptr_t)addr, size, prot, flags, fd, offset);//分配线性地址区间
}

函数调用图:

SysMount()

int SysMount	(	const char *	source,
		const char *	target,
		const char *	filesystemtype,
		unsigned long	mountflags,
		const void *	data
	)

SysMount 挂载文件系统 挂载是指将一个存储设备挂接到一个已存在的路径上。我们要访问存储设备中的文件，必须将文件所在的分区挂载到一个已存在的路径上， 然后通过这个路径来访问存储设备。如果只有一个存储设备，则可以直接挂载到根目录 / 上,变成根文件系统

参数

data	特定文件系统的私有数据
filesystemtype	挂载的文件系统类型
mountflags	读写标志位
source	已经格式化的块设备名称
target	挂载路径，即挂载点

返回

参见

在文件 fs_syscall.c 第 666 行定义.

{
    int ret;
    char *sourceRet = NULL;
    char *targetRet = NULL;
    char *dataRet = NULL;
    char fstypeRet[FILESYSTEM_TYPE_MAX + 1] = {0};
 
    if (!IsCapPermit(CAP_FS_MOUNT)) {
        return -EPERM;
    }
 
    if (target != NULL) {
        ret = UserPathCopy(target, &targetRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (filesystemtype != NULL) {
        ret = LOS_StrncpyFromUser(fstypeRet, filesystemtype, FILESYSTEM_TYPE_MAX + 1);
        if (ret < 0) {
            goto OUT;
        } else if (ret > FILESYSTEM_TYPE_MAX) {
            ret = -ENODEV;
            goto OUT;
        }
 
        if (strcmp(fstypeRet, "ramfs") && (source != NULL)) {
            ret = UserPathCopy(source, &sourceRet);
            if (ret != 0) {
                goto OUT;
            }
        }
#ifdef LOSCFG_FS_NFS
        if (strcmp(fstypeRet, "nfs") == 0) {
            ret = NfsMount(sourceRet, targetRet, 0, 0);
            goto OUT;
        }
#endif
    }
 
    if (data != NULL) {
        ret = UserPathCopy(data, &dataRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = mount(sourceRet, targetRet, (filesystemtype ? fstypeRet : NULL), mountflags, dataRet);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (sourceRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, sourceRet);
    }
    if (targetRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, targetRet);
    }
    if (dataRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, dataRet);
    }
    return ret;
}

函数调用图:

SysMprotect()

int SysMprotect	(	void *	vaddr,
		size_t	len,
		int	prot
	)

修改访问权限

参数

addr

返回

void*

在文件 vm_syscall.c 第 100 行定义.

{
    return LOS_DoMprotect((uintptr_t)vaddr, len, (unsigned long)prot);
}

函数调用图:

SysMqClose()

int SysMqClose

(

mqd_t

personal

)

关闭一个消息队列

在文件 ipc_syscall.c 第 106 行定义.

{
    int ret;
    int ufd = (INTPTR)personal;
 
    MQUEUE_FD_U2K(personal);
    ret = mq_close(personal);
    if (ret < 0) {
        return -get_errno();
    }
    FreeProcessFd(ufd);
    return ret;
}

函数调用图:

SysMqGetSetAttr()

int SysMqGetSetAttr	(	mqd_t	mqd,
		const struct mq_attr *	new,
		struct mq_attr *	old
	)

封装posix的标准接口，获取和设置消息队列的属性

参数

mqd
new	判断是否是获取还是设置功能,new==null 获取 否则为设置
old

返回

int

在文件 ipc_syscall.c 第 138 行定义.

{
    int ret;
    struct mq_attr knew, kold;
 
    if (new != NULL) {
        ret = LOS_ArchCopyFromUser(&knew, new, sizeof(struct mq_attr));
        if (ret != 0) {
            return -EFAULT;
        }
    }
    MQUEUE_FD_U2K(mqd);
    ret = mq_getsetattr(mqd, new ? &knew : NULL, old ? &kold : NULL);
    if (ret < 0) {
        return -get_errno();
    }
    if (old != NULL) {
        ret = LOS_ArchCopyToUser(old, &kold, sizeof(struct mq_attr));
        if (ret != 0) {
            return -EFAULT;
        }
    }
    return ret;
}

函数调用图:

SysMqNotify()

int SysMqNotify	(	mqd_t	personal,
		const struct sigevent *	sigev
	)

在文件 ipc_syscall.c 第 119 行定义.

{
    int ret;
 
    MQUEUE_FD_U2K(personal);
    ret = OsMqNotify(personal, sigev);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysMqOpen()

mqd_t SysMqOpen	(	const char *	mqName,
		int	openFlag,
		mode_t	mode,
		struct mq_attr *	attr
	)

打开一个消息队列,由posix接口封装

   IPC（Inter-Process Communication，进程间通信）
   每个进程各自有不同的用户地址空间，进程之间地址保护,相互隔离,任何一个进程的信息在另一个进程中都看不到，
   所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程A把数据从用户空间拷到内核缓冲区，
   进程B再从内核缓冲区把数据读走，

   IPC实现方式之消息队列:
   消息队列特点总结：
   （1）消息队列是消息的链表,具有特定的格式,存放在内存中并由消息队列标识符标识.
   （2）消息队列允许一个或多个进程向它写入与读取消息.
   （3）管道和消息队列的通信数据都是先进先出的原则。
   （4）消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取.比FIFO更有优势。
   （5）消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
   （6）目前主要有两种类型的消息队列：POSIX消息队列以及System V消息队列，System V消息队列是随内核持续的，
       只有在内核重起或者人工删除时，该消息队列才会被删除。
       
   鸿蒙liteos 支持POSIX消息队列并加入了一种自研的消息队列 liteipc,此处重点讲 posix消息队列
* 

参数

mqName
openFlag
mode
attr

返回

mqd_t

在文件 ipc_syscall.c 第 87 行定义.

{
    mqd_t ret;
    int retValue;
    char kMqName[PATH_MAX + 1] = { 0 };
 
    retValue = LOS_StrncpyFromUser(kMqName, mqName, PATH_MAX);
    if (retValue < 0) {
        return retValue;
    }
    ret = mq_open(kMqName, openFlag, mode, attr);//posix ,一个消息队列可以有多个进程向它读写消息
    if (ret == -1) {
        return (mqd_t)-get_errno();
    }
    /* SysFd to procFd */
    MQUEUE_FD_K2U(ret);
    return ret;
}

函数调用图:

SysMqSend()

int SysMqSend	(	mqd_t	personal,
		const char *	msgPtr,
		size_t	msgLen,
		unsigned int	msgPrio
	)

SysMqTimedReceive()

ssize_t SysMqTimedReceive	(	mqd_t	personal,
		char *	msg,
		size_t	msgLen,
		unsigned int *	msgPrio,
		const struct timespec *	absTimeout
	)

定时接收消息,任务将被阻塞,等待被唤醒读取

在文件 ipc_syscall.c 第 230 行定义.

{
    int ret, receiveLen;
    struct timespec timeout;
    char *msgIntr = NULL;
    unsigned int kMsgPrio;
 
    if (absTimeout != NULL) {
        ret = LOS_ArchCopyFromUser(&timeout, absTimeout, sizeof(struct timespec));
        if (ret != 0) {
            return -EFAULT;
        }
    }
    if (msgLen == 0) {
        return -EINVAL;
    }
    msgIntr = (char *)malloc(msgLen);
    if (msgIntr == NULL) {
        return -ENOMEM;
    }
    MQUEUE_FD_U2K(personal);
    receiveLen = mq_timedreceive(personal, msgIntr, msgLen, &kMsgPrio, absTimeout ? &timeout : NULL);//posix 接口的实现
    if (receiveLen < 0) {
        free(msgIntr);
        return -get_errno();
    }
 
    if (msgPrio != NULL) {
        ret = LOS_ArchCopyToUser(msgPrio, &kMsgPrio, sizeof(unsigned int));
        if (ret != 0) {
            free(msgIntr);
            return -EFAULT;
        }
    }
 
    ret = LOS_ArchCopyToUser(msg, msgIntr, receiveLen);
    free(msgIntr);
    if (ret != 0) {
        return -EFAULT;
    }
    return receiveLen;
}

函数调用图:

SysMqTimedSend()

int SysMqTimedSend	(	mqd_t	personal,
		const char *	msg,
		size_t	msgLen,
		unsigned int	msgPrio,
		const struct timespec *	absTimeout
	)

定时时间发送消息,任务将被阻塞,等待被唤醒写入消息

在文件 ipc_syscall.c 第 195 行定义.

{
    int ret;
    struct timespec timeout;
    char *msgIntr = NULL;
 
    if (absTimeout != NULL) {
        ret = LOS_ArchCopyFromUser(&timeout, absTimeout, sizeof(struct timespec));
        if (ret != 0) {
            return -EFAULT;
        }
    }
    if (msgLen == 0) {
        return -EINVAL;
    }
    msgIntr = (char *)malloc(msgLen);
    if (msgIntr == NULL) {
        return -ENOMEM;
    }
    ret = LOS_ArchCopyFromUser(msgIntr, msg, msgLen);
    if (ret != 0) {
        free(msgIntr);
        return -EFAULT;
    }
    MQUEUE_FD_U2K(personal);
    ret = mq_timedsend(personal, msgIntr, msgLen, msgPrio, absTimeout ? &timeout : NULL);//posix 接口的实现
    free(msgIntr);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysMqUnlink()

int SysMqUnlink

(

const char *

mqName

)

   从内核中删除名为mqName的消息队列
   如果该函数被调用了,但是仍然有进程已经打开了这个消息队列,那么这个消息队列
   的销毁会被推迟到所有的引用都被关闭时执行.并且函数 mq_unlink() 不需要阻塞
   到所有的引用都被关闭为止,它会立即返回.函数 mq_unlink()调用成功后, 如果在
   随后调用 mq_open() 时重用这个消息队列名字,效果就像这个名字的消息队列不存在,
   如果没有设置O_CREAT标志,函数mq_open() 会返回失败,否则会创建一个新的消息队列.
* 

参数

mqName

返回

int

在文件 ipc_syscall.c 第 176 行定义.

{
    int ret;
    int retValue;
    char kMqName[PATH_MAX + 1] = { 0 };
 
    retValue = LOS_StrncpyFromUser(kMqName, mqName, PATH_MAX);
    if (retValue < 0) {
        return retValue;
    }
 
    ret = mq_unlink(kMqName);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysMremap()

void * SysMremap	(	void *	oldAddr,
		size_t	oldLen,
		size_t	newLen,
		int	flags,
		void *	newAddr
	)

参数

oldAddr	需要扩大（或缩小）的内存段的原始地址。注意old_address必须是页对齐。
oldLen	内存段的原始大小。
newLen	新内存段的大小。
flags	如果没有足够的空间在当前位置展开映射，则返回失败 MREMAP_MAYMOVE：允许内核将映射重定位到新的虚拟地址。 MREMAP_FIXED：mremap()接受第五个参数，void *new_address，该参数指定映射地址必须页对齐；
newAddr	在new_address和new_size指定的地址范围内的所有先前映射都被解除映射。如果指定了MREMAP_FIXED， 还必须指定MREMAP_MAYMOVE。

返回

void* 成功返回：重新映射后的虚拟内存地址
失败返回：((void *)-1)。

在文件 vm_syscall.c 第 90 行定义.

{
    return (void *)LOS_DoMremap((vaddr_t)oldAddr, oldLen, newLen, flags, (vaddr_t)newAddr);
}

函数调用图:

SysMunmap()

int SysMunmap	(	void *	addr,
		size_t	size
	)

释放虚拟内存

参数

addr	虚拟内存起始位置
size	内存段的大小

返回

int 成功返回0 失败返回-1。

在文件 vm_syscall.c 第 72 行定义.

{
    return LOS_UnMMap((uintptr_t)addr, size);
}

函数调用图:

SysNanoSleep()

int SysNanoSleep	(	const struct timespec *	rqtp,
		struct timespec *	rmtp
	)

在文件 time_syscall.c 第 355 行定义.

{
    int ret;
    struct timespec srqtp;
    struct timespec srmtp;
 
    if (!rqtp || LOS_ArchCopyFromUser(&srqtp, rqtp, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    if (rmtp && LOS_ArchCopyFromUser(&srmtp, rmtp, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    ret = nanosleep(&srqtp, rmtp ? &srmtp : NULL);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (rmtp && LOS_ArchCopyToUser(rmtp, &srmtp, sizeof(struct timespec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysOpen()

int SysOpen	(	const char *	path,
		int	oflags,
			...
	)

系统调用|打开文件, 正常情况下返回进程的FD值

在文件 fs_syscall.c 第 294 行定义.

{
    int ret;
    int procFd;
    mode_t mode = DEFAULT_FILE_MODE; /* 0666: File read-write properties. */
    char *pathRet = NULL;
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            return ret;
        }
    }
 
    procFd = AllocProcessFd();//分配进程描述符
    if (procFd < 0) {
        ret = -EMFILE;
        goto ERROUT;
    }
 
    if (oflags & O_CLOEXEC) {
        SetCloexecFlag(procFd);
    }
 
    if ((unsigned int)oflags & O_DIRECTORY) {//目录标签
        ret = do_opendir(pathRet, oflags);//打开目录
    } else {
 
#ifdef LOSCFG_FILE_MODE //文件权限开关
    va_list ap;
 
    va_start(ap, oflags);
    mode = va_arg(ap, int);//可变参数读取mode值
    va_end(ap);
#endif
//当fd参数的值是AT_FDCWD，并且path参数是一个相对路径名，fstatat会计算相对于当前目录的path参数。
//如果path是一个绝对路径，fd参数就会被忽略
        ret = do_open(AT_FDCWD, pathRet, oflags, mode);//打开文件,返回系统描述符
    }
 
    if (ret < 0) {
        ret = -get_errno();
        goto ERROUT;
    }
 
    AssociateSystemFd(procFd, ret);//进程<->系统描述符 关联/绑定
    if (pathRet != NULL) {
        LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return procFd;//返回进程描述符
 
ERROUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    if (procFd >= 0) {
        FreeProcessFd(procFd);
    }
    return ret;
}

函数调用图:

SysOpenat()

int SysOpenat	(	int	dirfd,
		const char *	path,
		int	oflags,
			...
	)

在文件 fs_syscall.c 第 1781 行定义.

{
    int ret;
    int procFd;
    char *pathRet = NULL;
    mode_t mode;
#ifdef LOSCFG_FILE_MODE
    va_list ap;
 
    va_start(ap, oflags);
    mode = va_arg(ap, int);
    va_end(ap);
#else
    mode = 0666; /* 0666: File read-write properties. */
#endif
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            return ret;
        }
    }
 
    procFd = AllocProcessFd();
    if (procFd < 0) {
        ret = -EMFILE;
        goto ERROUT;
    }
 
    if (oflags & O_CLOEXEC) {
        SetCloexecFlag(procFd);
    }
 
    if (dirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        dirfd = GetAssociatedSystemFd(dirfd);
    }
 
    ret = do_open(dirfd, (path ? pathRet : NULL), oflags, mode);
    if (ret < 0) {
        ret = -get_errno();
        goto ERROUT;
    }
 
    AssociateSystemFd(procFd, ret);
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return procFd;
 
ERROUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    if (procFd >= 0) {
        FreeProcessFd(procFd);
    }
    return ret;
}

函数调用图:

SysPause()

int SysPause

(

void

)

系统调用之暂停任务

在文件 syscall_lookup.h 第 143 行定义.

函数调用图:

SysPipe()

int SysPipe

(

int

pipefd[2]

)

   管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。
   调用pipe系统函数即可创建一个管道。有如下特质：

   1. 其本质是一个伪文件(实为内核缓冲区)
   2. 由两个文件描述符引用，一个表示读端，一个表示写端。
   3. 规定数据从管道的写端流入管道，从读端流出。

   管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
   管道的局限性：
       ① 数据自己读不能自己写。
       ② 数据一旦被读走，便不在管道中存在，不可反复读取。
       ③ 由于管道采用半双工通信方式。因此，数据只能在一个方向上流动。
       ④ 只能在有公共祖先的进程间使用管道。
   常见的通信方式有，单工通信、半双工通信、全双工通信。
* 

参数

pipefd

返回

int

在文件 fs_syscall.c 第 995 行定义.

{
    int ret;
    int pipeFdIntr[2] = {0}; /* 2 : pipe fds for read and write */
 
    int procFd0 = AllocProcessFd();//读端管道,像 stdin对应标准输入
    if (procFd0 < 0) {
        return -EMFILE;
    }
    int procFd1 = AllocProcessFd();//写端管道,像 stdout对应标准输出
    if (procFd1 < 0) {
        FreeProcessFd(procFd0);
        return -EMFILE;
    }
 
    ret = pipe(pipeFdIntr);//创建管道
    if (ret < 0) {
        FreeProcessFd(procFd0);
        FreeProcessFd(procFd1);
        return -get_errno();
    }
    int sysPipeFd0 = pipeFdIntr[0];
    int sysPipeFd1 = pipeFdIntr[1];
 
    AssociateSystemFd(procFd0, sysPipeFd0);//进程FD和系统FD绑定
    AssociateSystemFd(procFd1, sysPipeFd1);
 
    pipeFdIntr[0] = procFd0;
    pipeFdIntr[1] = procFd1;
 
    ret = LOS_ArchCopyToUser(pipefd, pipeFdIntr, sizeof(pipeFdIntr));//参数都走两个进程FD
    if (ret != 0) {
        FreeProcessFd(procFd0);
        FreeProcessFd(procFd1);
        close(sysPipeFd0);
        close(sysPipeFd1);
        return -EFAULT;
    }
    return ret;
}

函数调用图:

SysPoll()

int SysPoll	(	struct pollfd *	fds,
		nfds_t	nfds,
		int	timeout
	)

SysPoll I/O多路转换

参数

fds	fds是一个struct pollfd类型的数组，用于存放需要检测其状态的socket描述符，并且调用poll函数之后fds数组不会被清空； 一个pollfd结构体表示一个被监视的文件描述符，通过传递fds指示 poll() 监视多个文件描述符。
nfds	记录数组fds中描述符的总数量。
timeout	指定等待的毫秒数，无论 I/O 是否准备好，poll() 都会返回，和select函数是类似的。

返回

函数返回fds集合中就绪的读、写，或出错的描述符数量，返回0表示超时，返回-1表示出错； poll改变了文件描述符集合的描述方式，使用了pollfd结构而不是select的fd_set结构，使得poll支持的文件描述符集合限制远大于select的1024。 这也是和select不同的地方。

参见

在文件 fs_syscall.c 第 1552 行定义.

{
    int ret;
    struct pollfd *kfds = NULL;
 
    if ((nfds >= MAX_POLL_NFDS) || (nfds == 0) || (fds == NULL)) {
        return -EINVAL;
    }
 
    kfds = (struct pollfd *)malloc(sizeof(struct pollfd) * nfds);
    if (kfds != NULL) {
        if (LOS_ArchCopyFromUser(kfds, fds, sizeof(struct pollfd) * nfds) != 0) {
            ret = -EFAULT;
            goto OUT_KFD;
        }
    }
 
    int *pollFds = NULL;
    ret = PollfdToSystem(kfds, nfds, &pollFds);
    if (ret < 0) {
        ret = -get_errno();
        goto OUT_KFD;
    }
 
    ret = poll(kfds, nfds, timeout);
    if (ret < 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    if (kfds != NULL) {
        RestorePollfd(kfds, nfds, pollFds);
        if (LOS_ArchCopyToUser(fds, kfds, sizeof(struct pollfd) * nfds) != 0) {
            ret = -EFAULT;
            goto OUT;
        }
    }
 
OUT:
    free(pollFds);
OUT_KFD:
    free(kfds);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

SysPpoll()

int SysPpoll	(	struct pollfd *	fds,
		nfds_t	nfds,
		const struct timespec *	tmo_p,
		const sigset_t *	sigmask,
		int	nsig
	)

在文件 fs_syscall.c 第 2648 行定义.

{
    int timeout, retVal;
    sigset_t_l origMask = {0};
    sigset_t_l set = {0};
 
    CHECK_ASPACE(tmo_p, sizeof(struct timespec));
    CPY_FROM_USER(tmo_p);
 
    if (tmo_p != NULL) {
        timeout = tmo_p->tv_sec * OS_SYS_US_PER_MS + tmo_p->tv_nsec / OS_SYS_NS_PER_MS;
        if (timeout < 0) {
            return -EINVAL;
        }
    } else {
        timeout = -1;
    }
 
    if (sigMask != NULL) {
        retVal = LOS_ArchCopyFromUser(&set, sigMask, sizeof(sigset_t));
        if (retVal != 0) {
            return -EFAULT;
        }
        (VOID)OsSigprocMask(SIG_SETMASK, &set, &origMask);
    } else {
        (VOID)OsSigprocMask(SIG_SETMASK, NULL, &origMask);
    }
 
    retVal = SysPoll(fds, nfds, timeout);
    (VOID)OsSigprocMask(SIG_SETMASK, &origMask, NULL);
 
    return retVal;
}

函数调用图:

SysPrctl()

int SysPrctl	(	int	option,
			...
	)

对进程进行特定操作

在文件 fs_syscall.c 第 1597 行定义.

{
    unsigned long name;
    va_list ap;
    errno_t err;
 
    va_start(ap, option);
    if (option != PR_SET_NAME) {
        PRINT_ERR("%s: %d, no support option : 0x%x\n", __FUNCTION__, __LINE__, option);
        err = EOPNOTSUPP;
        goto ERROR;
    }
 
    name = va_arg(ap, unsigned long);
    if (!LOS_IsUserAddress(name)) {
        err = EFAULT;
        goto ERROR;
    }
 
    err = OsSetTaskName(OsCurrTaskGet(), (const char *)(uintptr_t)name, TRUE);
    if (err != LOS_OK) {
        goto ERROR;
    }
 
    va_end(ap);
    return ENOERR;
 
ERROR:
    va_end(ap);
    return -err;
}

函数调用图:

SysPread64()

ssize_t SysPread64	(	int	fd,
		void *	buf,
		size_t	nbytes,
		off64_t	offset
	)

对进程进行特定操作

在文件 fs_syscall.c 第 1629 行定义.

{
    int ret, retVal;
    char *bufRet = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    if (nbytes == 0) {
        ret = pread64(fd, buf, nbytes, offset);
        if (ret < 0) {
            return -get_errno();
        } else {
            return ret;
        }
    }
 
    bufRet = (char *)LOS_MemAlloc(OS_SYS_MEM_ADDR, nbytes);
    if (bufRet == NULL) {
        return -ENOMEM;
    }
 
    ret = pread64(fd, (buf ? bufRet : NULL), nbytes, offset);
    if (ret < 0) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
        return -get_errno();
    }
 
    retVal = LOS_ArchCopyToUser(buf, bufRet, ret);
    if (retVal != 0) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
        return -EFAULT;
    }
 
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
    return ret;
}

函数调用图:

SysPreadv()

ssize_t SysPreadv	(	int	fd,
		const struct iovec *	iov,
		int	iovcnt,
		long	loffset,
		long	hoffset
	)

在文件 fs_syscall.c 第 2095 行定义.

{
    off_t offsetflag;
    offsetflag = (off_t)((unsigned long long)loffset | (((unsigned long long)hoffset) << HIGH_SHIFT_BIT));
 
    int ret;
    int valid_iovcnt = -1;
    struct iovec *iovRet = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
    if ((iov == NULL) || (iovcnt < 0) || (iovcnt > IOV_MAX)) {
        return -EINVAL;
    }
 
    if (iovcnt == 0) {
        return 0;
    }
 
    ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
    if (ret != 0) {
        return ret;
    }
 
    if (valid_iovcnt <= 0) {
        ret = -EFAULT;
        goto OUT_FREE;
    }
 
    ret = preadv(fd, iovRet, valid_iovcnt, offsetflag);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT_FREE:
    (void)(void)LOS_MemFree(OS_SYS_MEM_ADDR, iovRet);
    return ret;
}

函数调用图:

SysPselect6()

int SysPselect6	(	int	nfds,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	exceptfds,
		const struct timespec *	timeout,
		const long	data[2]
	)

在文件 fs_syscall.c 第 2682 行定义.

{
    int ret;
    int retVal;
    sigset_t_l origMask;
    sigset_t_l setl;
 
    CHECK_ASPACE(readfds, sizeof(fd_set));
    CHECK_ASPACE(writefds, sizeof(fd_set));
    CHECK_ASPACE(exceptfds, sizeof(fd_set));
    CHECK_ASPACE(timeout, sizeof(struct timeval));
 
    CPY_FROM_USER(readfds);
    CPY_FROM_USER(writefds);
    CPY_FROM_USER(exceptfds);
    DUP_FROM_USER(timeout, sizeof(struct timeval));
 
    if (timeout != NULL) {
        ((struct timeval *)timeout)->tv_usec = timeout->tv_nsec / 1000; /* 1000, convert ns to us */
    }
 
    if (data != NULL) {
        retVal = LOS_ArchCopyFromUser(&(setl.sig[0]), (int *)((UINTPTR)data[0]), sizeof(sigset_t));
        if (retVal != 0) {
            ret = -EFAULT;
            FREE_DUP(timeout);
            return ret;
        }
    }
 
    OsSigprocMask(SIG_SETMASK, &setl, &origMask);
    ret = do_select(nfds, readfds, writefds, exceptfds, (struct timeval *)timeout, UserPoll);
    if (ret < 0) {
        /* do not copy parameter back to user mode if do_select failed */
        ret = -get_errno();
        FREE_DUP(timeout);
        return ret;
    }
    OsSigprocMask(SIG_SETMASK, &origMask, NULL);
 
    CPY_TO_USER(readfds);
    CPY_TO_USER(writefds);
    CPY_TO_USER(exceptfds);
    FREE_DUP(timeout);
 
    return ret;
}

函数调用图:

SysPthreadKill()

int SysPthreadKill	(	pid_t	pid,
		int	sig
	)

系统调用之之向进程发送信号

在文件 ipc_syscall.c 第 307 行定义.

{
    return OsPthreadKill(pid, sig);
}

函数调用图:

SysPwrite64()

ssize_t SysPwrite64	(	int	fd,
		const void *	buf,
		size_t	nbytes,
		off64_t	offset
	)

在文件 fs_syscall.c 第 1667 行定义.

{
    int ret;
    char *bufRet = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
 
    if (nbytes == 0) {
        ret = pwrite64(fd, buf, nbytes, offset);
        if (ret < 0) {
            return -get_errno();
        }
        return ret;
    }
 
    bufRet = (char *)LOS_MemAlloc(OS_SYS_MEM_ADDR, nbytes);
    if (bufRet == NULL) {
        return -ENOMEM;
    }
 
    if (buf != NULL) {
        ret = LOS_ArchCopyFromUser(bufRet, buf, nbytes);
        if (ret != 0) {
            (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
            return -EFAULT;
        }
    }
 
    ret = pwrite64(fd, (buf ? bufRet : NULL), nbytes, offset);
    if (ret < 0) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
        return -get_errno();
    }
 
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, bufRet);
    return ret;
}

函数调用图:

SysPwritev()

ssize_t SysPwritev	(	int	fd,
		const struct iovec *	iov,
		int	iovcnt,
		long	loffset,
		long	hoffset
	)

在文件 fs_syscall.c 第 2134 行定义.

{
    off_t offsetflag;
    offsetflag = (off_t)((unsigned long long)loffset | (((unsigned long long)hoffset) << HIGH_SHIFT_BIT));
    int ret;
    int valid_iovcnt = -1;
    struct iovec *iovRet = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);
    if ((iov == NULL) || (iovcnt < 0) || (iovcnt > IOV_MAX)) {
        return -EINVAL;
    }
 
    if (iovcnt == 0) {
        return 0;
    }
 
    ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
    if (ret != 0) {
        return ret;
    }
 
    if (valid_iovcnt != iovcnt) {
        ret = -EFAULT;
        goto OUT_FREE;
    }
 
    ret = pwritev(fd, iovRet, valid_iovcnt, offsetflag);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT_FREE:
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, iovRet);
    return ret;
}

函数调用图:

SysRead()

ssize_t SysRead	(	int	fd,
		void *	buf,
		size_t	nbytes
	)

系统调用|读文件:从文件中读取nbytes长度的内容到buf中(用户空间)

在文件 fs_syscall.c 第 252 行定义.

{
    int ret;
 
    if (nbytes == 0) {
        return 0;
    }
    //[buf,buf+nbytes]地址必须在用户空间
    if (!LOS_IsUserAddressRange((vaddr_t)(UINTPTR)buf, nbytes)) {
        return -EFAULT;
    }
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);//获得关联的系统fd,因为真正的read,write是需要sysFd的
    ret = read(fd, buf, nbytes);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysReadlink()

ssize_t SysReadlink	(	const char *	pathname,
		char *	buf,
		size_t	bufsize
	)

在文件 fs_syscall.c 第 441 行定义.

{
    ssize_t ret;
    char *pathRet = NULL;
 
    if (bufsize == 0) {
        return -EINVAL;
    }
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (!LOS_IsUserAddressRange((vaddr_t)(UINTPTR)buf, bufsize)) {
        ret = -EFAULT;
        goto OUT;
    }
 
    ret = readlink(pathRet, buf, bufsize);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysReadlinkat()

ssize_t SysReadlinkat	(	int	dirfd,
		const char *	pathname,
		char *	buf,
		size_t	bufsize
	)

在文件 fs_syscall.c 第 1956 行定义.

{
    ssize_t ret;
    char *pathRet = NULL;
 
    if (bufsize == 0) {
        return -EINVAL;
    }
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (dirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        dirfd = GetAssociatedSystemFd(dirfd);
    }
 
    if (!LOS_IsUserAddressRange((vaddr_t)(UINTPTR)buf, bufsize)) {
        ret = -EFAULT;
        goto OUT;
    }
 
    ret = readlinkat(dirfd, pathRet, buf, bufsize);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysReadv()

ssize_t SysReadv	(	int	fd,
		const struct iovec *	iov,
		int	iovcnt
	)

通过FD读入数据到缓冲数组中,fd为进程描述符

在文件 fs_syscall.c 第 1464 行定义.

{
    int ret;
    int valid_iovcnt = -1;
    struct iovec *iovRet = NULL;
 
    /* Process fd convert to system global fd */
    fd = GetAssociatedSystemFd(fd);//进程FD转成系统FD
    if ((iov == NULL) || (iovcnt < 0) || (iovcnt > IOV_MAX)) {
        return -EINVAL;
    }
 
    if (iovcnt == 0) {
        return 0;
    }
 
    ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
    if (ret != 0) {
        return ret;
    }
 
    if (valid_iovcnt <= 0) {
        ret = -EFAULT;
        goto OUT;
    }
 
    ret = vfs_readv(fd, iovRet, valid_iovcnt, NULL);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, iovRet);
    return ret;
}

函数调用图:

SysRealpath()

char * SysRealpath	(	const char *	path,
		char *	resolvedPath
	)

在文件 fs_syscall.c 第 2264 行定义.

{
    char *pathRet = NULL;
    char *resolved_pathRet = NULL;
    char *result = NULL;
    int ret;
 
    if (resolved_path == NULL) {
        return (char *)(intptr_t)-EINVAL;
    }
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            result = (char *)(intptr_t)ret;
            goto OUT;
        }
    }
 
    resolved_pathRet = realpath((path ? pathRet : NULL), NULL);
    if (resolved_pathRet == NULL) {
        result = (char *)(intptr_t)-get_errno();
        goto OUT;
    }
 
    ret = LOS_ArchCopyToUser(resolved_path, resolved_pathRet, strlen(resolved_pathRet) + 1);
    if (ret != 0) {
        result = (char *)(intptr_t)-EFAULT;
        goto OUT;
    }
    result = resolved_path;
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    if (resolved_pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, resolved_pathRet);
    }
    return result;
}

函数调用图:

SysReboot()

int SysReboot	(	int	magic,
		int	magic2,
		int	type
	)

重启系统

在文件 misc_syscall.c 第 90 行定义.

{
    (void)magic;
    (void)magic2;
    if (!IsCapPermit(CAP_REBOOT)) {
        return -EPERM;
    }
    SystemRebootFunc rebootHook = OsGetRebootHook();
    if ((type == RB_AUTOBOOT) && (rebootHook != NULL)) {
        rebootHook();
        return 0;
    }
    return -EFAULT;
}

函数调用图:

SysRecv()

ssize_t SysRecv	(	int	socket,
		void *	buffer,
		size_t	length,
		int	flags
	)

在文件 net_syscall.c 第 273 行定义.

{
    int ret;
 
    SOCKET_U2K(socket);
    CHECK_ASPACE(buffer, length);
 
    DUP_FROM_USER_NOCOPY(buffer, length);
 
    if (buffer == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = recv(socket, buffer, length, flags);
    }
    if (ret == -1) {
        FREE_DUP(buffer);
        return -get_errno();
    }
 
    DUP_TO_USER(buffer, ret, FREE_DUP(buffer));
    FREE_DUP(buffer);
    return ret;
}

函数调用图:

SysRecvFrom()

ssize_t SysRecvFrom	(	int	socket,
		void *	buffer,
		size_t	length,
		int	flags,
		struct sockaddr *	address,
		socklen_t *	addressLen
	)

在文件 net_syscall.c 第 298 行定义.

{
    int ret;
 
    SOCKET_U2K(socket);
    CHECK_ASPACE(buffer, length);
 
    CHECK_ASPACE(addressLen, sizeof(socklen_t));
    CPY_FROM_USER(addressLen);
 
    CHECK_ASPACE(address, LEN(addressLen));
    DUP_FROM_USER_NOCOPY(address, LEN(addressLen));
 
    DUP_FROM_USER_NOCOPY(buffer, length, FREE_DUP(address));
 
    if (buffer == NULL || (address != NULL && addressLen == NULL)) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = recvfrom(socket, buffer, length, flags, address, addressLen);
    }
    if (ret == -1) {
        FREE_DUP(address);
        FREE_DUP(buffer);
        return -get_errno();
    }
 
    CPY_TO_USER(addressLen, FREE_DUP(address); FREE_DUP(buffer));
    DUP_TO_USER(address, LEN(addressLen), FREE_DUP(address); FREE_DUP(buffer));
    DUP_TO_USER(buffer, ret, FREE_DUP(address); FREE_DUP(buffer));
    FREE_DUP(address);
    FREE_DUP(buffer);
    return ret;
}

函数调用图:

SysRecvMsg()

ssize_t SysRecvMsg	(	int	s,
		struct msghdr *	message,
		int	flags
	)

在文件 net_syscall.c 第 444 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
 
    CHECK_ASPACE(message, sizeof(struct msghdr));
    CPY_FROM_NONCONST_USER(message);
 
    if (message && message->msg_iovlen > IOV_MAX) {
        set_errno(EMSGSIZE);
        return -get_errno();
    }
 
    CHECK_FIELD_ASPACE(message, msg_name, message->msg_namelen);
    CHECK_FIELD_ASPACE(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
    CHECK_FIELD_ASPACE(message, msg_control, message->msg_controllen);
 
    DUP_FIELD_FROM_USER(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
    CHECK_ARRAY_FIELD_ASPACE(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
        FREE_DUP_FIELD(message, msg_iov));
    DUP_FIELD_FROM_USER_NOCOPY(message, msg_name, message->msg_namelen,
        FREE_DUP_FIELD(message, msg_iov));
    DUP_FIELD_FROM_USER_NOCOPY(message, msg_control, message->msg_controllen,
        FREE_DUP_FIELD(message, msg_iov);
        FREE_DUP_FIELD(message, msg_name));
    DUP_ARRAY_FIELD_FROM_USER_NOCOPY(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
        FREE_DUP_FIELD(message, msg_control);
        FREE_DUP_FIELD(message, msg_iov);
        FREE_DUP_FIELD(message, msg_name));
 
    if (message == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = recvmsg(s, message, flags);
    }
    if (ret == -1) {
        goto OUT;
    }
 
    CPY_TO_USER(message, ret = -1; goto OUT);
    DUP_FIELD_TO_USER(message, msg_control, message->msg_controllen, ret = -1; goto OUT);
    DUP_FIELD_TO_USER(message, msg_iov, message->msg_iovlen * sizeof(struct iovec), ret = -1; goto OUT);
    DUP_FIELD_TO_USER(message, msg_name, message->msg_namelen, ret = -1; goto OUT);
    DUP_ARRAY_FIELD_TO_USER(message, msg_iov, message->msg_iovlen, iov_base, iov_len, ret = -1; goto OUT);
OUT:
    FREE_DUP_ARRAY_FIELD(message, msg_iov, message->msg_iovlen, iov_base);
    FREE_DUP_FIELD(message, msg_control);
    FREE_DUP_FIELD(message, msg_iov);
    FREE_DUP_FIELD(message, msg_name);
    return (ret == -1) ? -get_errno() : ret;
}

函数调用图:

SysRename()

int SysRename	(	const char *	oldpath,
		const char *	newpath
	)

重命名文件

在文件 fs_syscall.c 第 787 行定义.

{
    int ret;
    char *pathOldRet = NULL;
    char *pathNewRet = NULL;
 
    if (oldpath != NULL) {
        ret = UserPathCopy(oldpath, &pathOldRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (newpath != NULL) {
        ret = UserPathCopy(newpath, &pathNewRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = do_rename(AT_FDCWD, (oldpath ? pathOldRet : NULL), AT_FDCWD,
                    (newpath ? pathNewRet : NULL));
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathOldRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathOldRet);
    }
    if (pathNewRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathNewRet);
    }
    return ret;
}

函数调用图:

SysRenameat()

int SysRenameat	(	int	oldfd,
		const char *	oldpath,
		int	newdfd,
		const char *	newpath
	)

在文件 fs_syscall.c 第 2023 行定义.

{
    int ret;
    char *pathOldRet = NULL;
    char *pathNewRet = NULL;
 
    if (oldpath != NULL) {
        ret = UserPathCopy(oldpath, &pathOldRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (newpath != NULL) {
        ret = UserPathCopy(newpath, &pathNewRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (oldfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        oldfd = GetAssociatedSystemFd(oldfd);
    }
    if (newdfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        newdfd = GetAssociatedSystemFd(newdfd);
    }
 
    ret = do_rename(oldfd, (oldpath ? pathOldRet : NULL), newdfd, (newpath ? pathNewRet : NULL));
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathOldRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathOldRet);
    }
    if (pathNewRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathNewRet);
    }
    return ret;
}

函数调用图:

SysRmdir()

int SysRmdir

(

const char *

pathname

)

删除目录

在文件 fs_syscall.c 第 847 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = do_rmdir(AT_FDCWD, (pathname ? pathRet : NULL));
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysSchedGetAffinity()

int SysSchedGetAffinity	(	int	id,
		unsigned int *	cpuset,
		int	flag
	)

在文件 process_syscall.c 第 1062 行定义.

{
    int ret;
    unsigned int processID;
    unsigned int taskID;
    unsigned int intSave;
    unsigned int cpuAffiMask;
 
    ret = SchedAffinityParameterPreprocess(id, flag, &taskID, &processID);
    if (ret != LOS_OK) {
        return ret;
    }
 
    SCHEDULER_LOCK(intSave);
    if (flag >= 0) {
        if (OsProcessIsInactive(OS_PCB_FROM_PID(processID))) {
            SCHEDULER_UNLOCK(intSave);
            return -ESRCH;
        }
    } else {
        ret = OsUserTaskOperatePermissionsCheck(OS_TCB_FROM_TID(taskID));
        if (ret != LOS_OK) {
            SCHEDULER_UNLOCK(intSave);
            if (ret == EINVAL) {
                return -ESRCH;
            }
            return -ret;
        }
    }
 
#ifdef LOSCFG_KERNEL_SMP
    cpuAffiMask = (unsigned int)OS_TCB_FROM_TID(taskID)->cpuAffiMask;
#else
    cpuAffiMask = 1;
#endif /* LOSCFG_KERNEL_SMP */
 
    SCHEDULER_UNLOCK(intSave);
    ret = LOS_ArchCopyToUser(cpuset, &cpuAffiMask, sizeof(unsigned int));
    if (ret != LOS_OK) {
        return -EFAULT;
    }
 
    return LOS_OK;
}

函数调用图:

SysSchedGetParam()

int SysSchedGetParam	(	int	id,
		int	flag
	)

在文件 process_syscall.c 第 164 行定义.

{
    SchedParam param = { 0 };
    unsigned int intSave;
 
    if (flag < 0) {
        if (OS_TID_CHECK_INVALID(id)) {
            return -EINVAL;
        }
 
        LosTaskCB *taskCB = OS_TCB_FROM_TID(id);
        SCHEDULER_LOCK(intSave);
        int ret = OsUserTaskOperatePermissionsCheck(taskCB);
        if (ret != LOS_OK) {
            SCHEDULER_UNLOCK(intSave);
            return -ret;
        }
 
        taskCB->ops->schedParamGet(taskCB, &param);
        SCHEDULER_UNLOCK(intSave);
        return (int)param.priority;
    }
 
    if (id == 0) {
        id = (int)LOS_GetCurrProcessID();
    }
 
    if (OS_PID_CHECK_INVALID(id)) {
        return -EINVAL;
    }
 
    return OsGetProcessPriority(LOS_PRIO_PROCESS, id);
}

函数调用图:

SysSchedGetPriorityMax()

int SysSchedGetPriorityMax

(

int

policy

)

在文件 process_syscall.c 第 245 行定义.

{
    if (policy != LOS_SCHED_RR) {
        return -EINVAL;
    }
 
    return OS_USER_PROCESS_PRIORITY_LOWEST;
}

SysSchedGetPriorityMin()

int SysSchedGetPriorityMin

(

int

policy

)

在文件 process_syscall.c 第 236 行定义.

{
    if (policy != LOS_SCHED_RR) {
        return -EINVAL;
    }
 
    return OS_USER_PROCESS_PRIORITY_HIGHEST;
}

SysSchedGetScheduler()

int SysSchedGetScheduler	(	int	id,
		int	flag
	)

在文件 process_syscall.c 第 113 行定义.

{
    unsigned int intSave;
    SchedParam param = { 0 };
    int ret;
 
    if (flag < 0) {
        if (OS_TID_CHECK_INVALID(id)) {
            return -EINVAL;
        }
 
        LosTaskCB *taskCB = OS_TCB_FROM_TID(id);
        SCHEDULER_LOCK(intSave);
        ret = OsUserTaskOperatePermissionsCheck(taskCB);
        if (ret != LOS_OK) {
            SCHEDULER_UNLOCK(intSave);
            return -ret;
        }
 
        taskCB->ops->schedParamGet(taskCB, &param);
        SCHEDULER_UNLOCK(intSave);
        return (int)param.policy;
    }
 
    return LOS_GetProcessScheduler(id);
}

函数调用图:

SysSchedRRGetInterval()

int SysSchedRRGetInterval	(	int	pid,
		struct timespec *	tp
	)

在文件 process_syscall.c 第 254 行定义.

{
    unsigned int intSave;
    int ret;
    SchedParam param = { 0 };
    time_t timeSlice = 0;
    struct timespec tv;
    LosTaskCB *taskCB = NULL;
    LosProcessCB *processCB = NULL;
 
    if (tp == NULL) {
        return -EINVAL;
    }
 
    if (OS_PID_CHECK_INVALID(pid)) {
        return -EINVAL;
    }
 
    if (pid == 0) {
        processCB = OsCurrProcessGet();
    } else {
        processCB = OS_PCB_FROM_PID(pid);
    }
 
    SCHEDULER_LOCK(intSave);
    /* if can not find process by pid return ESRCH */
    if (OsProcessIsInactive(processCB)) {
        SCHEDULER_UNLOCK(intSave);
        return -ESRCH;
    }
 
    LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
        if (!OsTaskIsInactive(taskCB)) {
            taskCB->ops->schedParamGet(taskCB, &param);
            if (param.policy == LOS_SCHED_RR) {
                timeSlice += param.timeSlice;
            }
        }
    }
 
    SCHEDULER_UNLOCK(intSave);
 
    timeSlice = timeSlice * OS_NS_PER_CYCLE;
    tv.tv_sec = timeSlice / OS_SYS_NS_PER_SECOND;
    tv.tv_nsec = timeSlice % OS_SYS_NS_PER_SECOND;
    ret = LOS_ArchCopyToUser(tp, &tv, sizeof(struct timespec));
    if (ret != 0) {
        return -EFAULT;
    }
 
    return 0;
}

函数调用图:

SysSchedSetAffinity()

int SysSchedSetAffinity	(	int	id,
		const unsigned short	cpuset,
		int	flag
	)

在文件 process_syscall.c 第 1108 行定义.

{
    int ret;
    unsigned int processID;
    unsigned int taskID;
    unsigned int intSave;
    unsigned short currCpuMask;
    bool needSched = FALSE;
 
    if (cpuset > LOSCFG_KERNEL_CPU_MASK) {
        return -EINVAL;
    }
 
    ret = SchedAffinityParameterPreprocess(id, flag, &taskID, &processID);
    if (ret != LOS_OK) {
        return ret;
    }
 
    if (flag >= 0) {
        ret = OsPermissionToCheck(processID, LOS_GetCurrProcessID());
        if (ret != LOS_OK) {
            return ret;
        }
        SCHEDULER_LOCK(intSave);
        if (OsProcessIsInactive(OS_PCB_FROM_PID(processID))) {
            SCHEDULER_UNLOCK(intSave);
            return -ESRCH;
        }
    } else {
        SCHEDULER_LOCK(intSave);
        ret = OsUserTaskOperatePermissionsCheck(OS_TCB_FROM_TID(taskID));
        if (ret != LOS_OK) {
            SCHEDULER_UNLOCK(intSave);
            if (ret == EINVAL) {
                return -ESRCH;
            }
            return -ret;
        }
    }
 
    needSched = OsTaskCpuAffiSetUnsafe(taskID, cpuset, &currCpuMask);
    SCHEDULER_UNLOCK(intSave);
    if (needSched && OS_SCHEDULER_ACTIVE) {
        LOS_MpSchedule(currCpuMask);
        LOS_Schedule();
    }
 
    return LOS_OK;
}

函数调用图:

SysSchedSetParam()

int SysSchedSetParam	(	int	id,
		unsigned int	prio,
		int	flag
	)

在文件 process_syscall.c 第 218 行定义.

{
    if (flag < 0) {
        return -OsUserTaskSchedulerSet(id, LOS_SCHED_RR, prio, false);
    }
 
    return SysSetProcessPriority(LOS_PRIO_PROCESS, id, prio);
}

函数调用图:

SysSchedSetScheduler()

int SysSchedSetScheduler	(	int	id,
		int	policy,
		int	prio,
		int	flag
	)

在文件 process_syscall.c 第 140 行定义.

{
    int ret;
 
    if (flag < 0) {
        return -OsUserTaskSchedulerSet(id, policy, prio, true);
    }
 
    if (prio < OS_USER_PROCESS_PRIORITY_HIGHEST) {
        return -EINVAL;
    }
 
    if (id == 0) {
        id = (int)LOS_GetCurrProcessID();
    }
 
    ret = OsPermissionToCheck(id, LOS_GetCurrProcessID());
    if (ret < 0) {
        return ret;
    }
 
    return OsSetProcessScheduler(LOS_PRIO_PROCESS, id, prio, policy);
}

函数调用图:

SysSchedYield()

void SysSchedYield

(

int

type

)

在文件 process_syscall.c 第 105 行定义.

{
    (void)type;
 
    (void)LOS_TaskYield();
    return;
}

函数调用图:

SysSelect()

int SysSelect	(	int	nfds,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	exceptfds,
		struct timeval *	timeout
	)

SysSelect 系统调用|文件系统|select .鸿蒙liteos目前也支持epoll方式

参数

exceptfds	文件集将监视文件集中的任何文件是否发生错误，可用于其他的用途， 例如，监视带外数据OOB，带外数据使用MSG_OOB标志发送到套接字上。当select函数返回的时候， exceptfds将清除其中的其他文件描述符，只留下标记有OOB数据的文件描述符。
nfds	select监视的文件句柄数，一般设为要监视各文件中的最大文件描述符值加1。
readfds	文件描述符集合监视文件集中的任何文件是否有数据可读，当select函数返回的时候， readfds将清除其中不可读的文件描述符，只留下可读的文件描述符。
timeout	参数是一个指向 struct timeval 类型的指针，它可以使 select()在等待 timeout 时间后 若没有文件描述符准备好则返回。其timeval结构用于指定这段时间的秒数和微秒数。它可以使select处于三种状态： (1) 若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止； (2) 若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值； (3) timeout的值大于0，这就是等待的超时时间，即select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。
writefds	文件描述符集合监视文件集中的任何文件是否有数据可写，当select函数返回的时候， writefds将清除其中不可写的文件描述符，只留下可写的文件描述符。

返回

参见

在文件 fs_syscall.c 第 1135 行定义.

{
    int ret;
    fd_set *fdsRet = NULL;
    fd_set *readfdsRet = NULL;
    fd_set *writefdsRet = NULL;
    fd_set *exceptfdsRet = NULL;
    struct timeval timeoutRet = {0};
 
    ret = SelectParamCheckCopy(readfds, writefds, exceptfds, &fdsRet);//检查参数
    if (ret != 0) {
        return ret;
    }
 
    readfdsRet = fdsRet;        /* LOS_MemAlloc 3 sizeof(fd_set) space,first use for readfds */
    writefdsRet = fdsRet + 1;   /* 1: LOS_MemAlloc 3 sizeof(fd_set) space,second use for writefds */
    exceptfdsRet = fdsRet + 2;  /* 2: LOS_MemAlloc 3 sizeof(fd_set) space,thired use for exceptfds */
 
    if (timeout != NULL) {
        if (LOS_ArchCopyFromUser(&timeoutRet, timeout, sizeof(struct timeval)) != 0) {
            goto ERROUT;
        }
    }
    //poll()是在NuttX下执行此类监视操作的基本API
    ret = do_select(nfds, (readfds ? readfdsRet : NULL), (writefds ? writefdsRet : NULL),
                 (exceptfds ? exceptfdsRet : NULL), (timeout ? (&timeoutRet) : NULL), UserPoll);
    if (ret < 0) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, fdsRet);
        return -get_errno();
    }
 
    if (readfds != NULL) {
        if (LOS_ArchCopyToUser(readfds, readfdsRet, sizeof(fd_set)) != 0) {
            goto ERROUT;
        }
    }
 
    if (writefds != NULL) {
        if (LOS_ArchCopyToUser(writefds, writefdsRet, sizeof(fd_set)) != 0) {
            goto ERROUT;
        }
    }
 
    if (exceptfds != 0) {
        if (LOS_ArchCopyToUser(exceptfds, exceptfdsRet, sizeof(fd_set)) != 0) {
            goto ERROUT;
        }
    }
 
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, fdsRet);
    return ret;
 
ERROUT:
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, fdsRet);
    return -EFAULT;
}

函数调用图:

SysSend()

ssize_t SysSend	(	int	s,
		const void *	dataptr,
		size_t	size,
		int	flags
	)

在文件 net_syscall.c 第 223 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
    CHECK_ASPACE(dataptr, size);
 
    DUP_FROM_USER(dataptr, size);
 
    if (dataptr == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = send(s, dataptr, size, flags);
    }
    FREE_DUP(dataptr);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysSendFile()

ssize_t SysSendFile	(	int	outfd,
		int	infd,
		off_t *	offset,
		size_t	count
	)

在文件 fs_syscall.c 第 1740 行定义.

{
    int ret, retVal;
    off_t offsetRet;
 
    retVal = LOS_ArchCopyFromUser(&offsetRet, offset, sizeof(off_t));
    if (retVal != 0) {
        return -EFAULT;
    }
 
    /* Process fd convert to system global fd */
    outfd = GetAssociatedSystemFd(outfd);
    infd = GetAssociatedSystemFd(infd);
 
    ret = sendfile(outfd, infd, (offset ? (&offsetRet) : NULL), count);
    if (ret < 0) {
        return -get_errno();
    }
 
    retVal = LOS_ArchCopyToUser(offset, &offsetRet, sizeof(off_t));
    if (retVal != 0) {
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysSendMsg()

ssize_t SysSendMsg	(	int	s,
		const struct msghdr *	message,
		int	flags
	)

在文件 net_syscall.c 第 396 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
 
    CHECK_ASPACE(message, sizeof(struct msghdr));
    CPY_FROM_CONST_USER(struct msghdr, message);
 
    if (message && message->msg_iovlen > IOV_MAX) {
        set_errno(EMSGSIZE);
        return -get_errno();
    }
 
    CHECK_FIELD_ASPACE(message, msg_name, message->msg_namelen);
    CHECK_FIELD_ASPACE(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
    CHECK_FIELD_ASPACE(message, msg_control, message->msg_controllen);
 
    DUP_FIELD_FROM_USER(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
    CHECK_ARRAY_FIELD_ASPACE(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
        FREE_DUP_FIELD(message, msg_iov));
    DUP_FIELD_FROM_USER(message, msg_name, message->msg_namelen,
        FREE_DUP_FIELD(message, msg_iov));
    DUP_FIELD_FROM_USER(message, msg_control, message->msg_controllen,
        FREE_DUP_FIELD(message, msg_iov);
        FREE_DUP_FIELD(message, msg_name));
    DUP_ARRAY_FIELD_FROM_USER(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
        FREE_DUP_FIELD(message, msg_control);
        FREE_DUP_FIELD(message, msg_iov);
        FREE_DUP_FIELD(message, msg_name));
 
    if (message == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = sendmsg(s, message, flags);
    }
    FREE_DUP_ARRAY_FIELD(message, msg_iov, message->msg_iovlen, iov_base);
    FREE_DUP_FIELD(message, msg_control);
    FREE_DUP_FIELD(message, msg_iov);
    FREE_DUP_FIELD(message, msg_name);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysSendTo()

ssize_t SysSendTo	(	int	s,
		const void *	dataptr,
		size_t	size,
		int	flags,
		const struct sockaddr *	to,
		socklen_t	tolen
	)

在文件 net_syscall.c 第 246 行定义.

{
    int ret;
 
    SOCKET_U2K(s);
    CHECK_ASPACE(dataptr, size);
    CHECK_ASPACE(to, tolen);
 
    DUP_FROM_USER(dataptr, size);
    DUP_FROM_USER(to, tolen, FREE_DUP(dataptr));
 
    if (dataptr == NULL) {
        set_errno(EFAULT);
        ret = -1;
    } else {
        ret = sendto(s, dataptr, size, flags, to, tolen);
    }
    FREE_DUP(dataptr);
    FREE_DUP(to);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysSetGroupID()

int SysSetGroupID

(

unsigned int

gid

)

SysSetGroups()

int SysSetGroups	(	int	size,
		int	list[]
	)

在文件 process_syscall.c 第 825 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    int ret;
    int gid;
    int listSize = size;
    unsigned int count;
    int *safeList = NULL;
#endif
 
    if ((size != 0) && (list == NULL)) {
        return -EFAULT;
    }
 
    if ((size < 0) || (size > OS_GROUPS_NUMBER_MAX)) {
        return -EINVAL;
    }
 
#ifdef LOSCFG_SECURITY_CAPABILITY
    if (!IsCapPermit(CAP_SETGID)) {
        return -EPERM;
    }
 
    if (size != 0) {
        safeList = LOS_MemAlloc(m_aucSysMem1, size * sizeof(int));
        if (safeList == NULL) {
            return -ENOMEM;
        }
 
        ret = LOS_ArchCopyFromUser(safeList, list, size * sizeof(int));
        if (ret != 0) {
            ret = -EFAULT;
            goto EXIT;
        }
        gid = OsCurrUserGet()->gid;
        for (count = 0; count < size; count++) {
            if (safeList[count] == gid) {
                listSize = size - 1;
            } else if (safeList[count] < 0) {
                ret = -EINVAL;
                goto EXIT;
            }
        }
    }
 
    ret = SetGroups(listSize, safeList, size);
EXIT:
    if (safeList != NULL) {
        (void)LOS_MemFree(m_aucSysMem1, safeList);
    }
 
    return ret;
#else
    return 0;
#endif
}

函数调用图:

SysSetiTimer()

int SysSetiTimer	(	int	which,
		const struct itimerval *	value,
		struct itimerval *	ovalue
	)

在文件 time_syscall.c 第 108 行定义.

{
    int ret;
    struct itimerval svalue;
    struct itimerval sovalue;
 
    if (value == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    if (LOS_ArchCopyFromUser(&svalue, value, sizeof(struct itimerval))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    ret = setitimer(which, &svalue, &sovalue);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (ovalue && LOS_ArchCopyToUser(ovalue, &sovalue, sizeof(struct itimerval))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysSetProcessGroupID()

int SysSetProcessGroupID	(	unsigned int	pid,
		unsigned int	gid
	)

为指定进程设置进程组ID

在文件 process_syscall.c 第 370 行定义.

{
    int ret;
 
    if (pid == 0) {//无指定进程ID时 @note_thinking 此处会不会有风险, 直接返回会不会好些 ?
        pid = LOS_GetCurrProcessID();//获取当前进程ID,给当前进程设置组ID
    }
 
    if (gid == 0) {
        gid = pid;
    } else if (gid <= OS_USER_PRIVILEGE_PROCESS_GROUP) {
        return -EPERM;
    }
 
    ret = OsPermissionToCheck(pid, gid);
    if (ret < 0) {
        return ret;
    }
 
    return OsSetProcessGroupID(pid, gid);
}

函数调用图:

SysSetProcessPriority()

int SysSetProcessPriority	(	int	which,
		int	who,
		unsigned int	prio
	)

在文件 process_syscall.c 第 198 行定义.

{
    int ret;
 
    if (prio < OS_USER_PROCESS_PRIORITY_HIGHEST) {
        return -EINVAL;
    }
 
    if (who == 0) {
        who = (int)LOS_GetCurrProcessID();
    }
 
    ret = OsPermissionToCheck(who, LOS_GetCurrProcessID());
    if (ret < 0) {
        return ret;
    }
 
    return OsSetProcessScheduler(which, who, prio, LOS_GetProcessScheduler(who));
}

函数调用图:

这是这个函数的调用关系图:

SysSetRealEffGroupID()

int SysSetRealEffGroupID	(	int	rgid,
		int	egid
	)

在文件 process_syscall.c 第 713 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    return SysSetRealEffSaveGroupID(rgid, egid, -1);
#else
    if ((rgid != 0) || (egid != 0)) {
        return -EPERM;
    }
    return 0;
#endif
}

函数调用图:

SysSetRealEffSaveGroupID()

int SysSetRealEffSaveGroupID	(	int	rgid,
		int	egid,
		int	sgid
	)

在文件 process_syscall.c 第 677 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    int ret;
 
    if ((rgid == -1) && (egid == -1) && (sgid == -1)) {
        return 0;
    }
 
    ret = SetRealEffSaveGroupIDCheck(rgid, egid, sgid);
    if (ret != 0) {
        return ret;
    }
 
    if (rgid >= 0) {
        if (((egid != -1) && (egid != rgid)) || ((sgid != -1) && (sgid != rgid))) {
            return -EPERM;
        }
        return SysSetGroupID(rgid);
    } else if (egid >= 0) {
        if ((sgid != -1) && (sgid != egid)) {
            return -EPERM;
        }
        return SysSetGroupID(egid);
    } else {
        return SysSetGroupID(sgid);
    }
 
#else
    if ((rgid != 0) || (egid != 0) || (sgid != 0)) {
        return -EPERM;
    }
    return 0;
#endif
}

函数调用图:

这是这个函数的调用关系图:

SysSetRealEffSaveUserID()

int SysSetRealEffSaveUserID	(	int	ruid,
		int	euid,
		int	suid
	)

在文件 process_syscall.c 第 530 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    int ret;
 
    if ((ruid == -1) && (euid == -1) && (suid == -1)) {
        return 0;
    }
 
    ret = SetRealEffSaveUserIDCheck(ruid, euid, suid);
    if (ret != 0) {
        return ret;
    }
 
    if (ruid >= 0) {
        if (((euid != -1) && (euid != ruid)) || ((suid != -1) && (suid != ruid))) {
            return -EPERM;
        }
        return SysSetUserID(ruid);
    } else if (euid >= 0) {
        if ((suid != -1) && (suid != euid)) {
            return -EPERM;
        }
        return SysSetUserID(euid);
    } else {
        return SysSetUserID(suid);
    }
#else
    if ((ruid != 0) || (euid != 0) || (suid != 0)) {
        return -EPERM;
    }
    return 0;
#endif
}

函数调用图:

这是这个函数的调用关系图:

SysSetRealEffUserID()

int SysSetRealEffUserID	(	int	ruid,
		int	euid
	)

在文件 process_syscall.c 第 565 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    return SysSetRealEffSaveUserID(ruid, euid, -1);
#else
    if ((ruid != 0) || (euid != 0)) {
        return -EPERM;
    }
    return 0;
#endif
}

函数调用图:

SysSetrlimit()

int SysSetrlimit	(	int	resource,
		unsigned long long	k_rlim[2]
	)

在文件 misc_syscall.c 第 228 行定义.

{
    int ret;
    struct rlimit lim;
 
    if(!IsCapPermit(CAP_CAPSET)) {
        return -EPERM;
    }
 
    ret = LOS_ArchCopyFromUser(&lim, k_rlim, sizeof(struct rlimit));
    if (ret != 0) {
        return -EFAULT;
    }
    ret = setrlimit(resource, &lim);
 
    return ret;
}

函数调用图:

SysSetSockOpt()

int SysSetSockOpt	(	int	socket,
		int	level,
		int	optName,
		const void *	optValue,
		socklen_t	optLen
	)

在文件 net_syscall.c 第 348 行定义.

{
    int ret;
 
    SOCKET_U2K(socket);
    CHECK_ASPACE(optValue, optLen);
 
    DUP_FROM_USER(optValue, optLen);
    ret = setsockopt(socket, level, optName, optValue, optLen);
    FREE_DUP(optValue);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysSetThreadArea()

int SysSetThreadArea

(

const char *

area

)

在文件 process_syscall.c 第 902 行定义.

{
    unsigned int intSave;
    int ret = LOS_OK;
 
    if (!LOS_IsUserAddress((unsigned long)(uintptr_t)area)) {
        return EINVAL;
    }
 
    LosTaskCB *taskCB = OsCurrTaskGet();
    SCHEDULER_LOCK(intSave);
    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
    if (processCB->processMode != OS_USER_MODE) {
        ret = EPERM;
        goto OUT;
    }
 
    taskCB->userArea = (unsigned long)(uintptr_t)area;
OUT:
    SCHEDULER_UNLOCK(intSave);
    return ret;
}

函数调用图:

SysSetUserID()

int SysSetUserID

(

int

uid

)

在文件 process_syscall.c 第 477 行定义.

{
#ifdef LOSCFG_SECURITY_CAPABILITY
    int ret = -EPERM;
    unsigned int intSave;
 
    if (uid < 0) {
        return -EINVAL;
    }
 
    SCHEDULER_LOCK(intSave);
    User *user = OsCurrUserGet();
    if (IsCapPermit(CAP_SETUID)) {
        user->userID = uid;
        user->effUserID = uid;
        /* add process to a user */
    } else if (user->userID != uid) {
        goto EXIT;
    }
 
    ret = LOS_OK;
    /* add process to a user */
EXIT:
    SCHEDULER_UNLOCK(intSave);
    return ret;
#else
    if (uid != 0) {
        return -EPERM;
    }
 
    return 0;
#endif
}

函数调用图:

这是这个函数的调用关系图:

SysShellExec()

int SysShellExec	(	const char *	msgName,
		const char *	cmdString
	)

执行 shell 命令

在文件 misc_syscall.c 第 106 行定义.

{ 
    int ret;
    unsigned int uintRet;
    errno_t err;
    CmdParsed cmdParsed;
    char msgNameDup[CMD_KEY_LEN + 1] = { 0 };
    char cmdStringDup[CMD_MAX_LEN + 1] = { 0 };
 
    if (!IsCapPermit(CAP_SHELL_EXEC)) {//1.先鉴权
        return -EPERM;
    }
    //2.由内核栈空间接走用户空间的参数,注意还是同一个任务,只是从任务的用户空间移到内核栈.
    ret = LOS_StrncpyFromUser(msgNameDup, msgName, CMD_KEY_LEN + 1);
    if (ret < 0) {
        return -EFAULT;
    } else if (ret > CMD_KEY_LEN) {
        return -ENAMETOOLONG;
    }
 
    ret = LOS_StrncpyFromUser(cmdStringDup, cmdString, CMD_MAX_LEN + 1);
    if (ret < 0) {
        return -EFAULT;
    } else if (ret > CMD_MAX_LEN) {
        return -ENAMETOOLONG;
    }
 
    err = memset_s(&cmdParsed, sizeof(CmdParsed), 0, sizeof(CmdParsed));
    if (err != EOK) {
        return -EFAULT;
    }
    //获取消息类型
    uintRet = ShellMsgTypeGet(&cmdParsed, msgNameDup);
    if (uintRet != LOS_OK) {
        PRINTK("%s:command not found\n", msgNameDup);
        return -EFAULT;
    } else {
        (void)OsCmdExec(&cmdParsed, (char *)cmdStringDup);//执行shell命令,回调命令注册时的 函数指针
    }
 
    return 0;
}

函数调用图:

SysShmAt()

void * SysShmAt	(	int	shmid,
		const void *	shmaddr,
		int	shmflg
	)

 连接共享内存标识符为shmid的共享内存，连接成功后把共享内存区对象映射到调用进程的地址空间，随后可像本地空间一样访问
 一旦创建/引用了一个共享存储段，那么进程就可调用shmat函数将其连接到它的地址空间中
 如果shmat成功执行，那么内核将使与该共享存储相关的shmid_ds结构中的shm_nattch计数器值加1

参数

shmid
shmaddr
shmflg

返回

void*

在文件 vm_syscall.c 第 152 行定义.

{
    void *ret = NULL;
 
    ret = ShmAt(shmid, shmaddr, shmflg);
    if (ret == (void *)-1) {
        return (void *)(intptr_t)-get_errno();
    }
 
    return ret;
}

函数调用图:

SysShmCtl()

int SysShmCtl	(	int	shmid,
		int	cmd,
		struct shmid_ds *	buf
	)

完成对共享内存的控制 此函数可以对shmid指定的共享存储进行多种操作（删除、取信息、加锁、解锁等）

参数

shmid	共享内存标识符
cmd	IPC_STAT：得到共享内存的状态，把共享内存的shmid_ds结构复制到buf中 IPC_SET：改变共享内存的状态，把buf所指的shmid_ds结构中的uid、gid、mode复制到共享内存的shmid_ds结构内 IPC_RMID：删除这片共享内存
buf	共享内存管理结构体。

返回

int

在文件 vm_syscall.c 第 174 行定义.

{
    int ret;
 
    ret = ShmCtl(shmid, cmd, buf);
    if (ret < 0) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysShmDt()

int SysShmDt

(

const void *

shmaddr

)

与shmat函数相反，是用来断开与共享内存附加点的地址，禁止本进程访问此片共享内存

参数

shmaddr

连接的共享内存的起始地址 本函数调用并不删除所指定的共享内存区，而只是将先前用shmat函数连接（attach）好的共享内存脱离（detach）目前的进程

返回

int 返回值 成功：0 出错：-1，错误原因存于error中

在文件 vm_syscall.c 第 192 行定义.

{
    int ret;
 
    ret = ShmDt(shmaddr);
    if (ret < 0) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysShmGet()

int SysShmGet	(	key_t	key,
		size_t	size,
		int	shmflg
	)

得到一个共享内存标识符或创建一个共享内存对象

参数

key	建立新共享内存对象 标识符是IPC对象的内部名。为使多个合作进程能够在同一IPC对象上汇聚，需要提供一个外部命名方案。 为此，每个IPC对象都与一个键（key）相关联，这个键作为该对象的外部名,无论何时创建IPC结构（通过msgget、semget、shmget创建）， 都应给IPC指定一个键, key_t由ftok创建,ftok当然在本工程里找不到,所以要写这么多.
size	新建的共享内存大小，以字节为单位
shmflg	IPC_CREAT IPC_EXCL IPC_CREAT： 在创建新的IPC时，如果key参数是IPC_PRIVATE或者和当前某种类型的IPC结构无关，则需要指明flag参数的IPC_CREAT标志位， 则用来创建一个新的IPC结构。（如果IPC结构已存在，并且指定了IPC_CREAT，则IPC_CREAT什么都不做，函数也不出错） IPC_EXCL： 此参数一般与IPC_CREAT配合使用来创建一个新的IPC结构。如果创建的IPC结构已存在函数就出错返回， 返回EEXIST（这与open函数指定O_CREAT和O_EXCL标志原理相同）

返回

int

在文件 vm_syscall.c 第 129 行定义.

{
    int ret;
 
    ret = ShmGet(key, size, shmflg);
    if (ret < 0) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysShutdown()

int SysShutdown	(	int	socket,
		int	how
	)

在文件 net_syscall.c 第 335 行定义.

{
    int ret;
 
    SOCKET_U2K(socket);
    ret = shutdown(socket, how);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysSigAction()

int SysSigAction	(	int	sig,
		const sigaction_t *restrict	sa,
		sigaction_t *restrict	old,
		size_t	sigsetsize
	)

注册信号,鸿蒙内核只捕捉了SIGSYS 信号

在文件 ipc_syscall.c 第 274 行定义.

{
    return OsSigAction(sig, sa, old);
}

函数调用图:

SysSigPending()

int SysSigPending

(

sigset_t_l *

setl

)

获取阻塞当前任务的信号集

在文件 ipc_syscall.c 第 355 行定义.

{
    sigset_t set;
    int ret;
 
    ret = LOS_ArchCopyFromUser(&set, &(setl->sig[0]), sizeof(sigset_t));
    if (ret != 0) {
        return -EFAULT;
    }
    ret = OsSigPending(&set);
    if (ret != LOS_OK) {
        return ret;
    }
    ret = LOS_ArchCopyToUser(&(setl->sig[0]), &set, sizeof(sigset_t));
    if (ret != LOS_OK) {
        return -EFAULT;
    }
    return ret;
}

函数调用图:

SysSigprocMask()

int SysSigprocMask	(	int	how,
		const sigset_t_l *restrict	setl,
		sigset_t_l *restrict	oldl,
		size_t	sigsetsize
	)

系统调用之进程信号屏蔽, 什么意思?简单说就是 一个信号来了进程要不要处理,屏蔽就是不处理,注意不能屏蔽SIGKILL和SIGSTOP信号,必须要处理.

参数

how	SIG_BLOCK 加入信号到进程屏蔽。set包含了希望阻塞的附加信号 SIG_UNBLOCK 从进程屏蔽里将信号删除。set包含了希望解除阻塞的信号 SIG_SETMASK 将set的值设定为新的进程屏蔽
setl
oldl
sigsetsize

返回

int

在文件 ipc_syscall.c 第 290 行定义.

{
    CHECK_ASPACE(setl, sizeof(sigset_t_l));
    CHECK_ASPACE(oldl, sizeof(sigset_t_l));
    CPY_FROM_USER(setl);
    CPY_FROM_USER(oldl);
    /* Let OsSigprocMask do all of the work */
    int ret = OsSigprocMask(how, setl, oldl);
    CPY_TO_USER(oldl);
    return ret;
}

函数调用图:

SysSigSuspend()

int SysSigSuspend

(

sigset_t_l *

setl

)

在文件 ipc_syscall.c 第 375 行定义.

{
    sigset_t set;
    int retVal;
 
    retVal = LOS_ArchCopyFromUser(&set, &(setl->sig[0]), sizeof(sigset_t));
    if (retVal != 0) {
        return -EFAULT;
    }
 
    return OsSigSuspend(&set);
}

函数调用图:

SysSigTimedWait()

int SysSigTimedWait	(	const sigset_t_l *	setl,
		siginfo_t *	info,
		const struct timespec *	timeout,
		size_t	sigsetsize
	)

在文件 ipc_syscall.c 第 312 行定义.

{
    sigset_t set;
    unsigned int tick;
    int retVal, ret;
    siginfo_t infoIntr;
    struct timespec timeoutIntr;
 
    retVal = LOS_ArchCopyFromUser(&set, &(setl->sig[0]), sizeof(sigset_t));
    if (retVal != 0) {
        return -EFAULT;
    }
 
    if (timeout == NULL) {
        tick = LOS_WAIT_FOREVER;
    } else {
        retVal = LOS_ArchCopyFromUser(&timeoutIntr, timeout, sizeof(struct timespec));
        if (retVal != 0) {
            return -EFAULT;
        }
        if (!ValidTimeSpec(&timeoutIntr)) {
            return -EINVAL;
        }
        tick = OsTimeSpec2Tick(&timeoutIntr);
    }
    ret = OsSigTimedWait(&set, &infoIntr, tick);
    if (ret < 0) {
        return ret;
    }
    if (info != NULL) {
        retVal = LOS_ArchCopyToUser(info, &infoIntr, sizeof(siginfo_t));
        if (retVal != 0) {
            return -EFAULT;
        }
    }
    return (ret == 0 ? infoIntr.si_signo : ret);
}

函数调用图:

SysSocket()

int SysSocket	(	int	domain,
		int	type,
		int	protocol
	)

在文件 net_syscall.c 第 66 行定义.

{
    int ret;
 
    ret = socket(domain, type, protocol);
    if (ret == -1) {
        return -get_errno();
    }
 
    SOCKET_K2U(ret);
    return ret;
}

函数调用图:

SysStat()

int SysStat	(	const char *	path,
		struct kstat *	buf
	)

获取文件状态信息

在文件 fs_syscall.c 第 1339 行定义.

{
    int ret;
    char *pathRet = NULL;
    struct stat bufRet = {0};
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = stat((path ? pathRet : NULL), (buf ? (&bufRet) : NULL));
    if (ret < 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
    if (ret != 0) {
        ret = -EFAULT;
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysStatfs()

int SysStatfs	(	const char *	path,
		struct statfs *	buf
	)

获取指定路径下文件的文件系统信息

在文件 fs_syscall.c 第 1272 行定义.

{
    int ret;
    char *pathRet = NULL;
    struct statfs bufRet = {0};
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = statfs((path ? pathRet : NULL), (buf ? (&bufRet) : NULL));
    if (ret < 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct statfs));
    if (ret != 0) {
        ret = -EFAULT;
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysStatfs64()

int SysStatfs64	(	const char *	path,
		size_t	sz,
		struct statfs *	buf
	)

获取文件系统信息

在文件 fs_syscall.c 第 1303 行定义.

{
    int ret;
    char *pathRet = NULL;
    struct statfs bufRet = {0};
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (sz != sizeof(*buf)) {
        ret = -EINVAL;
        goto OUT;
    }
 
    ret = statfs((path ? pathRet : NULL), (buf ? (&bufRet) : NULL));
    if (ret < 0) {
        ret = -get_errno();
        goto OUT;
    }
 
    ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct statfs));
    if (ret != 0) {
        ret = -EFAULT;
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysStatx()

int SysStatx	(	int	fd,
		const char *restrict	path,
		int	flag,
		unsigned	mask,
		struct statx *restrict	stx
	)

在文件 fs_syscall.c 第 1432 行定义.

{
    return -ENOSYS;
}

SysSymlink()

int SysSymlink	(	const char *	target,
		const char *	linkpath
	)

在文件 fs_syscall.c 第 474 行定义.

{
    int ret;
    char *targetRet = NULL;
    char *pathRet = NULL;
 
    if (target != NULL) {
        ret = UserPathCopy(target, &targetRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (linkpath != NULL) {
        ret = UserPathCopy(linkpath, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = symlink(targetRet, pathRet);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
 
    if (targetRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, targetRet);
    }
    return ret;
}

函数调用图:

SysSymlinkat()

int SysSymlinkat	(	const char *	target,
		int	dirfd,
		const char *	linkpath
	)

在文件 fs_syscall.c 第 1915 行定义.

{
    int ret;
    char *pathRet = NULL;
    char *targetRet = NULL;
 
    if (target != NULL) {
        ret = UserPathCopy(target, &targetRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (linkpath != NULL) {
        ret = UserPathCopy(linkpath, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (dirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        dirfd = GetAssociatedSystemFd(dirfd);
    }
 
    ret = symlinkat(targetRet, dirfd, pathRet);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
 
    if (targetRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, targetRet);
    }
    return ret;
}

函数调用图:

SysSync()

void SysSync

(

void

)

将内存缓冲区数据写回硬盘

在文件 syscall_lookup.h 第 62 行定义.

SysSysconf()

long SysSysconf

(

int

name

)

系统配置

在文件 misc_syscall.c 第 198 行定义.

{
    long ret;
 
    ret = sysconf(name);
    if (ret == -1) {
        return -get_errno();
    }
 
    return ret;
}

函数调用图:

SysThreadExit()

void SysThreadExit

(

int

status

)

在文件 process_syscall.c 第 1005 行定义.

{
    OsRunningTaskToExit(OsCurrTaskGet(), (unsigned int)status);
}

函数调用图:

SysThreadJoin()

int SysThreadJoin

(

unsigned int

taskID

)

在文件 process_syscall.c 第 976 行定义.

{
    unsigned int intSave;
    int ret;
 
    if (OS_TID_CHECK_INVALID(taskID)) {
        return EINVAL;
    }
 
    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
    SCHEDULER_LOCK(intSave);
    ret = OsUserTaskOperatePermissionsCheck(taskCB);
    if (ret != LOS_OK) {
        goto EXIT;
    }
 
    ret = (int)OsTaskJoinPendUnsafe(OS_TCB_FROM_TID(taskID));
 
EXIT:
    SCHEDULER_UNLOCK(intSave);
    return ret;
}

函数调用图:

SysTime()

time_t SysTime

(

time_t *

tloc

)

在文件 time_syscall.c 第 90 行定义.

{
    int ret;
    time_t stloc;
 
    ret = time(tloc ? &stloc : NULL);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (tloc && LOS_ArchCopyToUser(tloc, &stloc, sizeof(time_t))) {
        errno = EFAULT;
        ret = -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysTimerCreate()

int SysTimerCreate	(	clockid_t	clockID,
		struct ksigevent *	evp,
		timer_t *	timerID
	)

在文件 time_syscall.c 第 160 行定义.

{
    int ret;
    timer_t stimerID;
    struct ksigevent ksevp;
 
    if (timerID == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    if (evp && LOS_ArchCopyFromUser(&ksevp, evp, sizeof(struct ksigevent))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    ret = OsTimerCreate(clockID, evp ? &ksevp : NULL, &stimerID);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (LOS_ArchCopyToUser(timerID, &stimerID, sizeof(timer_t))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysTimerDelete()

int SysTimerDelete

(

timer_t

timerID

)

在文件 time_syscall.c 第 252 行定义.

{
    int ret;
 
    ret = timer_delete(timerID);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysTimerGetoverrun()

int SysTimerGetoverrun

(

timer_t

timerID

)

在文件 time_syscall.c 第 241 行定义.

{
    int ret;
 
    ret = timer_getoverrun(timerID);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysTimerGettime()

int SysTimerGettime	(	timer_t	timerID,
		struct itimerspec *	value
	)

在文件 time_syscall.c 第 189 行定义.

{
    int ret;
    struct itimerspec svalue;
 
    if (value == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    ret = timer_gettime(timerID, &svalue);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (LOS_ArchCopyToUser(value, &svalue, sizeof(struct itimerspec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysTimerGettime64()

int SysTimerGettime64	(	timer_t	timerID,
		struct itimerspec64 *	value
	)

在文件 time_syscall.c 第 524 行定义.

{
    int ret;
    struct itimerspec val;
    struct itimerspec64 svalue;
 
    if (value == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    ret = timer_gettime(timerID, &val);
    if (ret < 0) {
        return -get_errno();
    }
 
    svalue.it_interval.tv_sec = val.it_interval.tv_sec;
    svalue.it_interval.tv_nsec = val.it_interval.tv_nsec;
    svalue.it_value.tv_sec = val.it_value.tv_sec;
    svalue.it_value.tv_nsec = val.it_value.tv_nsec;
 
    if (LOS_ArchCopyToUser(value, &svalue, sizeof(struct itimerspec64))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysTimerSettime()

int SysTimerSettime	(	timer_t	timerID,
		int	flags,
		const struct itimerspec *	value,
		struct itimerspec *	oldValue
	)

在文件 time_syscall.c 第 212 行定义.

{
    int ret;
    struct itimerspec svalue;
    struct itimerspec soldValue;
 
    if (value == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    if (LOS_ArchCopyFromUser(&svalue, value, sizeof(struct itimerspec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    ret = timer_settime(timerID, flags, &svalue, &soldValue);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (oldValue && LOS_ArchCopyToUser(oldValue, &soldValue, sizeof(struct itimerspec))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysTimerSettime64()

int SysTimerSettime64	(	timer_t	timerID,
		int	flags,
		const struct itimerspec64 *	value,
		struct itimerspec64 *	oldValue
	)

在文件 time_syscall.c 第 553 行定义.

{
    int ret;
    struct itimerspec val;
    struct itimerspec oldVal;
    struct itimerspec64 svalue;
    struct itimerspec64 soldValue;
 
    if (value == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    if (LOS_ArchCopyFromUser(&svalue, value, sizeof(struct itimerspec64))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    if (svalue.it_interval.tv_sec > UINT32_MAX || svalue.it_value.tv_sec > UINT32_MAX) {
        errno = ENOSYS;
        return -ENOSYS;
    }
 
    val.it_interval.tv_sec = svalue.it_interval.tv_sec;
    val.it_interval.tv_nsec = svalue.it_interval.tv_nsec;
    val.it_value.tv_sec = svalue.it_value.tv_sec;
    val.it_value.tv_nsec = svalue.it_value.tv_nsec;
 
    ret = timer_settime(timerID, flags, &val, oldValue ? &oldVal : NULL);
    if (ret < 0) {
        return -get_errno();
    }
 
    if (oldValue != NULL) {
        soldValue.it_interval.tv_sec = oldVal.it_interval.tv_sec;
        soldValue.it_interval.tv_nsec = oldVal.it_interval.tv_nsec;
        soldValue.it_value.tv_sec = oldVal.it_value.tv_sec;
        soldValue.it_value.tv_nsec = oldVal.it_value.tv_nsec;
 
        if (LOS_ArchCopyToUser(oldValue, &soldValue, sizeof(struct itimerspec64))) {
            errno = EFAULT;
            return -EFAULT;
        }
    }
 
    return ret;
}

函数调用图:

SysTimes()

clock_t SysTimes

(

struct tms *

buf

)

在文件 time_syscall.c 第 384 行定义.

{
    clock_t ret;
    struct tms sbuf;
 
    if (buf == NULL) {
        errno = EFAULT;
        return -EFAULT;
    }
    ret = times(&sbuf);
    if (ret == -1) {
        return -get_errno();
    }
    if (LOS_ArchCopyToUser(buf, &sbuf, sizeof(struct tms))) {
        errno = EFAULT;
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysTruncate()

int SysTruncate	(	const char *	path,
		off_t	length
	)

系统调用|文件系统|截断功能

在文件 fs_syscall.c 第 1192 行定义.

{
    int ret;
    int fd = -1;
    char *pathRet = NULL;
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    fd = open((path ? pathRet : NULL), O_RDWR);
    if (fd < 0) {
        /* The errno value has already been set */
        ret = -get_errno();
        goto OUT;
    }
 
    ret = ftruncate(fd, length);
    close(fd);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysTruncate64()

int SysTruncate64	(	const char *	path,
		off64_t	length
	)

系统调用|文件系统|截断功能

在文件 fs_syscall.c 第 1225 行定义.

{
    int ret;
    int fd = -1;
    char *pathRet = NULL;
 
    if (path != NULL) {
        ret = UserPathCopy(path, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    fd = open((path ? pathRet : NULL), O_RDWR);
    if (fd < 0) {
        /* The errno value has already been set */
        ret = -get_errno();
        goto OUT;
    }
 
    ret = ftruncate64(fd, length);
    close(fd);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysUgetrlimit()

int SysUgetrlimit	(	int	resource,
		unsigned long long	k_rlim[2]
	)

在文件 misc_syscall.c 第 210 行定义.

{
    int ret;
    struct rlimit lim;
 
    ret = getrlimit(resource, &lim);
    if (ret < 0) {
        return ret;
    }
 
    ret = LOS_ArchCopyToUser(k_rlim, &lim, sizeof(struct rlimit));
    if (ret != 0) {
        return -EFAULT;
    }
 
    return ret;
}

函数调用图:

SysUmask()

int SysUmask

(

int

mask

)

SysUmount()

int SysUmount

(

const char *

target

)

卸载文件系统,当某个文件系统不需要再使用了，那么可以将它卸载掉。

在文件 fs_syscall.c 第 734 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (!IsCapPermit(CAP_FS_MOUNT)) {
        return -EPERM;
    }
 
    if (target != NULL) {
        ret = UserPathCopy(target, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    ret = umount(target ? pathRet : NULL);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

SysUmount2()

int SysUmount2	(	const char *	target,
		int	flags
	)

卸载文件系统

在文件 fs_syscall.c 第 894 行定义.

{
    if (flags != 0) {
        return -EINVAL;
    }
    return SysUmount(target);
}

函数调用图:

SysUname()

int SysUname

(

struct utsname *

name

)

在文件 misc_syscall.c 第 52 行定义.

{
    int ret;
    struct utsname tmpName;
    ret = LOS_ArchCopyFromUser(&tmpName, name, sizeof(struct utsname));
    if (ret != 0) {
        return -EFAULT;
    }
    ret = uname(&tmpName);
    if (ret < 0) {
        return ret;
    }
    ret = LOS_ArchCopyToUser(name, &tmpName, sizeof(struct utsname));
    if (ret != 0) {
        return -EFAULT;
    }
    return ret;
}

函数调用图:

SysUnlink()

int SysUnlink

(

const char *

pathname

)

删除链:删除由装入点管理的文件

   执行unlink()函数并不一定会真正的删除文件，它先会检查文件系统中此文件的连接数是否为1，
   如果不是1说明此文件还有其他链接对象，因此只对此文件的连接数进行减1操作。若连接数为1，
   并且在此时没有任何进程打开该文件，此内容才会真正地被删除掉。在有进程打开此文件的情况下，
   则暂时不会删除，直到所有打开该文件的进程都结束时文件就会被删除。
* 

在文件 fs_syscall.c 第 519 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
    //删除由装入点管理的文件
    ret = do_unlink(AT_FDCWD, (pathname ? pathRet : NULL));
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysUnlinkat()

int SysUnlinkat	(	int	dirfd,
		const char *	pathname,
		int	flag
	)

在文件 fs_syscall.c 第 1994 行定义.

{
    int ret;
    char *pathRet = NULL;
 
    if (pathname != NULL) {
        ret = UserPathCopy(pathname, &pathRet);
        if (ret != 0) {
            goto OUT;
        }
    }
 
    if (dirfd != AT_FDCWD) {
        /* Process fd convert to system global fd */
        dirfd = GetAssociatedSystemFd(dirfd);
    }
 
    ret = unlinkat(dirfd, (pathname ? pathRet : NULL), flag);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT:
    if (pathRet != NULL) {
        (void)LOS_MemFree(OS_SYS_MEM_ADDR, pathRet);
    }
    return ret;
}

函数调用图:

SysUserExitGroup()

void SysUserExitGroup

(

int

status

)

在文件 process_syscall.c 第 999 行定义.

{
    (void)status;
    OsProcessThreadGroupDestroy();
}

函数调用图:

SysUserThreadDetach()

int SysUserThreadDetach

(

unsigned int

taskID

)

在文件 process_syscall.c 第 953 行定义.

{
    unsigned int intSave;
    int ret;
 
    if (OS_TID_CHECK_INVALID(taskID)) {
        return EINVAL;
    }
 
    SCHEDULER_LOCK(intSave);
    ret = OsUserTaskOperatePermissionsCheck(OS_TCB_FROM_TID(taskID));
    SCHEDULER_UNLOCK(intSave);
    if (ret != LOS_OK) {
        return ret;
    }
 
    if (LOS_TaskDelete(taskID) != LOS_OK) {
        return ESRCH;
    }
 
    return LOS_OK;
}

函数调用图:

SysUserThreadSetDetach()

int SysUserThreadSetDetach

(

unsigned int

taskID

)

在文件 process_syscall.c 第 930 行定义.

{
    unsigned int intSave;
    int ret;
 
    if (OS_TID_CHECK_INVALID(taskID)) {
        return EINVAL;
    }
 
    LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
    SCHEDULER_LOCK(intSave);
    ret = OsUserTaskOperatePermissionsCheck(taskCB);
    if (ret != LOS_OK) {
        goto EXIT;
    }
 
    ret = (int)OsTaskSetDetachUnsafe(taskCB);
 
EXIT:
    SCHEDULER_UNLOCK(intSave);
    return ret;
}

函数调用图:

SysUtime()

int SysUtime	(	const char *	path,
		const struct utimbuf *	ptimes
	)

在文件 time_syscall.c 第 45 行定义.

{
    int ret;
    char *spath = NULL;
    struct utimbuf sptimes;
 
    if (path == NULL) {
        errno = EINVAL;
        return -EINVAL;
    }
 
    spath = LOS_MemAlloc(m_aucSysMem0, PATH_MAX + 1);
    if (spath == NULL) {
        errno = ENOMEM;
        return -ENOMEM;
    }
 
    ret = LOS_StrncpyFromUser(spath, path, PATH_MAX + 1);
    if (ret == -EFAULT) {
        LOS_MemFree(m_aucSysMem0, spath);
        return ret;
    } else if (ret > PATH_MAX) {
        LOS_MemFree(m_aucSysMem0, spath);
        PRINT_ERR("%s[%d], path exceeds maxlen: %d\n", __FUNCTION__, __LINE__, PATH_MAX);
        return -ENAMETOOLONG;
    }
    spath[ret] = '\0';
 
    if (ptimes && LOS_ArchCopyFromUser(&sptimes, ptimes, sizeof(struct utimbuf))) {
        LOS_MemFree(m_aucSysMem0, spath);
        errno = EFAULT;
        return -EFAULT;
    }
 
    ret = utime(spath, ptimes ? &sptimes : NULL);
    if (ret < 0) {
        ret = -get_errno();
    }
 
    LOS_MemFree(m_aucSysMem0, spath);
 
    return ret;
}

函数调用图:

SysUtimensat()

int SysUtimensat	(	int	fd,
		const char *	path,
		struct timespec	times[2],
		int	flag
	)

SysVfork()

int SysVfork

(

void

)

在文件 syscall_lookup.h 第 141 行定义.

函数调用图:

SysWait()

int SysWait	(	int	pid,
		USER int *	status,
		int	options,
		void *	rusage
	)

在文件 process_syscall.c 第 307 行定义.

{
    (void)rusage;
 
    return LOS_Wait(pid, status, (unsigned int)options, NULL);
}

函数调用图:

SysWaitid()

int SysWaitid	(	idtype_t	type,
		int	pid,
		USER siginfo_t *	info,
		int	options,
		void *	rusage
	)

在文件 process_syscall.c 第 314 行定义.

{
    (void)rusage;
    int ret;
    int truepid = 0;
 
    switch (type) {
        case P_ALL:
            /* Wait for any child; id is ignored. */
            truepid = -1;
            break;
        case P_PID:
            /* Wait for the child whose process ID matches id */
            if (pid <= 0) {
                return -EINVAL;
            }
            truepid = pid;
            break;
        case P_PGID:
            /* Wait for any child whose process group ID matches id */
            if (pid <= 1) {
                return -EINVAL;
            }
            truepid = -pid;
            break;
        default:
            return -EINVAL;
    }
 
    ret = LOS_Waitid(truepid, info, (unsigned int)options, NULL);
    if (ret > 0) {
        ret = 0;
    }
    return ret;
}

函数调用图:

SysWrite()

ssize_t SysWrite	(	int	fd,
		const void *	buf,
		size_t	nbytes
	)

系统调用|写文件:将buf中(用户空间)nbytes长度的内容写到文件中

在文件 fs_syscall.c 第 273 行定义.

{
    int ret;
 
    if (nbytes == 0) {
        return 0;
    }
    //[buf,buf+nbytes]地址必须在用户空间
    if (!LOS_IsUserAddressRange((vaddr_t)(UINTPTR)buf, nbytes)) {
        return -EFAULT;
    }
 
    /* Process fd convert to system global fd */
    int sysfd = GetAssociatedSystemFd(fd);
    ret = write(sysfd, buf, nbytes);
    if (ret < 0) {
        return -get_errno();
    }
    return ret;
}

函数调用图:

SysWritev()

ssize_t SysWritev	(	int	fd,
		const struct iovec *	iov,
		int	iovcnt
	)

将缓冲数组里的数据写入文件

在文件 fs_syscall.c 第 1500 行定义.

{
    int ret;
    int valid_iovcnt = -1;
    struct iovec *iovRet = NULL;
 
    /* Process fd convert to system global fd */
    int sysfd = GetAssociatedSystemFd(fd);
    if ((iovcnt < 0) || (iovcnt > IOV_MAX)) {
        return -EINVAL;
    }
 
    if (iovcnt == 0) {
        return 0;
    }
 
    if (iov == NULL) {
        return -EFAULT;
    }
 
    ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
    if (ret != 0) {
        return ret;
    }
 
    if (valid_iovcnt != iovcnt) {
        ret = -EFAULT;
        goto OUT_FREE;
    }
 
    ret = writev(sysfd, iovRet, valid_iovcnt);
    if (ret < 0) {
        ret = -get_errno();
    }
 
OUT_FREE:
    (void)LOS_MemFree(OS_SYS_MEM_ADDR, iovRet);
    return ret;
}

函数调用图: