Linux常用C函数

可以参考这个：

http://net.pku.edu.cn/~yhf/linux_c/

/第三章   文件IO******************************************/
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
函数: fpathconf或pathconf ——     
    查询目录具体支持何种行为，如文件名最大值，路径名最大值
函数: pread和pwrite ——
    随机读写函数
ssize_t pread(int fd, void *buf, size_t count, off_t offset);
ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset);    
*****
int dup(    int oldfd);             //复制表述符
int dup2(    int oldfd,     int newfd)  //用fd参数指定新描述符的值
*****
void     sync(        void);   //把所有的缓冲写到磁盘
int        syncfs(        int fd); //指定文件
int     fdatasync(    int fd);  //只写文件的数据部分
*****
int fcntl(int fd, int cmd, ... /* arg */ ); //var = fcntl(fd, F_GETFL, 0)
*****
int ioctl(    int d,     int request,     ...);//是IO操作的杂物箱
*****
/dev/fd/0   

int rename(const char *oldpath, const char *newpath);  //为文件更换名字

int getdtablesize(void);  //返回进程能打开的最大文件描述符的数，Linux时1024

/第四章      文件和目录******************************************/
int stat(    const char *path,     struct stat *buf);  //获得文件的各种信息
int fstat(    int fd,             struct stat *buf);
int lstat(    const char *path,     struct stat *buf); //返回符号链接本身
int fstatat(    int dirfd,         const char *pathname,     struct stat *buf,    int flags);

int access(                const char *pathname,     int mode);  //检测文件对于进程的属性
int faccessat(    int dirfd, const char *pathname,         int mode,     int flags);
mode:
R_OK(读)    W_OK(可写)  X_OK(可执行)    F_OK(文件是否存在)

mode_t umask(mode_t mask); //文件权限

chmod 1777 filename  //设置文件粘着位

int chown(    const char *path,   uid_t owner,     gid_t group);
int fchown(   int fd,                     uid_t owner,     gid_t group);
int lchown(    const char *path,    uid_t owner,    gid_t group);
int fchownat(  int dirfd,                const char *pathname,   uid_t owner,    gid_t group,   int flags);

cat core1 > core2 //把空洞文件填满

int truncate(const char *path, off_t length);//文件截断
int ftruncate(int fd, off_t length);
命令：truncate -s 0 mask //文件变为空

int link(const char *oldpath, const char *newpath); //创建硬链接
int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags);
int unlink(const char *pathname);
int unlinkat(int dirfd, const char *pathname, int flags);
int remove(const char *pathname);  //解除链接

link filename filename_link  //创建硬链接
ln filename filename_link  //创建硬链接
ln  -s  [源文件或目录]  [目标文件或目录]  //创建软链接

int symlink(    const char *oldpath,     const char *newpath); //创建软链接
int symlinkat(    const char *oldpath,     int newdirfd,         const char *newpath);

ssize_t readlink(const char *path,      char *buf,       size_t bufsiz); //读符号链接
int readlinkat(    int dirfd,     const char *pathname,  char *buf,  size_t bufsiz);

int futimens(int fd, const struct timespec times[2]);//修改最后访问时间
int utimensat(int dirfd, const char *pathname,const struct timespec times[2], int flags);
int utimes(const char *path, const struct timeval times[2]);

int mkdir(    const char *pathname,                 mode_t mode); //创建文件夹
int mkdirat(    int dirfd,         const char *pathname,     mode_t mode);
int rmdir(    const char *pathname);  //删除文件夹

int dirfd(DIR *dirp);  //把文件夹变文件描述符

DIR *opendir(const char *name); //打开文件夹
DIR *fdopendir(int fd);
struct dirent *readdir(DIR *dirp);  //每次只能读一个文件
int  readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result);
void rewinddir(DIR *dirp);
int  closedir(DIR *dirp);   //关闭文件夹
long telldir(DIR *dirp);
void seekdir(DIR *dirp, long loc);

         
int   chdir(const char *path);//改变当前进程的工作目录
int   fchdir(int fd);
char *getcwd(char *buf, size_t size);//获取当前进程的工作目录

unsigned int major(dev_t dev); //主设备
unsigned int minor(dev_t dev); //次设备

/第五章      标准IO库******************************************/
int fwide(FILE *stream, int mode); //设置流的定向

