可以參考這個：

/第三章   檔案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為要寫的地址