linux系统调用相关头文件
linux下ecall用法
linux下ecall用法
在Linux下,ecall是用于执行系统调用的一种机制。
系统调用是操作系统提供给应用程序的接口,用于访问操作系统内核提供的服务。
通过ecall,应用程序可以调用系统调用并与之交互。
在Linux中,ecall的使用通常涉及到以下几个步骤:
1.包含头文件:在程序中包含必要的头文件,以便使用ecall机制。
通常情况下,需要包含<sys/syscall.h>头文件。
2.定义系统调用号:在程序中定义系统调用的编号。
系统调用号是一个整数值,用于标识特定的系统调用。
可以在头文件中找到系统调用号的定义。
3.调用ecall函数:在程序中使用ecall函数来执行系统调用。
ecall函数的原型如下:
long ecall(long num, long arg1, long arg2, long arg3, long arg4, long arg5);
其中,num参数指定要执行的系统调用编号,其他参数是传递给系统调用的参数。
4.处理返回值:ecall函数将返回系统调用的结果。
根据不同的系统调用,返回值的意义可能不同。
可以通过检查返回值来处理系统调用的结果。
需要注意的是,ecall函数是低级函数,通常用于与内核交互。
在实际的应用程序开发中,更常用的是高级的系统调用接口,如open(), read(), write(), close()等函数。
这些函数提供了更高级别的抽象,使得程序更加易于使用和管理。
newfstatat函数
newfstatat函数newfstatat函数是Linux系统的一个系统调用函数,其主要功能是获取某个文件的信息,如文件大小、访问权限、修改时间等属性。
它可以通过文件路径或描述符来访问文件,并将文件信息保存到一个结构体中。
下面,我们来分步骤阐述newfstatat函数的使用过程:步骤一:包含头文件和定义结构体在使用newfstatat函数前,我们需要包含相关头文件。
因为newfstatat函数返回一个结构体,我们需要定义一个结构体来存储文件的信息。
头文件包含可以使用如下代码:```#include <linux/stat.h>```结构体定义可以使用如下代码:```struct stat file_stat;```步骤二:调用newfstatat函数newfstatat函数的调用格式如下:```int newfstatat(int dirfd, const char *pathname, struct stat *buf, int flags);```其中,dirfd表示要访问文件的目录的描述符,pathname表示要访问的文件路径,buf表示指向一个结构体的指针,用来存储文件的信息,flags表示选项,一般为0即可。
newfstatat函数的返回值为0表示调用成功,-1表示出现错误,此时errno会设置相应的错误码。
步骤三:获取文件信息当函数调用成功返回后,我们可以通过访问结构体中的成员来获取文件的信息。
文件大小可以通过file_stat.st_size成员来获取,访问权限可以通过file_stat.st_mode成员获取,修改时间可以通过file_stat.st_mtime成员来获取。
例:```struct stat file_stat;if (newfstatat(dirfd, filepath, &file_stat, 0) == 0) {printf("File size: %ld\n", file_stat.st_size);printf("File mode: %o\n", file_stat.st_mode);printf("Modified time: %ld\n", file_stat.st_mtime);}```至此,我们完成了使用newfstatat函数获取文件信息的过程。
cap_capset解析
cap_capset解析在Linux系统中,`cap_capset`通常是与Linux 内核中的能力(capabilities)相关的系统调用(syscall)有关的一个概念。
Linux 能力是Linux 内核引入的一种权限管理机制,它允许细粒度地分配权限,使得特定进程能够执行一些通常需要超级用户权限的操作,而无需完全提升为超级用户。
`cap_capset` 是设置和修改进程的能力集的系统调用。
以下是有关`cap_capset` 的简要解释:1. 系统调用名称:`cap_capset`2. 系统调用编号:`#include <linux/capability.h>` 中定义了`CAPSET` 的常量值,表示`cap_capset` 这个系统调用的编号。
3. 功能:`cap_capset` 系统调用用于在一个进程中设置或修改能力集。
能力集是一组权限标志,表示进程在执行时拥有的特权。
通过`cap_capset` 调用,可以修改进程的能力集,使其具有或去除特定的权限。
4. 参数:- `header`: 包含权限集合的数据结构。
- `dataptr`: 指向数据块的指针,其中包含有关权限的信息。
- `datalen`: 数据块的长度。
5. 返回值:返回0 表示成功,其他值表示错误。
6. 头文件:`<linux/capability.h>` 包含有关Linux 能力的定义。
7. 使用示例:```c#include <linux/capability.h>#include <sys/capability.h>#include <unistd.h>int main() {cap_t caps = cap_get_proc();cap_value_t cap_list[1] = {CAP_NET_RAW};cap_set_flag(caps, CAP_EFFECTIVE, 1, cap_list, CAP_SET);cap_set_flag(caps, CAP_PERMITTED, 1, cap_list, CAP_SET);cap_set_proc(caps);// 现在,进程应该具有CAP_NET_RAW 能力。
linux backtrace机制 -回复
linux backtrace机制-回复Linux Backtrace机制是一种用于调试和诊断操作系统内核和用户空间程序的技术。
它允许开发人员追踪程序执行期间的函数调用堆栈,从而帮助定位和分析潜在的错误和异常。
本文将一步一步地介绍Linux Backtrace 的原理、使用方法和实际应用。
首先,我们来了解一下Backtrace的概念。
Backtrace是指在程序运行时记录下函数的调用堆栈信息。
当程序发生错误或异常时,通过查看堆栈信息,可以得知程序执行到此处时,经过了哪些函数调用。
这对于程序员来说是非常有用的,因为它可以帮助他们理解程序的执行流程,从而更好地排查和修复错误。
Backtrace主要可以分为两种类型:用户空间的Backtrace和内核空间的Backtrace。
用户空间的Backtrace用于跟踪用户空间程序的函数调用堆栈,而内核空间的Backtrace则用于跟踪内核模块或驱动程序的函数调用堆栈。
本文将重点讨论用户空间的Backtrace机制。
在Linux系统中,我们可以使用一些工具和函数来实现Backtrace。
其中最常用的是GNU glibc库提供的backtrace()函数和backtrace_symbols()函数。
backtrace()函数用于获取当前线程的函数调用堆栈,并将其保存在一个指定大小的堆栈帧数组中。
backtrace_symbols()函数则用于将堆栈帧数组的内容转化为可读的字符串形式,以供打印和分析。
接下来,我们来看一下使用Backtrace的步骤。
第一步是引入相关的头文件。
在使用Backtrace时,我们需要包含<execinfo.h>头文件。
第二步是调用backtrace()函数。
backtrace()函数接受一个void参数和一个整数参数。
第一个参数是一个指针数组,用于保存函数调用堆栈的地址,第二个参数是一个整数,用于指定保存的最大帧数。
backtrace()函数会根据参数指定的帧数,将函数调用堆栈的地址保存在指针数组中。
Linux内核目录文件简介
Linux V0.11目录文件简介●Makefile文件:该文件是编译辅助工具软件make的参数配置文件。
●boot目录:功能是当计算机加电时引导内核启动,将内核代码加载到内存中,并做一些进入入32位保护运行方式前的系统初始化工作。
①Bootsect.s:磁盘引导块程序,驻留磁盘第一个扇区。
0x7C00②Setup.s:读取机器的硬件配置参数,并把内核模块system移动到适当的内存位置处。
③Head.s:被编译连接在system模块的最前部分,主要进行硬件设备的探测设置和内存管理页面的初始设置工作。
●fs目录:文件系统实现程序的目录。
1、file_table.c文件中,目前仅定义了一个文件句柄(描述符)结构数组。
2、ioctl.c文件将引用kernel/chr_dev/tty.c中的函数,实现字符设备的io控制功能。
3、exec.c程序主要包含一个执行程序函数do_execve(),它是所有exec()函数簇中的主要函数。
4、fcntl.c程序用于实现文件i/o控制的系统调用函数。
5、read_write.c程序用于实现文件读/写和定位三个系统调用函数。
6、stat.c程序中实现了两个获取文件状态的系统调用函数。
7、open.c程序主要包含实现修改文件属性和创建与关闭文件的系统调用函数。
8、char_dev.c主要包含字符设备读写函数rw_char()。
9、pipe.c程序中包含管道读写函数和创建管道的系统调用。
10、file_dev.c程序中包含基于i节点和描述符结构的文件读写函数。
11、namei.c程序主要包括文件系统中目录名和文件名的操作函数和系统调用函数。
12、block_dev.c程序包含块数据读和写函数。
13、inode.c程序中包含针对文件系统i节点操作的函数。
14、truncate.c程序用于在删除文件时释放文件所占用的设备数据空间。
15、bitmap.c程序用于处理文件系统中i节点和逻辑数据块的位图。
linux header file
1 Linux内核所在目录为/usr/src/kernels/...2 Linux头文件所在目录为/usr/include/...3 找不见头文件可以用find命令查找find / -name *.hlinux常用头文件如下:POSIX标准定义的头文件<dirent.h> 目录项<fcntl.h> 文件控制read,write,fcntl,close,link,stat,umask,unlink,fopen O_RDONLY O_WRONLY O_NONBLOCK等。
<fnmatch.h> 文件名匹配类型<glob.h> 路径名模式匹配类型<grp.h> 组文件<netdb.h> 网络数据库操作<pwd.h> 口令文件<regex.h> 正则表达式<tar.h> TAR归档值<termios.h> 终端I/O<unistd.h> 符号常量unix standard header ->unistd.h,STDIN_FILENO,STDOUT_FILENO <utime.h> 文件时间<wordexp.h> 字符扩展类型-------------------------<arpa/inet.h> INTERNET定义<net/if.h> 套接字本地接口<netinet/in.h> INTERNET地址族<netinet/tcp.h> 传输控制协议定义-------------------------<sys/mman.h> 内存管理声明<sys/select.h> Select函数<sys/socket.h> 套接字借口<sys/stat.h> 文件状态<sys/times.h> 进程时间<sys/types.h> 基本系统数据类型例如:size_t(signed int) off_t(long)<sys/un.h> UNIX域套接字定义<sys/utsname.h> 系统名<sys/wait.h> 进程控制------------------------------POSIX定义的XSI扩展头文件<cpio.h> cpio归档值<dlfcn.h> 动态链接<fmtmsg.h> 消息显示结构<ftw.h> 文件树漫游<iconv.h> 代码集转换使用程序<langinfo.h> 语言信息常量<libgen.h> 模式匹配函数定义<monetary.h> 货币类型<ndbm.h> 数据库操作<nl_types.h> 消息类别<poll.h> 轮询函数<search.h> 搜索表<strings.h> 字符串操作<syslog.h> 系统出错日志记录<ucontext.h> 用户上下文<ulimit.h> 用户限制<utmpx.h> 用户帐户数据库-----------------------------<sys/ipc.h> IPC(命名管道)<sys/msg.h> 消息队列<sys/resource.h>资源操作<sys/sem.h> 信号量<sys/shm.h> 共享存储<sys/statvfs.h> 文件系统信息<sys/time.h> 时间类型<sys/timeb.h> 附加的日期和时间定义<sys/uio.h> 矢量I/O操作------------------------------POSIX定义的可选头文件<aio.h> 异步I/O<mqueue.h> 消息队列<pthread.h> 线程<sched.h> 执行调度<semaphore.h> 信号量<spawn.h> 实时spawn接口<stropts.h> XSI STREAMS接口<trace.h> 事件跟踪3、C/C++头文件一览C#include<assert.h> //设定插入点#include<ctype.h> //字符处理#include<errno.h> //定义错误码#include<float.h> //浮点数处理#include<iso646.h> //对应各种运算符的宏#include<limits.h> //定义各种数据类型最值的常量#include<locale.h> //定义本地化C函数#include<math.h> //定义数学函数#include<setjmp.h> //异常处理支持#include<signal.h> //信号机制支持#include<stdarg.h> //不定参数列表支持#include<stddef.h> //常用常量#include<stdio.h> //定义输入/输出函数#include<stdlib.h> //定义杂项函数及内存分配函数如malloc、free、system、atoi、atol、rand、exit等#include<string.h> //字符串处理,strlen(),strcat(),strcpy(),strcmp()等等#include<time.h> //定义关于时间的函数#include<wchar.h> //宽字符处理及输入/输出#include<wctype.h> //宽字符分类传统C++#include<fstream.h> //改用<fstream>#include<iomanip.h> //改用<iomainip>#include<iostream.h> //改用<iostream>#include<strstrea.h> //该类不再支持,改用<sstream>中的stringstream ————————————————————————————————标准C++#include<algorithm> //STL 通用算法#include<bitset> //STL 位集容器#include<cctype> //字符处理#include<cerrno> //定义错误码#include<cfloat> //浮点数处理#include<ciso646> //对应各种运算符的宏#include<climits> //定义各种数据类型最值的常量#include<clocale> //定义本地化函数#include<cmath> //定义数学函数#include<complex> //复数类#include<csignal> //信号机制支持#include<csetjmp> //异常处理支持#include<cstdarg> //不定参数列表支持#include<cstddef> //常用常量#include<cstdio> //定义输入/输出函数#include<cstdlib> //定义杂项函数及内存分配函数#include<cstring> //字符串处理#include<ctime> //定义关于时间的函数#include<cwchar> //宽字符处理及输入/输出#include<cwctype> //宽字符分类#include<deque> //STL 双端队列容器#include<exception> //异常处理类#include<fstream> //文件输入/输出#include<al> //STL 定义运算函数(代替运算符)#include<limits> //定义各种数据类型最值常量#include<list> //STL 线性列表容器#include<locale> //本地化特定信息#include<map> //STL 映射容器#include<memory> //STL通过分配器进行的内存分配#include<new> //动态内存分配#include<numeric> //STL常用的数字操作#include<iomanip> //参数化输入/输出#include<ios> //基本输入/输出支持#include<iosfwd> //输入/输出系统使用的前置声明#include<iostream> //数据流输入/输出#include<istream> //基本输入流#include<iterator> //STL迭代器#include<ostream> //基本输出流#include<queue> //STL 队列容器#include<set> //STL 集合容器#include<sstream> //基于字符串的流#include<stack> //STL 堆栈容器#include<stdexcept> //标准异常类#include<streambuf> //底层输入/输出支持#include<string> //字符串类#include<typeinfo> //运行期间类型信息#include<utility> //STL 通用模板类#include<valarray> //对包含值的数组的操作#include<vector> //STL 动态数组容器————————————————————————————————C99增加的部分#include<complex.h> //复数处理#include<fenv.h> //浮点环境#include<inttypes.h> //整数格式转换#include<stdbool.h> //布尔环境#include<stdint.h> //整型环境#include<tgmath.h> //通用类型数学宏本文来自CSDN博客,转载请标明出处:/wubin1124/archive/2009/12/09/4971359.aspx******************************************************************************* ****************************************************程序在使用一个函数之前,应该首先声明该函数。
linux C语言常用函数大全
1: 系统调用:读一个文件函数原型:ssize_t read(int fd, void *buf, size_t size) ;头文件:#include参数:略返回值:1> = 0 :达到文件结尾3> > 0 :返回读到的实际字节数备注:略2:系统调用:写入一个文件函数原型:ssize_t write(int fd, void *buf, size_t size) ;头文件:#include参数:略返回值:1> > 0 :返回写入的实际字节数目----------------------------------注意:当返回值不等于size时,则出现I/O错误备注:略3:系统调用:返回本进程的ID函数原型:pid_t getpid() ;头文件:#include参数:无返回值:1> > 0 :返回本进程ID2>4:系统调用:返回本进程的组ID函数原型:gid_t getgid() ;头文件:#include参数:无返回值:1> > 0 :返回组ID5:系统调用:复制一个文件描述符(一个参数)函数原型:int dup(int fd) ;头文件:#include参数:略返回值:1> >= 0 :返回一个文件描述符备注:此函数的结果就是两个文件符指向一个相同的文件6:系统调用:复制一个文件描述符(两个参数)函数原型:int dup(int fd1, int fd2) ;头文件:#include参数:fd1 :已知的fdfd2 :要复制到的fd返回值:1> >=0 :调用成功备注:此函数的分成三种情况:1> 若fd2已打开,且fd2 != fd1,则先将fd2关闭2> 若fd2已打开,且fd2 == fd1,则直接返回3> 若fd2没有打开,则直接复制7:系统调用:获取文件属性的三个函数函数原型:int stat(const char *pathname, stat *buf) ;int fstat(int fd, stat *buf) ;int lstat(int fd, stat *buf) ;头文件:#include#include参数:略返回值:如果返回负数,则调用失败备注:当操作的文件是个链接文件时1> stat和fstat返回的是链接指向文件的属性2> lstat返回的是链接文件本身的属性8:系统调用:判断文件类型的几个宏(Question:参数) 头文件:(Question)普通文件:S_ISREG()目录文件:S_ISDIR()链接文件:S_ISLNK()块设备:S_ISBLK()字符设备:S_ISCHR()管道:S_ISFIFO()SOCKET :S_ISSOCK()9:系统调用:测试文件存取模式函数原型:int access(const char *pathname, int mode) 头文件:#include#include#include参数:mode的取值情况:---------------1> 存在:F_OK (文件是否存在)2> 可读:R_OK3> 可写:W_OK4> 执行:X_OK返回值:如果失败,返回一个负数备注:10:系统命令:置位设置-用户-ID位chmod u+s file11:系统结构:文件存储权限字S_ISUID 设置-用户-IDS_ISGID 用户-组-IDS_ISIVX 粘住位S_IRUSR 用户相关S_IWUSRS_IXUSRS_IRGRP 组相关S_IWGRPS_IXGRPS_IROTH 其他用户相关S_IWOTHS_IXOTH12:系统函数:屏蔽标记函数函数原型:mode_t umask(mode_t masks) ;头文件:#include参数:要屏蔽的存储方式字(mode_t)返回值:返回原来的屏蔽方式字备注:1> 此函数如果出错,则不会返回2> 这是UNIX中出错不会返回的仅有的几个函数之一13:系统调用:改动文件存取模式函数原型:int chmod(const char *pathname, mode_t mode) ;int fchmode(int fd, mode_t mode) ;头文件:#include#include参数:略返回值:如果出错,则返回一个负数备注:fchmod能设置一个已打开文件的存储访问权限14:系统调用:截短文件的函数函数原型:int truncate(const char *pathname, off_t length) ;int ftruncate(int fd, off_t length) ;头文件:#include#include参数:off_t (截短到该长度)返回值:如果失败,则返回一个负数备注:1> length可正可负2> 可能出现“文件空洞”15:标准函数:设置流的缓冲类型函数原型:int setvbuf(FILE *fstream, void *buf, int mode, size_t size 头文件:#include参数:buf :if buf==NULL,则由系统来分配缓存,叫做系统缓存if buf!=NULL,则来使用分配的缓存,叫做用户缓存size:分配的用户缓存大小mode:_IOFBF :I/O全缓存_IOLBF :I/O行缓存_IONBF :I/O不缓存参数:如果失败,则返回一个负数16:标准函数:缓冲流函数原型:int fflush(FILE *fstream) ;头文件:#include参数:if fstream == NULL,则强制刷新全部流if fstream != NULL,则刷新特定流返回值:如果失败,则返回一个负数17:标准函数:打开文件的三个函数函数原型:FILE* fopen(const char *pathname, char *mode) ;FILE* fropen(const char *pathname, char *mode) ;FILE* fdopen(int fd, char *mode) ;头文件:#include参数:略返回值:略备注:1> fopen :路径 FILE*2> fropen :重新打开一个文件3> fdopen :把FILE* 和一个fd联系起来I/O的几种type类型1> r :为读而打开2> r+ :为读和写而打开3> w :使文件长度称为0,或为写而创建文件4> w+ :使文件长度成为0,为读和写而打开5> a :添加,为在文件尾写而打开或为了写而创建文件6> a+ :为在文件尾读和写而打开或创建19:标准函数:关闭一个文件流函数原型:int fclose(FILE* fstream) ;头文件:#include参数:略返回值:如果出错,返回一个负数备注:系统在关闭一个文件时,会自动刷新该文件相关的流1> 输入数据:全部被抛弃2> 输出数据:全部被刷新20:标准函数:读取一个字符(三个)函数原型:int getchar() ;int getc(FILE *fstream) ;int fgetc(FILE *fstream) ;头文件:#include参数:略返回值:1> EOF :文件结束2> >=0 :读取的字符的ASCII码3> getc和fgetc的差别getc是个宏2> 返回值一定要用int类型,不是char类型3> 三个函数遇见文件结束或I/O错误时,都会返回负数,这个时候应该用两个函数来判断是那种情况:feof(FILE *fstream) ; // 是否文件结尾?ferror(FILE *fstream) ; // 是否出现错误?21:标准函数:测试是否到达一个文件流的结束函数原型:int feof(FILE *fstream) ;头文件:#include参数:略返回值:略22:标准函数:测试一个文件流是否出现错误函数原型:int ferror(FILE *fstream) ;头文件:#include参数:略返回值:略23:标准函数:字符回送函数函数原型:int ungetc(int c, FILE *fsteam) ;头文件:#include参数:略返回值:1> 如果回送成功,则返回字符c2> 如果失败,则返回一个负数24:标准函数:字符输出函数函数原型:int putchar(int c) ;int putc(int c, FILE *fstream) ;int fputc(int c, FILE *fstream) ;头文件:#include参数:略返回值:如果失败,则返回一个负数备注:其他相关事项和put类型相同25:标准函数:每次一行I/O的输入函数函数原型:int fgets(const char *buf, size_t size, FILE *fstream) ;头文件:#include参数:略返回值:1> 如果成功,返回实际写入的字节数2> 如果返回值和size不相等,则出现错误26:标准函数:每次一行I/O的输出函数函数原型:int fputs(const char *buf, FILE *fstream) ;头文件:#include参数:略返回值:1> >=0 :返回实际读取的字节数2> fgets函数中,如果缓存大小是size,则最多能存放n-1个字符(包括‘\n’符号)2> fputs函数中,系统推荐在buf[size-2]字符=’\n’,不过并不强制这样做27:标准函数:读二进制文件或数据类型函数原型:int fread(void *buf, size_t objsize, int objnum, FILE *fs头文件:#include参数:buf :缓存首地址objsize :一个字节所占的字节数目objnum :对象的数目返回值:1> >=0 :返回读到的对象数目2>28:标准函数:写二进制文件或数据类型函数原型:int fwrite(const void *buf,size_t size, int num, FILE *f)头文件:#include参数:buf :缓存首地址objsize :一个字节所占的字节数目num :要写入的字节数目返回值:如果返回值和num不相等,那么就出现了错误备注:fread和fwrite函数是有局限性的,因为各种操作系统同一种类型所占的空间大小也是有差别的29:标准函数:定位流函数函数原型:int fseek(FILE *fstream, long offset, int whence) ;头文件:#include参数:offset :偏移量whence :从什么地方开始(SET,END,CURSOR)返回值:如果定位失败,则返回一个负数30:标准函数:重置文件流函数原型:int rewind(FILE *fstream)头文件:#include参数:略返回值:略31:标准函数:建立临时文件(两个)函数原型:char* tmpnam(char *str) ;FILE* tmpfile(void) ;头文件:#include参数:if (str == NULL)路径名会存储在str中if (str != NULL)路径名存储在系统的静态空间里面返回值:tmpnam :返回临时文件的路径名tmpfile :返回临时文件的指针。
Linux 系统中调用 exit() 和 _exit() 结束进程的区别是什么?
网上搜索到一些博客有对这两个函数的解释,看了之后还是犯迷糊。
exit()函数定义在stdlib.h头文件中,_exit()定义在unistd.h头文件中,这是区别之一。
调用_exit()函数时,其会关闭调用进程的所有文件描述符,清理内存和内核数据,但不会刷新流(stdin, stdout, stderr ...)。
exit()函数是在_exit()函数之上的一个封装,其会调用_exit(),并在调用之前先刷新流,并且exit()系统调用之前要检查文件的打开情况,把文件缓冲区的内容写回文件。
所以要保证数据的完整性,得调用exit()函数。
但是也查到一些解释,《Linux环境C程序设计》(第二版 徐诚等编著)一书第205页exit系统调用小节中有这样描述:“由fork()函数创建的子进程分支里,正常情况下使用函数exit()是不正确的,这是因为使用它会导致标准输入输出的缓冲区被清空两次,而且临时文件可能被意外删除。
”这与上面的解释相悖了,究竟谁是对的?基于上面的描述,我还有以下疑问:1、刷新缓冲区是简单的删除其中的数据,还是要进行一些操作,例如保存数据再清空?2、exit()为什么会导致标准输入输出的缓冲区被清空两次?希望有高手不吝赐教,解释exit()和_exit()的区别及使用方法。
谢谢!添加评论 分享匿名用户知乎用户、知乎用户、知乎用户 等人赞同基本来说,_Exit(或 _exit,建议使用大写版本)是为 fork 之后的子进程准备的特殊 API。
功能见 [1],讨论见 [2]。
因为在 fork 之后,exec 之前,很多资源还是共享的(如某些文件描述符),如果使用 exit 会关闭这些资源,导致某些非预期的副作用(如删除临时文件等)。
「刷新」是对应 flush,意思是把内容从内存缓存写出到文件里,而不仅仅是清空(所以常见的对 stdin 调用 flush 的方法是耍流氓而已)。
如果在 fork 的时候父进程内存有缓冲内容,则这个缓冲会带到子进程,并且两个进程会分别 flush (写出)一次,造成数据重复。
Linux(CC++)下的文件操作open、fopen与freopen
Linux(CC++)下的⽂件操作open、fopen与freopenopen是下的底层系统调⽤函数,fopen与freopen c/c++下的标准I/O库函数,带输⼊/输出缓冲。
linxu下的fopen是open的封装函数,fopen最终还是要调⽤底层的系统调⽤open。
所以在linux下如果需要对设备进⾏明确的控制,那最好使⽤底层系统调⽤(open),open对应的⽂件操作有:close, read, write,ioctl 等。
fopen 对应的⽂件操作有:fclose, fread, fwrite, freopen, fseek, ftell, rewind等。
freopen⽤于重定向输⼊输出流的函数,该函数可以在不改变代码原貌的情况下改变输⼊输出环境,但使⽤时应当保证流是可靠的。
详细见第3部分。
-------------------------------------------------------------------------------------------------------------------open和fopen的区别:1,fread是带缓冲的,read不带缓冲.2,fopen是标准c⾥定义的,open是POSIX中定义的.3,fread可以读⼀个结构.read在linux/unix中读⼆进制与普通⽂件没有区别.4,fopen不能指定要创建⽂件的权限.open可以指定权限.5,fopen返回⽂件指针,open返回⽂件描述符(整数).6,linux/unix中任何设备都是⽂件,都可以⽤open,read.-------------------------------------------------------------------------------------------------------------------1、open系统调⽤(linux)需要包含头⽂件:#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>函数原型:int open( const char * pathname, int oflags);int open( const char * pathname,int oflags, mode_t mode);mode仅当创建新⽂件时才使⽤,⽤于指定⽂件的访问权限。
linux系统调用 api 手册
linux系统调用 api 手册【实用版】目录I.Linux 系统调用 API 手册概述II.Linux 系统调用 API 的功能III.Linux 系统调用 API 的使用方法IV.Linux 系统调用 API 的示例正文I.Linux 系统调用 API 手册概述Linux 系统调用 API 手册是指提供了一系列用于在 Linux 系统中调用系统功能的 API 函数。
这些 API 函数可以让程序员在编写程序时,更加方便、高效地与 Linux 系统进行交互,实现各种系统操作。
II.Linux 系统调用 API 的功能Linux 系统调用 API 的功能主要包括以下几个方面:1.文件操作:包括文件的打开、关闭、读取、写入等操作。
2.进程管理:包括进程的创建、终止、切换等操作。
3.系统管理:包括系统时间的获取、设置,内存的管理等操作。
4.网络操作:包括网络套接字的创建、连接、接收、发送等操作。
III.Linux 系统调用 API 的使用方法要使用 Linux 系统调用 API,首先需要在程序中包含相应的头文件,然后调用相应的函数。
例如,要使用文件操作相关的 API,需要在程序中包含`<unistd.h>`头文件,然后调用如`open()`、`read()`、`write()`等函数。
IV.Linux 系统调用 API 的示例以下是一个简单的使用 Linux 系统调用 API 的示例,该示例展示了如何使用`read()`和`write()`函数实现文件的读写操作:```c#include <stdio.h>#include <unistd.h>int main() {int fd = open("example.txt", O_RDWR);if (fd < 0) {perror("Error opening file");return -1;}char buffer[1024];if (read(fd, buffer, 1024) < 0) {perror("Error reading from file");return -1;}printf("Content of file: %s", buffer);char new_content[1024] = "Hello, world!";if (write(fd, new_content, 1024) < 0) {perror("Error writing to file");return -1;}printf("New content written to file.");close(fd);return 0;}```在这个示例中,我们首先使用`open()`函数打开名为`example.txt`的文件,然后使用`read()`函数从文件中读取内容,使用`write()`函数向文件中写入新内容。
prctl方法
prctl方法1. 简介prctl方法是Linux操作系统中的一个系统调用,用于设置和获取进程的运行时属性。
通过调用prctl方法,可以对进程进行各种配置和控制,包括修改进程的名称、获取或设置进程的资源限制、修改进程的用户标识等。
本文将详细介绍prctl方法的使用方式和常见应用场景。
2. prctl方法的使用方式2.1 声明头文件在使用prctl方法之前,首先需要引入相关头文件:#include <sys/prctl.h>2.2 函数原型prctl方法的函数原型如下:int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);其中,参数option表示要执行的操作类型,arg2、arg3、arg4、arg5是与不同操作相关的参数。
2.3 常见操作类型下面列举了一些常见的操作类型及其说明:•PR_SET_NAME: 设置进程名称。
可以通过该操作修改进程在系统中显示的名称。
•PR_GET_NAME: 获取进程名称。
可以通过该操作获取当前进程在系统中显示的名称。
•PR_GET_PDEATHSIG: 获取父进程退出时发送给子进程的信号。
•PR_SET_PDEATHSIG: 设置父进程退出时发送给子进程的信号。
•PR_GET_CHILD_SUBREAPER: 判断当前进程是否是子进程的”subreaper”。
•PR_SET_CHILD_SUBREAPER: 设置当前进程为子进程的”subreaper”。
•PR_GET_DUMPABLE: 获取进程是否可以进行核心转储(dump)。
•PR_SET_DUMPABLE: 设置进程是否可以进行核心转储(dump)。
2.4 使用示例2.4.1 设置进程名称#include <sys/prctl.h>#include <stdio.h>int main() {prctl(PR_SET_NAME, "myprocess");printf("Process name set to 'myprocess'\n");return 0;}上述代码通过调用prctl方法将当前进程的名称设置为”myprocess”。
Linux C 一些函数 所属的头文件
Linux C 一些函数所属的头文件在编写程序时,有时总是不记得所使用的函数在哪个库函数中。
现在先把自己以前经常用到的函数头文件总结一下。
有不对的地方还请指教。
1,系统调用文件的操作函数#inlclude <fcntl.h>int open(char *name,int how) 第二个参数,O_RDONLY O_WRONL Y O_RDWR O_CREAT #include <unistd.h>int close(int fd)size_t read(int fd,void *buf, size_t count)size_t write(int fd,const void *buf,size_t count)sleep(1) 系统睡眠一秒钟,最小单位为一秒。
#define msleep(x) usleep(x*1000)msleep(500); 系统睡眠0.5秒#include <stdio.h>perror("会出现错误的函数名")#include <string.h>char *strerror(int errnum) 依据错误代码errnum来查找错误原因字符串char *strcpy(char *dest,const char *src)int strcmp(char *s1,const char *s2) s1若等于s2的值则返回0值int strncmp(char *s1,const char *s2,int n) 前n个字符串比较2,进程控制函数#include <unistd.h>pid_t fork(void) 子进程中返回0 父进程中返回子进程ID 出错返回-1pid_t getpid(void) pid_t getppid(void)pid_t vfork(void)exec函数族进程pid 的类型为pid_t 类型,它包含于#include <sys/types.h> 若定义一个进程pid变量,则需要包含此头文件exit(n)结束进程父进程可以由wait函数来获得子进程结束装状态。
linux系统write函数
linux系统write函数
write函数是Linux系统中一个重要的系统调用函数,它可以用于从
一些文件句柄中写入一些数据,并返回已写入的字节数。
它是我们常用的
I/O函数之一、该函数定义在<unistd.h>头文件中,其原型为:ssize_t write(int fd, const void *buf, size_t count);
write函数有三个参数,第一个参数fd为要写入的文件描述符,表
示要操作的文件;第二个参数buf为要写入的数据,通常为一个指向字符
串的指针;第三个参数count表示要写入数据的长度,单位为字节。
函数
返回值为写入的字节数,如果出错返回-1,错误原因存于errno(错误号)中。
write函数执行完成后,文件描述符指向的文件位置指针会自动增加,表示已写入的位置。
如果我们想控制文件描述符指向的文件位置指针可以
使用lseek函数,将文件描述符指向指定位置。
write函数不能写入文件的大小,因为传入的参数是一个固定的字节
大小。
如果要写入文件大小,必须先使用lseek函数查找文件的大小,然
后再调用write函数写入该大小。
如果要修改文件的大小,可以使用truncate函数来完成。
write函数的使用可以极大地减少程序的开发时间,有效提高程序的
效率。
在使用write函数时,应该注意文件是否打开,文件权限是否允许
写入,文件是否存在,传入的参数是否正确等。
总之,write函数在Linux系统中是一个重要的I/O函数。
linux 内核头文件 linux kernel header
inux 内核头文件linux kernel header概述:在进行有关系统软件的安装的时候(编译一个新的驱动,或者安装一个系统级别的测试工具,例如systemtap),经常需要重新编译内核,相应的问题往往与内核头文件有关。
那么,什么是内核头文件,为什么需要更新内核头文件?内核头文件作用是什么,如何更新?本文主要为你解答这些疑问。
1.内核头文件的发展历史在Linux 2.2/2.4 的纯真年代,内核头文件一直保持着Unix 世界的"KISS"传统,只需将内核源码树中的头文件直接复制到/usr/include 中即可使用,一切都是那么Simple and Stupid ...但是随着2.6 系列内核的发布,事情开始变得混乱和复杂起来。
首先是内核开发者宣布强烈反对直接使用"未净化"的"原始"内核头文件,他们建议使用发行版提供的"经过净化的"内核头文件。
于是各种发行版开始"八仙过海,各显神通",由于"净化"方法各不相同,结果就是每个发行版都有着自己与众不同的内核头文件。
更为严重的是,内核开发者甚至推荐编译Glibc 的头文件也要使用发行版提供的"经过净化的"内核头文件。
由于Glibc 和Kernel 是整个系统的根基,这样一来Linux 便像传统的Unix 那样开始走向分裂。
另一件哭笑不得的事情是,虽然内核开发者强烈推荐使用发行版提供的"经过净化的"内核头文件,但是Glibc 的开发者却不买账,他们推荐使用"未净化"的"原始"内核头文件来编译Glibc ,两个开发组一直坚持各自的见解,互不妥协!另外,两个开发组在应当由谁提供内核头文件的问题上意见也不一致:内核开发组认为应当由发行版的制作者提供,而Glibc 开发组认为应当由内核开发组提供。
wext ioctl用法 -回复
wext ioctl用法-回复wext ioctl用法:一步一步回答引言:在嵌入式系统中,驱动程序常常需要与硬件设备进行通信和交互。
ioctl 是一种常用的系统调用,在Linux系统中,使用ioctl能够实现与设备驱动程序的通信。
而在无线网络驱动程序开发中,wext ioctl则是一种特定的ioctl接口,用于无线网络设备的管理和配置。
本文将详细介绍wext ioctl的用法,以及如何在嵌入式系统中使用该接口。
一、什么是wext ioctl?wext ioctl是Linux内核中一种特殊的ioctl接口,用于无线设备管理扩展接口。
wext是Wireless Extension的缩写,是对Linux无线网络驱动程序的扩展接口进行统一和标准化的一种方式。
通过wext ioctl,用户空间的应用程序可以和无线网络设备的驱动程序进行通信,实现无线网络的配置、监控和管理。
二、wext ioctl的使用步骤为了使用wext ioctl接口,我们需要按照以下步骤进行操作:步骤一:打开wext ioctl接口在应用程序中,首先需要获得对无线网络设备的访问权限。
我们可以通过打开wext ioctl设备文件,利用open系统调用来实现该目的。
设备文件通常位于/dev目录下,其名称可能是wlan0、eth0等,具体取决于使用的无线网络设备。
步骤二:定义ioctl命令和参数在进行ioctl调用之前,我们需要首先定义具体的ioctl命令和相关参数。
这些ioctl命令在Linux源码中已经定义好了,我们只需要在应用程序中引入相应的头文件即可。
例如,对于无线设备的配置操作,我们可以使用SIOCSIWAP命令,用于设置连接的无线接入点的MAC地址。
步骤三:进行ioctl调用在定义好ioctl命令和参数后,我们可以使用ioctl系统调用来实际完成与无线设备的通信。
ioctl系统调用的原型如下所示:int ioctl(int fd, unsigned long request, ...);其中,fd是设备文件的文件描述符,request是ioctl命令,后面可以跟上相应的参数。
10.系统调用与标准IO库
系统调用
当然,系统调用最终具有一种明确的操作, 如getpid()系统调用,它会返回当前进程 的PID.内核中它的实现非常简单: asmlinkage long sys_getpid(void) { return current->tgid; }
14
系统调用
在Linux中,每个系统调用被赋予一个全局 唯一的系统调用号.用户空间进程执行一个 系统调用的时候,这个系统调用号就被用来 指明到底要执行哪个系统调用;进程不会提 及系统调用的名称. 系统调用号相当关键,一旦分配就不能再有 任何变更,否则编译好的应用程序就会崩溃. 此外,如果一个系统调用被删除,它所占用 的系统调用号也不允许被回收利用.
19
系统调用
给用户空间的返回值也通过寄存器传递. 在x86系统上,它存放在eax寄存器中.
20
系统调用
who命令作用是显示哪些用户登陆了系统. #who 第一列显示登陆用户名 第二列显示终端名 第三列显示登陆时间
21
系统调用
who是如何实现这些功能的? 用户登陆信息放在/var/run/utmp文件 中,who通过读取该文件获取登陆信息. utmp这个文件里保存的是结构数组,数组 元素是utmp类型的结构. 可以在/usr/inlcude/bits/utmp.h中找 到utmp结构类型的定义.
27
大纲
系统调用 标准I/O库
28
标准I/O 标准I/O库 I/O库
无论编写系统程序还是应用程序,都离不 开I/O这个重要的环节.相对于低级的I/O 操作(即系统调用级的I/O),标准I/O库函 数处理了很多细节,如缓存分配等. 考虑到代码的可移植性,开发人员应该在 编写代码时尽可能使用标准库函数.头文 件<stdio.h>中声明了标准C的I/O库,标 准C的I/O库在所有通用计算机上的C语言 实现都是相同的.
linux 标准库头文件的路径
linux 标准库头文件的路径
Linux 标准库头文件的路径取决于你所使用的发行版和安
装的软件包管理器。
一般来说,Linux 系统的标准库头文
件位于 `/usr/include` 目录下。
以下是一些常见的 Linux 发行版的标准库头文件路径:
- Ubuntu、Debian、Linux Mint:`/usr/include`
- CentOS、Fedora、Red Hat Enterprise Linux:
`/usr/include`
- Arch Linux:`/usr/include`
- openSUSE:`/usr/include`
- Gentoo:`/usr/include`
请注意,这些路径是默认的安装路径,如果你的系统有特
殊的配置,可能会有所不同。
另外,一些特定的库可能会有自己的头文件路径。
例如,OpenGL 的头文件路径是 `/usr/include/GL`,C++ 标准库
的头文件路径是 `/usr/include/c++`。
如果你想要查找特定库的头文件路径,可以使用 `pkg-config` 命令。
例如,要查找 `libcurl` 库的头文件路径,可以运行以下命令:
pkg-config --cflags libcurl
这将输出 `libcurl` 库的头文件路径。
总之,要获取 Linux 标准库头文件的路径,你可以首先检
查 `/usr/include` 目录,如果需要特定库的头文件路径,可以使用 `pkg-config` 命令来查找。
linux创建进程的方法
linux创建进程的方法
在Linux系统中,创建进程的方法有多种,其中最常用的方法是使用fork()系统调用。
下面是详细的创建进程的步骤:
1. 导入头文件
在程序中导入头文件<unistd.h>,该头文件中包含了fork()系统调用的声明。
2. 调用fork()系统调用
使用fork()系统调用创建一个新的进程。
fork()系统调用会返回两次,一次在父进程中返回子进程的PID,另一次在子进程中返回0。
3. 判断进程类型
根据fork()系统调用的返回值判断当前进程是父进程还是子进程。
如果返回值大于0,则表示当前进程是父进程,返回值为子进程的PID;如果返回值为0,则表示当前进程是子进程。
4. 编写父进程代码
在父进程中编写需要执行的代码。
通常情况下,父进程会等待子进程执行完毕后再继续执行。
5. 编写子进程代码
在子进程中编写需要执行的代码。
通常情况下,子进程会执行一些与父进程不同的操作。
6. 退出进程
在进程执行完毕后,使用exit()系统调用退出进程。
在父进程中,可以使用wait()系统调用等待子进程执行完毕后再退出。
以上就是在Linux系统中创建进程的详细步骤。
需要注意的是,创建进程时需要
注意进程间的通信和同步问题,以确保程序的正确性和稳定性。
系统调用实验报告
系统调用实验报告系统调用实验报告一、引言计算机操作系统是现代计算机系统的核心组成部分,它负责管理和协调计算机硬件和软件资源,为用户提供良好的使用环境。
在操作系统中,系统调用是用户程序与操作系统之间进行交互的关键接口。
二、实验目的本实验旨在深入理解系统调用的概念和原理,通过编写和调用系统调用接口,掌握系统调用的使用方法和注意事项。
三、实验环境本实验使用Linux操作系统,并借助C语言编写相关程序。
四、实验过程1. 系统调用的概念系统调用是操作系统提供给用户程序的一组函数接口,通过这些接口,用户程序可以向操作系统请求服务和资源。
系统调用可以分为进程控制、文件操作、设备管理、通信等多个类别,每个系统调用都有一个唯一的标识符和一组参数。
2. 系统调用的使用方法为了使用系统调用,我们需要包含相应的头文件,并通过系统调用号来调用对应的函数。
例如,要打开一个文件,可以使用open()系统调用,其原型为:```cint open(const char *pathname, int flags, mode_t mode);```其中,pathname是文件路径,flags是打开方式,mode是权限设置。
通过调用open()函数,我们可以获取一个文件描述符,用于后续的文件操作。
3. 系统调用的注意事项在使用系统调用时,需要注意以下几点:- 参数传递:系统调用的参数传递通常使用寄存器或栈来完成,具体传递方式与操作系统和硬件平台相关。
- 错误处理:系统调用可能会返回错误码,表示调用失败。
因此,在调用系统调用后,需要检查返回值并进行相应的错误处理。
- 安全性:系统调用是操作系统提供的特权接口,用户程序需要通过操作系统的访问控制机制来确保系统调用的安全性。
五、实验结果通过编写和调用系统调用接口,我们可以实现各种功能,如文件读写、进程创建和管理、网络通信等。
这些功能可以大大扩展用户程序的能力,提高系统的灵活性和可扩展性。
六、实验总结系统调用是操作系统与用户程序之间的重要接口,它为用户程序提供了访问操作系统服务和资源的途径。
linux mesa 调用过程
linux mesa 调用过程Linux是一个开源的操作系统,而Mesa是一个开源的图形库,它们之间有着紧密的联系。
本文将介绍Linux Mesa的调用过程。
一、什么是MesaMesa是一个实现了OpenGL和其他图形API的开源图形库。
它提供了一系列的函数和数据结构,用于处理图形渲染和显示的各种操作。
Mesa可以在多个操作系统上运行,其中包括Linux。
二、Linux下的Mesa调用过程在Linux系统中,使用Mesa进行图形渲染和显示的过程可以分为以下几个步骤:1. 获取Mesa源代码要在Linux系统中使用Mesa,首先需要获取Mesa的源代码。
可以通过官方网站或者其他开源软件仓库获取最新的Mesa源代码。
2. 编译和安装Mesa获取到Mesa源代码后,需要进行编译和安装。
在Linux系统中,可以使用命令行工具进行编译和安装。
具体的编译和安装过程可以参考Mesa的官方文档或者相关的教程。
3. 配置环境变量在安装完成后,需要配置一些环境变量,以便系统能够正确找到Mesa库和头文件。
可以通过修改.bashrc或者其他类似的配置文件来设置这些环境变量。
4. 创建OpenGL上下文在应用程序中使用Mesa进行图形渲染和显示之前,需要先创建一个OpenGL上下文。
这个上下文是一个抽象的概念,它包含了各种图形渲染和显示所需要的状态和资源。
5. 调用Mesa函数一旦创建了OpenGL上下文,就可以在应用程序中调用Mesa提供的函数来进行图形渲染和显示了。
这些函数包括了各种图形操作,比如绘制三角形、设置材质和光照等等。
6. 销毁OpenGL上下文在应用程序结束之前,需要销毁之前创建的OpenGL上下文。
这样可以释放相关的资源,避免资源泄漏和内存溢出。
三、Mesa的优势和应用领域Mesa作为一个开源的图形库,在Linux系统中有着广泛的应用。
它的优势主要体现在以下几个方面:1. 跨平台性Mesa可以在多个操作系统上运行,包括Linux、Windows和MacOS等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
分类: LINUX
在编写程序时,有时总是不记得所使用的函数在哪个库函数中。现在先把自己以前经常用到的函数头文件总结一下。 有不对的地方还请指教。
1,系统调用 文件的操作函数
#inlclude <fcntl.h>
pid_t vfork(void)
exec函数族
进程pid 的类型为pid_t 类型,它包含于#include <sys/types.h> 若定义一个进程pid变量,则需要包含此头文件
exit(n)结束进程 父进程可以由wait函数来获得子进程结束装状态。
在进程结束的时候,会关闭文件描述符号,做一些清理工作,只保留进程返回状态等信息
#include <sys/types.h> #include <sys/stat.h>
int mkfifo(const char *pathname,mode_t mode)
对于命名管道的操作同普通文件的操作
5,消息队列
数据类型key_t是在头文件sys/types.h中定义的,它是一个长整形的数据。
信号集数据结构的定义,sigset_t 为结构体数据类型
sigset_t intmask;
sigemptyset(&intmask);
sigaddset(&intmask,SIGINT);
sigdelset(&intmask,SIGINT);
sigprocmask(int how,const sigset_t *set,sigset_t *oset)
struct msg
{
long mtype;
char mtext[50];
}msg1,msg2; //消息队列缓冲区
int rcvtype=1;
msgsnd(msgid,&msg1,6,0) 6个字节,最后一个参数填写为0表示函数调用阻塞直到满足条件为止。
msgrcv(msgid,&msg2,6,rcvtype,0) 最后一个参数也可为IPC_NOWAIT,没有收到消息返回-1
sigpromask(SIGBLOCK,&de <pthread.h>
线程ID类型为 pthread_t 为结构体类型
获得线程ID的办法 pthread_t tid; tid=pthread_self();
pthread_create(&tid,NULL,thread,NULL) 第二个参数为线程属性,第三个参数为线程。第四个参数是可以向该线程传递参数。 线程 void *thread(void *arg)
int strncmp(char *s1,const char *s2,int n) 前n个字符串比较
2,进程控制函数
#include <unistd.h>
pid_t fork(void) 子进程中返回0 父进程中返回子进程ID 出错返回-1
pid_t getpid(void) pid_t getppid(void)
alarm(2) 定时两秒后,产生SIGALRM信号,系统默认处理是结束进程。
int pause(void) //pause函数使调用进程挂起直至捕捉到一个信号。
signal(SIGINT,ctrl_c) ctrl_c为函数名 功能:发出信号后,调用信号处理函数
7,信号集函数组 阻塞信号
pthread_cleanup_pop(0); 0表示线程结束时不执行清理函数,非0执行,两函数配对使用。
调用pthread_exit时,或响应取消时,即使是pthread_cleanup_pop(0);也执行清理函数。
互斥锁
互斥锁类型为 pthread_mutex_t mutex1
pthread_mutex_init(&mutex1,NULL) 互斥锁的创建,第二个参数为空,表示默认属性。
msgctl(msgid,IPC_RMID,NULL); 删除消息队列
6,进程间通信-信号
#include <signal.h>
int kill(pid_t pid,int sig)
int raise(int signo);进程向自身发送信号
raise(signo)等价于kill(getpid(),signo);
如WEXITSTATUS(status) 可以获得exit(2)中返回的值,status=2,这样就可以知道所等待的为哪个进程。如果不用这个宏转换,则status=512.
pid_t waitpid(pid_t pid,int status,int options) 可以指定等待某个进程号pid的进程结束
perror("会出现错误的函数名")
#include <string.h>
char *strerror(int errnum) 依据错误代码errnum来查找错误原因字符串
char *strcpy(char *dest,const char *src)
int strcmp(char *s1,const char *s2) s1若等于s2的值则返回0值
size_t write(int fd,const void *buf,size_t count)
sleep(1) 系统睡眠一秒钟,最小单位为一秒。
#define msleep(x) usleep(x*1000)
msleep(500); 系统睡眠0.5秒
#include <stdio.h>
pthread_exit((void *)2) //与return((void *)2)的区别?谁可以解答。。。
void *tret;
pthread_join(tid,&tret);
pthread_cancel(tid);
pthread_cleanup_push(fun,NULL);第一个参数为清理函数,第二个为传参,线程清理处理程序
key=ftok(".",'A') #include <sys/types.h> #include <sys/ipc.h>
所属头文件:#include<sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
int msgid;
msgid=msgget(key, IPC_CREAT | IPC_EXCL | 0666);
调用exit(),子进程会关闭所有打开的进程描述符 exit会作清理工作,比如说,释放内存(在C++里面会主动的调用析构函数,),关闭文件句柄的工作,包括刷新IO流。
_exit(n)直接退出,不会做一些清理工作,也不会关闭文件描述符。
#include <sys/wait.h>
pid_t wait(int *status) 等待任意子进程结束。子进程结束状态值由status返回。
int open(char *name,int how) 第二个参数,O_RDONLY O_WRONLY O_RDWR O_CREAT
#include <unistd.h>
int close(int fd)
size_t read(int fd,void *buf, size_t count)
第三个参数为无符号整型,n表示信号量初始化的值
sem_wait(&sem1) P操作
sem_post(&sem1) V操作
用PV实现线程间的互斥与同步功能
int sem_getvalue(sem_t *sem) 取得信号量的值
int sem_destroy(sem_t *sem) 删除信号量
在使用 waitpid函数时还用到了pid参数,所以还要加上#include <sys/types.h>
关于进程等待函数还有很多宏将status转换为需要的值,需要了解。
3,进程间通信-管道
#include <unistd.h>
int pipe(int filedes[2])
4,进程间通信-命名管道
pthread_mutex_destory(&mutex1) 清除一个互斥锁
pthread_mutex_lock(&mutex1)
pthread_mutex_unlock(&mutex1)
信号量
#include <semaphore.h>
信号量的类型 sem_t sem1;
sem_init(&sem1,0,n) 信号量的初始化,第二个参数Linux没能实现在进程间信号量的共享,所以值为0。