void setbuf(FILE *stream, char *buf); //用buf当作这个流的缓冲
void setbuffer(FILE *stream, char *buf, size_t size);
void setlinebuf(FILE *stream);
int  setvbuf(FILE *stream, char *buf, int mode, size_t size);//用buf当作这个流的缓冲，且设置缓冲类型为全，行或不带缓冲

int fflush(FILE *stream); //冲洗流

FILE *fopen(const char *path, const char *mode);  //打开流
FILE *freopen(const char *path, const char *mode, FILE *stream);
FILE *fdopen(int fd, const char *mode);

//输入*****************************
int   fgetc(FILE *stream);
int   getc(FILE *stream);
int   getchar(void);  //相当于getc(stdin)
int   ungetc(int c, FILE *stream);  //把字符c压回缓冲

char *fgets(char *s, int size, FILE *stream);  //输入一行
char *gets(char *s);

//输出*****************************
int fputc(int c, FILE *stream);
int putc(int c, FILE *stream);
int putchar(int c);

int puts(const char *s);
int fputs(const char *s, FILE *stream); //输出一行

 

void clearerr(FILE *stream); //清除错误标志和结束标志
int  feof(FILE *stream);
int  ferror(FILE *stream);  //测试给定流 stream 的错误标识符。

int  fileno(FILE *stream);  //通过流获得文件描述符

size_t fread(void *ptr,         size_t size,     size_t nmemb,     FILE *stream);//二进制读
size_t fwrite(const void *ptr,     size_t size,     size_t nmemb,        FILE *stream);//二进制写

long  ftell(FILE *stream);  //告诉文件位置
int   fseek(FILE *stream, long offset, int whence);//移动文件指针
void  rewind(FILE *stream);  //把文件指针移动到开头

off_t ftello(FILE *stream);  //自己定义文件位置类型
int   fseeko(FILE *stream, off_t offset, int whence);

int   fgetpos(FILE *stream, fpos_t *pos);
int   fsetpos(FILE *stream, fpos_t *pos);

int printf(const char *format, ...);
int fprintf(FILE *stream, const char *format, ...);
int sprintf(char *str, const char *format, ...);  //写到指定数组
int snprintf(char *str, size_t size, const char *format, ...);

int vprintf(const char *format, va_list ap);
int vfprintf(FILE *stream, const char *format, va_list ap);
int vsprintf(char *str, const char *format, va_list ap);
int vsnprintf(char *str, size_t size, const char *format, va_list ap);

int scanf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *str, const char *format, ...);

int vscanf(const char *format, va_list ap);
int vsscanf(const char *str, const char *format, va_list ap);
int vfscanf(FILE *stream, const char *format, va_list ap);

int  fileno(FILE *stream);  //通过流获得对应的文件描述符

char *tmpnam(char *s); //创建一个临时文件，函数结束就自动删除或就没创建
FILE *tmpfile(void); //创建一个临时文件,进程结束就自动删除

int mkstemp(char *template);  //创建/tmp/dirXXXXXX临时文件，返回文件描述符
int mkostemp(char *template, int flags);
int mkstemps(char *template, int suffixlen);
int mkostemps(char *template, int suffixlen, int flags);
       
       
/第六章   系统数据文件和信息******************************************/
struct spwd *getspnam(const char *name);  //获取密文文件信息
struct spwd *getspent(void);
void   setspent(void);
void   endspent(void);
       
int uname(struct utsname *name);  //可以读出主机和操作系统的信息如CPU信息       
struct utsname
  {
    /* Name of the implementation of the operating system.  */
    char sysname[_UTSNAME_SYSNAME_LENGTH];

    /* Name of this node on the network.  */
    char nodename[_UTSNAME_NODENAME_LENGTH];

    /* Current release level of this implementation.  */
    char release[_UTSNAME_RELEASE_LENGTH];
    /* Current version level of this release.  */
    char version[_UTSNAME_VERSION_LENGTH];

    /* Name of the hardware type the system is running on.  */
    char machine[_UTSNAME_MACHINE_LENGTH];

    /* Name of the domain of this node on the network.  */
    char __domainname[_UTSNAME_DOMAIN_LENGTH];

  };
  
/第七章   进程环境******************************************/
int atexit(void (*function)(void));  //注册结束处理函数

命令：size   //显示一个可执行文件的内存分布

void *malloc(size_t size);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);  //重新分配地址
void  free(void *ptr);

