可以參考這個：
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檔案
# 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); //控制消息隊列
/*
*
******************************* 驅動 **************************
*
*/
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為要寫的位址
![使用tkinter 實作一個猜數字遊戲[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)