char *getenv(const char *name);  //获取指定的环境变量
int   setenv(const char *name, const char *value, int overwrite);  //设置环境变量
int   putenv(char *string);  //添加环境变量，若存在，则删除
int   unsetenv(const char *name);  //删除环境变量，即使没有也不会出错

int  setjmp(jmp_buf env);  //设置异常返回点
int  sigsetjmp(sigjmp_buf env, int savesigs);
void longjmp(jmp_buf env, int val);  //回跳到异常返回点
void siglongjmp(sigjmp_buf env, int val);

int getrlimit(int resource, struct rlimit *rlim);  //获得限制
int setrlimit(int resource, const struct rlimit *rlim);  //设置限制
int prlimit(pid_t pid, int resource, const struct rlimit *new_limit,struct rlimit *old_limit);

/第八章    进程控制******************************************/
pid_t getpid(void);  //进程id
pid_t getppid(void);  //父进程id

uid_t getuid(void);  //用户ID
uid_t geteuid(void);       

gid_t getgid(void);  //组ID
gid_t getegid(void);

pid_t fork(void);  //创建进程
pid_t vfork(void);  //创建进程，但与父进程共享空间

pid_t wait(int *stat_loc);  //等待子进程中止，并得到返回状态
pid_t waitpid(pid_t pid, int *stat_loc, int options);
//判断是否为exit状态：WIFEXITED(stat_loc)
//把返回的值转换出来：WEXITSTATUS(stat_loc)

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);  //功能更多，可以等待指定的组ID里面的进程

pid_t wait3(int *status, int options,struct rusage *rusage);  //可以
pid_t wait4(pid_t pid, int *status, int options,struct rusage *rusage);

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg,..., char * const envp[]);

int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],char *const envp[]);

int fexecve(int fd, char *const argv[], char *const envp[]);

//L后缀：表示arg参数是一个一个传
//V后缀：表示是把arg整个数组全部传
//E后缀：表示传递环境变量数组
//P后缀：表示去filename作为参数

int setuid(uid_t uid);  //设置实际用户ID
int setgid(gid_t gid);
int setreuid(uid_t ruid, uid_t euid);   //设置实际用户ID，和有效用户ID
int setregid(gid_t rgid, gid_t egid);
int seteuid(uid_t uid);  //设置有效用户ID
int setegid(gid_t gid);

int system(const char *command);  //在函数中直接执行命令

int acct(const char *filename);  //把"filename"文件作为进程记录的文件

char *getlogin(void);   //获得当前登录用户名
int getlogin_r(char *buf, size_t bufsize);

struct passwd *getpwnam(const char *name);  //使用登录名可以获得下面结构的信息
struct passwd *getpwuid(uid_t uid);
int    getpwnam_r(const char *name, struct passwd *pwd,char *buf, size_t buflen, struct passwd **result);
int    getpwuid_r(uid_t uid, struct passwd *pwd,char *buf, size_t buflen, struct passwd **result);
/*********************/
struct passwd {
               char   *pw_name;       /* username */
               char   *pw_passwd;     /* user password */
               uid_t   pw_uid;        /* user ID */
               gid_t   pw_gid;        /* group ID */
               char   *pw_gecos;      /* user information */
               char   *pw_dir;        /* home directory */
               char   *pw_shell;      /* shell program */
           };
/*********************/

int nice(int inc);  //管理进程调度的时间

clock_t times(struct tms *buf);   //获得程序执行过程中的某一段的时间信息

 

 

 

/第九章   进程关系******************************************/
9.2：
命令: tty
    显示当前终端的文件位置
函数: ttyname
    显示当前终端的文件位置
9.3:
函数: getpgrp  ——    pid_t getpgrp(void);
    返回调用进程的进程组ID
函数: getpgid  ——   pid_t getpgid(pid_t pid); 
    返回调用进程的进程组ID
函数: setpgid  ——   int setpgid(pid_t pid, pid_t pgid);
    可以加入一个现有的进程组或者创建一个新进程组
9.5:
函数: setsid  ——     pid_t setsid(void);
    建立一个新的会话
函数: getsid  ——    pid_t getsid(pid_t pid);
    获得会话id
9.7:
函数: tcgetpgrp  ——     
    返回前台进程组ID
函数: tcsetpgrp  ——    
    设置前台进程组ID
函数: tcsetpgrp  ——    
    获得会话首进程的进程ID
    
/第十章    信号******************************************/
core 文件：    
            # ulimit -c   //默认core文件大小为0，所以一般不产生core文件
            0
            # ulimit -c 1024
            # ulimit -c
            1024
            # ./a.out 
            段错误 (核心已转储)
            # ls
            3.c  a.out core
            #gdb a.out core 
            (gdb)where  或（bt）
            #0  0x000000000040053c in core_test ()
            #1  0x0000000000400559 in main ()
10.3
gcc -S -o 1.S 1.c //生成汇编

typedef void (*sighandler_t)(int);  //信号处理函数
sighandler_t signal(    int signum,     sighandler_t handler);  //设置信号处理函数
int sigaction(int sig, const struct sigaction *restrict act,struct sigaction *restrict oact);
struct sigaction
{
    void(*sa_handler) (int signo) //信号处理函数
    sigset_t          sa_mask  //信号集
    int sa_flags            //标志位          
    void(*sa_sigaction) (void *, siginfo_t *, void *)    //指向信号捕捉功能的指针。
}

int pause(void);  //休眠，直到收到一个信号

命令：kill -l    //显示所有信号的宏名

int kill(pid_t pid, int sig);  //给进程发送信号
int raise(int sig);  //发送给所有进程

unsigned int alarm(unsigned int seconds);  //闹钟函数

int sigemptyset(sigset_t *set);  //清除空间
int sigfillset(sigset_t *set);  //清除空间，并加入所有信号
int sigaddset(sigset_t *set, int signum);  //添加信号
int sigdelset(sigset_t *set, int signum);  //删除信号
int sigismember(const sigset_t *set, int signum);  //测试信号signum是否再信号集set中

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); //设置信号屏蔽集
                                            //SIG_BLOCK ，把原来的信号屏蔽集与set的信号集，构成一个并集，变成一个新的信号屏蔽集
                                            //SIG_SETMASK ，把原来的信号屏蔽集与set的信号集，构成一个交集，变成一个新的信号屏蔽集
                                            //SIG_UNBLOCK ，把set的信号集变成一个新的信号屏蔽集

void siglongjmp(sigjmp_buf env, int val);  //跳转
int  sigsetjmp(sigjmp_buf env, int savesigs);  //设置跳转点

int sigpending(sigset_t *set);  //测试信号

 

void abort(void);

int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);  //纳米级休眠
int clock_nanosleep(clockid_t clock_id, int flags,const struct timespec *rqtp, struct timespec *rmtp);  //基于特定时钟的休眠

int sigqueue(pid_t pid, int sig, const union sigval value);  //信号排队发送函数

 

 

/第十一章   线程******************************************/
int pthread_equal(pthread_t t1, pthread_t t2);  //对两个线程ID进行比较

pthread_t pthread_self(void);    //获得自身的线程ID

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);  //创建线程

void pthread_exit(void *retval);  //主动退出线程
int pthread_join(pthread_t thread, void **retval);   //等待线程结束并，并接收返回值

int pthread_cancel(pthread_t thread);  //同一进程的线程取消其他线程

void pthread_cleanup_push(void (*routine)(void *),void *arg);   //注册线程清理函数
void pthread_cleanup_pop(int execute);   //触发清理函数

/********************************  互斥量  *******/
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);  //互斥锁初始化
int pthread_mutex_lock(pthread_mutex_t *mutex);   //互斥锁上锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);  //互斥锁判断上锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);   //互斥锁解锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);  //消除互斥锁

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,const struct timespec *restrict abs_timeout);  //在绝对时间内等待锁

/********************************  读写锁  *******/
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);   //读写锁初始化  
           
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);   //读写锁上 读 锁
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);   //读写锁判断 可读

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);   //读写锁上 写 锁
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);   //读写锁判断 可写
       
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);      //读写锁解锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);   //读写锁消除

int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict abs_timeout);  //在绝对时间内等待 写 锁
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict abs_timeout);  //在绝对时间内等待 读 锁

/********************************  条件变量 *******/
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);     //使用初始化函数

int pthread_cond_destroy(pthread_cond_t *cond);          //条件变量的销毁函数

int pthread_cond_timedwait(pthread_cond_t *restrict cond,         //条件变量等待函数
              pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);

int pthread_cond_broadcast(pthread_cond_t *cond);  //通知所有消费者
int pthread_cond_signal(pthread_cond_t *cond);   //只能唤醒其中任意一个消费者

/********************************  自旋锁  *******/
int pthread_spin_lock(pthread_spinlock_t *lock);     //上锁
int pthread_spin_trylock(pthread_spinlock_t *lock);   //自旋锁判断

int pthread_spin_unlock(pthread_spinlock_t *lock);   //释放自旋锁

int pthread_spin_destroy(pthread_spinlock_t *lock);   //清除自旋锁
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);   //初始化

/********************************  屏障  *******/
int pthread_barrier_destroy(pthread_barrier_t *barrier);  //销毁
int pthread_barrier_init(pthread_barrier_t *restrict barrier,   //count指定所有线程继续运行之前，必须到达屏障的线程数量
                        const pthread_barrierattr_t *restrict attr, unsigned count);
int pthread_barrier_wait(pthread_barrier_t *barrier);    //等待所有线程达到

 

 

                        
/第十二章   线程控制******************************************/
                        
int pthread_attr_init(pthread_attr_t *attr);   //属性初始化
int pthread_attr_destroy(pthread_attr_t *attr);       //销毁attr    
                
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);  //设置分离状态属性
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);  //获取分离状态属性                        
                                    //PTHREAD_CREATE_DETACHED  ———— 分离态                        
                                    //PTHREAD_CREATE_JOINABLE  ———— 正常态                    
int pthread_attr_setstack(pthread_attr_t *attr,void *stackaddr, size_t stacksize);  //设置栈的大小
int pthread_attr_getstack(pthread_attr_t *attr,void **stackaddr, size_t *stacksize);  //获取栈的大小
                        
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);  //设置栈的最先大小，如PTHREAD_STACK_MIN (16384) bytes.
int pthread_attr_getstacksize(pthread_attr_t *attr, size_t *stacksize);      //获取栈的最大大小                    
                        
int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);  //设置栈溢出后，缓冲区的大小
int pthread_attr_getguardsize(pthread_attr_t *attr, size_t *guardsize);  //获得栈溢出后，缓冲区的大小                    
                        
                        
int pthread_attr_setstack();  //设置栈的大小
int pthread_attr_getstack();  //获取栈的大小
                        
int pthread_attr_setstacksize();  //设置栈的最先大小，如PTHREAD_STACK_MIN (16384) bytes.
int pthread_attr_getstacksize();      //获取栈的最大大小                    
                        
int pthread_attr_setguardsize();  //设置栈溢出后，缓冲区的大小
int pthread_attr_getguardsize();  //获得栈溢出后，缓冲区的大小                            
                        
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);  //互斥量属性销毁
int pthread_mutexattr_init(pthread_mutexattr_t *attr);  //互斥量属性初始化                        

//线程取消                        
int pthread_setcancelstate(int state, int *oldstate);
                             //PTHREAD_CANCEL_ENABLE 线程是可取消的，这是所有新线程的默认取消状态
                             //PTHREAD_CANCEL_DISABLE 线程是不可取消的，如果接收到取消请求，它将被阻塞，直到可以celability启用。
int pthread_setcanceltype(int type, int *oldtype);   //在还没到达取消点时，可以通过这个修改取消类型                             
void pthread_testcancel(void);  //自己添加取消点                        

//线程信号                        
int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset);  //    屏蔽字修改函数                
int pthread_kill(pthread_t thread, int signo);    //向指定线程发送信号                          
int sigwait(const sigset_t *restrict set, int *restrict signop);  //等待信号集的任意一个信号                        
                        
int pthread_atfork(void (*prepare)(void), void (*parent)(void),void (*child)(void));  //线程创建进程                        
                        
                        
                        
/第十三章  守护进程******************************************/
                        
void openlog(const char *ident, int option, int facility);  //打开日志文件/var/log/syslog
void syslog(int priority, const char *format, ...);  //向日志文件写内容
void closelog(void);                                  //关闭日志文件    
                        
                        
/第十四章  高级IO******************************************/                        
O_NONBLOCK  //实现非阻塞打开                        
                        
int fcntl(int fd, int cmd, ... /* arg */ );   //文件锁                        

//————————————————————— IO多路复用 ——————————————                        
int pselect(int nfds, fd_set *restrict readfds,
              fd_set *restrict writefds, fd_set *restrict errorfds,
              const struct timespec *restrict timeout,
              const sigset_t *restrict sigmask);
int select(int nfds, fd_set *restrict readfds,
              fd_set *restrict writefds, fd_set *restrict errorfds,
              struct timeval *restrict timeout);
void FD_CLR(int fd, fd_set *fdset);
int  FD_ISSET(int fd, fd_set *fdset);
void FD_SET(int fd, fd_set *fdset);
void FD_ZERO(fd_set *fdset);                        
                        
int poll(struct pollfd fds[], nfds_t nfds, int timeout);                        
                        
/////////////////  异步I/O
int aio_read(struct aiocb *aiocbp);  /* 提交一个异步读 */
int aio_write(struct aiocb *aiocbp); /* 提交一个异步写 */
int aio_cancel(int fildes, struct aiocb *aiocbp); /* 取消一个异步请求（或基于一个fd的所有异步请求，aiocbp==NULL） */
int aio_error(const struct aiocb *aiocbp);        /* 查看一个异步请求的状态（进行中EINPROGRESS？还是已经结束或出错？） */
ssize_t aio_return(struct aiocb *aiocbp);         /* 查看一个异步请求的返回值（跟同步读写定义的一样） */
int aio_suspend(const struct aiocb * const list[], int nent, const struct timespec *timeout); /* 阻塞等待请求完成 */
int aio_fsync(int op, struct aiocb *aiocbp);
int aio_error(const struct aiocb *aiocbp);
int lio_listio(int mode, struct aiocb *const aiocb_list[],
                      int nitems, struct sigevent *sevp);

struct sigevent {
    int sigev_notify; //通知类型
    int sigev_signo; //信号的编号
    union sigval sigev_value; //sigev_notify_function传递的参数
    void (*sigev_notify_function)(union sigval); /* 异步IO请求完成后，执行的函数 */
    pthread_attr_t *sigev_notify_attributes; /* notify attrs */
};

//分散读和集中写
ssize_t readv(int fd, const struct iovec *iov, int iovcnt);  
ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
ssize_t preadv(int fd, const struct iovec *iov, int iovcnt,off_t offset);
ssize_t pwritev(int fd, const struct iovec *iov, int iovcnt,off_t offset);

struct iovec {
    void  *iov_base;    /* Starting address */
    size_t iov_len;     /* 要读的区域的长度 */
};

//存储IO映射
void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);  //建立存储空间
int   munmap(void *addr, size_t length);  //解除存储空间

int mprotect(void *addr, size_t len, int prot);  //更改现有映射的权限

int msync(void *addr, size_t length, int flags);  //冲洗空间

/第十五章  进程间通信******************************************/                        

int pipe(int pipefd[2]);  //创建无名管道

FILE *popen(const char *command, const char *type);  //创建标准流管道   如：popen(“ls -a”, "r")
int   pclose(FILE *stream);                            //关闭标准流管道
       
int mkfifo(const char *pathname, mode_t mode);  //创建有名管道

//信号量
int semget(key_t key, int nsems, int semflg);  //创建或获取信号量
int semop(int semid, struct sembuf *sops, size_t nsops)  //获得或释放一个信号量
int semctl(int semid, int semnum, int cmd, union semun arg);  //信号量控制
key_t ftok(const char *pathname, int proj_id);  //创建IPC的key(键)

//共享内存
int   shmget(key_t key, size_t size, int shmflg);  //从内存中获得一段共享内存区域
void *shmat(int shmid, const void *shmaddr, int shmflg);  //映射共享内存
int   shmdt(const void *shmaddr);   //撤销共享内存
int   shmctl(int shmid, int cmd, struct shmid_ds *buf);  //共享内存控制

ipcs -m  //显示系统中的共享内存

//消息队列
int     msgget(key_t key, int msgflg);  //创建或打开消息队列
int     msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);  //添加消息
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);//读取消息
int     msgctl(int msqid, int cmd, struct msqid_ds *buf);  //控制消息队列

 

https://mp.weixin.qq.com/s?__biz=MjM5NTY1MjY0MQ==&mid=2650743347&idx=4&sn=9b3a1c10621be2e731442eec76befa5e&chksm=befeb77d89893e6b1bee7ecb7fe56dfa3153557d75e90f74624d1c099eaea4a7afad2f437ef8&mpshare=1&scene=23&srcid=1003iQLxzdASp2KwgaAHJ9e2#rd

 

/*
*
*******************************          驱动          **************************
*
*/

lsmod(list module,将模块列表显示)
insmod（install module，安装模块）
modinfo（module information，模块信息）
rmmod（remove module，卸载模块）
modprobe、depmod，可以添加依赖

dmesg  //正常得不到驱动的输出信息，可以用这个显示

//创建设备文件
mknod filename type major minor   //如：mknod /dev/test c  251 0

register_chrdev_region()   //新的指定注册
alloc_chrdev_region()      //系统自动分配
unregister_chrdev_region() //注销

static inline int register_chrdev(unsigned int major, const char *name,
                  const struct file_operations *fops)          //老的指定注册

cat /proc/devices      //打印所有设备

//用户空间和内核空间的转换
copy_from_user(void *to, const void __user *from, unsigned long n)  //用来将数据从  用户  空间复制到  内核  空间
copy_to_user(void __user *to, const void *from, unsigned long n)   //用来将数据从  内核  空间复制到  用户  空间

//如果要复制的内存是简单类型，如char、 int、 long等
put_user()
get_user()

int val;                    /* 内核空间整型变量*/
get_user(val, (int *) arg); /* 用户→内核， arg是用户空间的地址 */
put_user(val, (int *) arg); /* 内核→用户， arg是用户空间的地址 */

///////////////////////////////////////

request_mem_region(start,n,name)  //向内核申请（报告）需要映射的内存资源
release_mem_region(start,n)    //销毁内存资源
ioremap(cookie,size)             //真正用来实现映射，传给他物理地址他给你映射返回一个虚拟地址
iounmap(cookie)               //销毁映射

/*************  新的指定注册  方式        *************/
int register_chrdev_region(dev_t from, unsigned count, const char *name)        //函数用于已知起始设备的设备号的情况

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name)//用于设备号未知，向系统动态申请未被占用的设备号的情况，
                                                                                       //函数调用成功之后，会把得到的设备号放入第一个参数dev中

unregister_chrdev_region    (dev_t from, unsigned count)                       //释放原先申请的设备号

cdev_alloc             //用于动态申请一个cdev内存
void cdev_init(struct cdev *, struct file_operations *)       //用于初始化cdev的成员，并建立cdev和file_operations之间的连接
int cdev_add(struct cdev *, dev_t, unsigned)               //注册，它的调用通常发生在字符设备驱动模块加载函数中
void cdev_del(struct cdev *)                                 //注销，它的函数的调用则通常发生在字符设备驱动模块卸载函数中

struct cdev {
2 struct kobject kobj; /* 内嵌的kobject对象 */
3 struct module *owner; /* 所属模块*/
4 struct file_operations *ops; /* 文件操作结构体*/
5 struct list_head list;
6 dev_t dev; /* 设备号*/
7 unsigned int count;
}

//处理设备号的宏定义
MAJOR(dev_t dev)                    //从设备号中提取major  
MINOR(dev_t dev)                   //从设备号中提取major和minor
MKDEV(int major,int minor);         //通过major和minor构建设备号dev_t

一般用法：
register_chrdev_region + cdev_init + cdev_add   //注册
cdev_del + unregister_chrdev_region              //销毁
/******************************************************/

/*************    创建设备文件   **************/
class_create(owner, name)  //创建一个设备类 
owner：THIS_MODULE
name  : 名字

 

//创建后会产生/sys/class/ljj_class，/sys/devices/virtual/ljj_class
//和  ls  /sys/class/ljj_class/test/
-r--r--r--    1 root     0             4096 Jan  1 12:01 dev
drwxr-xr-x    2 root     0                0 Jan  1 12:03 power
lrwxrwxrwx    1 root     0                0 Jan  1 12:03 subsystem -> ../../../../class/ljj_class
-rw-r--r--    1 root     0             4096 Jan  1 12:03 uevent

void class_destroy(struct class *cls)   //销毁一个设备类

struct device *device_create(struct class *class, struct device *parent,
            dev_t devt, void *drvdata, const char *fmt, ...)  //创建一个字符设备文件
struct class *class  ：类
struct device *parent：NULL
dev_t devt  ：设备号
void *drvdata  ：NULL
const char *fmt  ：名字

device_destroy(struct class *class, dev_t devt);  //销毁一个字符设备文件

/*************************************************/
readb(c)        //c为要读的地址
writel(v,  c)   //v为要写的值，c为要写的地址