mutex相关的函数并不是linux kernel实现的，而是glibc实现的，源码位于nptl目录下。
http://ftp.gnu.org/pub/gnu/glibc/glibc-2.3.5.tar.gz
首先说数据结构：
typedef union
{
struct
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
/* KIND must stay at this position in the structure to maintain
binary compatibility. */
int __kind;
int __spins;
} __data;
char __size[__SIZEOF_PTHREAD_MUTEX_T];
long int __align;
} pthread_mutex_t;
int __lock; 资源竞争引用计数
int __kind; 锁类型，init 函数中mutexattr 参数传递，该参数可以为NULL，一般为 PTHREAD_MUTEX_NORMAL
结构体其他元素暂时不了解，以后更新。
/*nptl/pthread_mutex_init.c*/
int
__pthread_mutex_init (mutex, mutexattr)
pthread_mutex_t *mutex;
const pthread_mutexattr_t *mutexattr;
{
const struct pthread_mutexattr *imutexattr;
assert (sizeof (pthread_mutex_t) <= __SIZEOF_PTHREAD_MUTEX_T);
imutexattr = (const struct pthread_mutexattr *) mutexattr ?: &default_attr;
/* Clear the whole variable. */
memset (mutex, '\0', __SIZEOF_PTHREAD_MUTEX_T);
/* Copy the values from the attribute. */
mutex->__data.__kind = imutexattr->mutexkind & ~0x80000000;
/* Default values: mutex not used yet. */
// mutex->__count = 0; already done by memset
// mutex->__owner = 0; already done by memset
// mutex->__nusers = 0; already done by memset
// mutex->__spins = 0; already done by memset
return 0;
}
init函数就比较简单了，将mutex结构体清零，设置结构体中__kind属性。
/*nptl/pthread_mutex_lock.c*/
int
__pthread_mutex_lock (mutex)
pthread_mutex_t *mutex;
{
assert (sizeof (mutex->__size) >= sizeof (mutex->__data));
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))
{
…
default:
/* Correct code cannot set any other type. */
case PTHREAD_MUTEX_TIMED_NP:
simple:
/* Normal mutex. */
LLL_MUTEX_LOCK (mutex->__data.__lock);
break;
…
}
/* Record the ownership. */
assert (mutex->__data.__owner == 0);
mutex->__data.__owner = id;
#ifndef NO_INCR
++mutex->__data.__nusers;
#endif
return 0;
}
该函数主要是调用LLL_MUTEX_LOCK， 省略部分为根据mutex结构体__kind属性不同值做些处理。
宏定义函数LLL_MUTEX_LOCK最终调用，将结构体mutex的__lock属性作为参数传递进来
#define __lll_mutex_lock(futex) \
((void) ({ \
int *__futex = (futex); \
if (atomic_compare_and_exchange_bool_acq (__futex, 1, 0) != 0) \
__lll_lock_wait (__futex); \
}))
atomic_compare_and_exchange_bool_acq (__futex, 1, 0)宏定义为：
#define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \
({ __typeof (mem) __gmemp = (mem); \
__typeof (*mem) __gnewval = (newval); \
\
*__gmemp == (oldval) ? (*__gmemp = __gnewval, 0) : 1; })
这个宏实现的功能是：
如果mem的值等于oldval，则把newval赋值给mem，放回0，否则不做任何处理，返回1.
由此可以看出，当mutex锁限制的资源没有竞争时，__lock 属性被置为1，并返回0，不会调用__lll_lock_wait (__futex); 当存在竞争时，再次调用lock函数，该宏不做任何处理，返回1，调用__lll_lock_wait (__futex);
void
__lll_lock_wait (int *futex)
{
do
{
int oldval = atomic_compare_and_exchange_val_acq (futex, 2, 1);
if (oldval != 0)
lll_futex_wait (futex, 2);
}
while (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0);
}
atomic_compare_and_exchange_val_acq (futex, 2, 1); 宏定义：
/* The only basic operation needed is compare and exchange. */
#define atomic_compare_and_exchange_val_acq(mem, newval, oldval) \
({ __typeof (mem) __gmemp = (mem); \
__typeof (*mem) __gret = *__gmemp; \
__typeof (*mem) __gnewval = (newval); \
\
if (__gret == (oldval)) \
*__gmemp = __gnewval; \
__gret; })
这个宏实现的功能是，当mem等于oldval时，将mem置为newval，始终返回mem原始值。
此时，futex等于1，futex将被置为2，并且返回1. 进而调用
lll_futex_wait (futex, 2);
#define lll_futex_timed_wait(ftx, val, timespec) \
({ \
DO_INLINE_SYSCALL(futex, 4, (long) (ftx), FUTEX_WAIT, (int) (val), \
(long) (timespec)); \
_r10 == -1 ? -_retval : _retval; \
})
该宏对于不同的平台架构会用不同的实现，采用汇编语言实现系统调用。不过确定的是调用了Linux kernel的futex系统调用。
futex在linux kernel的实现位于：kernel/futex.c
SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,
struct timespec __user *, utime, u32 __user *, uaddr2,
u32, val3)
{
struct timespec ts;
ktime_t t, *tp = NULL;
u32 val2 = 0;
int cmd = op & FUTEX_CMD_MASK;
if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||
cmd == FUTEX_WAIT_BITSET ||
cmd == FUTEX_WAIT_REQUEUE_PI)) {
if (_from_user(&ts, utime, sizeof(ts)) != 0)
return -EFAULT;
if (!timespec_valid(&ts))
return -EINVAL;
t = timespec_to_ktime(ts);
if (cmd == FUTEX_WAIT)
t = ktime_add_safe(ktime_get(), t);
tp = &t;
}
/*
* requeue parameter in 'utime' if cmd == FUTEX_*_REQUEUE_*.
* number of waiters to wake in 'utime' if cmd == FUTEX_WAKE_OP.
*/
if (cmd == FUTEX_REQUEUE || cmd == FUTEX_CMP_REQUEUE ||
cmd == FUTEX_CMP_REQUEUE_PI || cmd == FUTEX_WAKE_OP)
val2 = (u32) (unsigned long) utime;
return do_futex(uaddr, op, val, tp, uaddr2, val2, val3);
}
futex具有六个形参，pthread_mutex_lock最终只关注了前四个。futex函数对参数进行判断和转化之后，直接调用do_futex。
long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
u32 __user *uaddr2, u32 val2, u32 val3)
{
int clockrt, ret = -ENOSYS;
int cmd = op & FUTEX_CMD_MASK;
int fshared = 0;
if (!(op & FUTEX_PRIVATE_FLAG))
fshared = 1;
clockrt = op & FUTEX_CLOCK_REALTIME;
if (clockrt && cmd != FUTEX_WAIT_BITSET && cmd != FUTEX_WAIT_REQUEUE_PI)
return -ENOSYS;
switch (cmd) {
case FUTEX_WAIT:
val3 = FUTEX_BITSET_MATCH_ANY;
case FUTEX_WAIT_BITSET:
ret = futex_wait(uaddr, fshared, val, timeout, val3, clockrt);
break;
…
default:
ret = -ENOSYS;
}
return ret;
}
省略部分为对其他cmd的处理，pthread_mutex_lock函数最终传入的cmd参数为FUTEX_WAIT，所以在此只关注此分之，分析futex_wait函数的实现。
static int futex_wait(u32 __user *uaddr, int fshared,
u32 val, ktime_t *abs_time, u32 bitset, int clockrt)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct restart_block *restart;
struct futex_hash_bucket *hb;
struct futex_q q;
int ret;
… … //delete parameters check and convertion
retry:
/* Prepare to wait on uaddr. */
ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
if (ret)
goto out;
/* queue_me and wait for wakeup, timeout, or a signal. */
futex_wait_queue_me(hb, &q, to);
… … //other handlers
return ret;
}
futex_wait_setup 将线程放进休眠队列中，
futex_wait_queue_me(hb, &q, to);将本线程休眠，等待唤醒。
唤醒后，__lll_lock_wait函数中的while (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0); 语句将被执行，由于此时futex在pthread_mutex_unlock中置为0，所以atomic_compare_and_exchange_bool_acq (futex, 2, 0)语句将futex置为2，返回0. 退出循环，访问用户控件的临界资源。
/*nptl/pthread_mutex_unlock.c*/
int
internal_function attribute_hidden
__pthread_mutex_unlock_usercnt (mutex, decr)
pthread_mutex_t *mutex;
int decr;
{
switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))
{
… …
default:
/* Correct code cannot set any other type. */
case PTHREAD_MUTEX_TIMED_NP:
case PTHREAD_MUTEX_ADAPTIVE_NP:
/* Normal mutex. Nothing special to do. */
break;
}
/* Always reset the owner field. */
mutex->__data.__owner = 0;
if (decr)
/* One less user. */
--mutex->__data.__nusers;
/* Unlock. */
lll_mutex_unlock (mutex->__data.__lock);
return 0;
}
省略部分是针对不同的__kind属性值做的一些处理，最终调用 lll_mutex_unlock。
该宏函数最终的定义为：
#define __lll_mutex_unlock(futex) \
((void) ({ \
int *__futex = (futex); \
int __val = atomic_exchange_rel (__futex, 0); \
\
if (__builtin_expect (__val > 1, 0)) \
lll_futex_wake (__futex, 1); \
}))
atomic_exchange_rel (__futex, 0);宏为：
#define atomic_exchange_rel(mem, value) \
(__sync_synchronize (), __sync_lock_test_and_set (mem, value))
实现功能为：将mem设置为value，返回原始mem值。
__builtin_expect (__val > 1, 0) 是编译器优化语句，告诉编译器期望值，也就是大多数情况下__val > 1 ？是0，其逻辑判断依然为if(__val > 1)为真的话执行 lll_futex_wake。
现在分析，在资源没有被竞争的情况下，__futex 为1，那么返回值__val则为1，那么 lll_futex_wake (__futex, 1); 不会被执行，不产生系统调用。 当资源产生竞争的情况时，根据对pthread_mutex_lock 函数的分析，__futex为2， __val则为2，执行 lll_futex_wake (__futex, 1); 从而唤醒等在临界资源的线程。
lll_futex_wake (__futex, 1); 最终会调动同一个系统调用，即futex, 只是传递的cmd参数为FUTEX_WAKE。
在linux kernel的futex实现中，调用
static int futex_wake(u32 __user *uaddr, int fshared, int nr_wake, u32 bitset)
{
struct futex_hash_bucket *hb;
struct futex_q *this, *next;
struct plist_head *head;
union futex_key key = FUTEX_KEY_INIT;
int ret;
if (!bitset)
return -EINVAL;
ret = get_futex_key(uaddr, fshared, &key);
if (unlikely(ret != 0))
goto out;
hb = hash_futex(&key);
spin_lock(&hb->lock);
head = &hb->chain;
plist_for_each_entry_safe(this, next, head, list) {
if (match_futex (&this->key, &key)) {
if (this->pi_state || this->rt_waiter) {
ret = -EINVAL;
break;
}
/* Check if one of the bits is set in both bitsets */
if (!(this->bitset & bitset))
continue;
wake_futex(this);
if (++ret >= nr_wake)
break;
}
}
spin_unlock(&hb->lock);
put_futex_key(fshared, &key);
out:
return ret;
}
该函数遍历在该mutex上休眠的所有线程，调用wake_futex进行唤醒，
static void wake_futex(struct futex_q *q)
{
struct task_struct *p = q->task;
/*
* We set q->lock_ptr = NULL _before_ we wake up the task. If
* a non futex wake up happens on another CPU then the task
* might exit and p would dereference a non existing task
* struct. Prevent this by holding a reference on p across the
* wake up.
*/
get_task_struct(p);
plist_del(&q->list, &q->list.plist);
/*
* The waiting task can free the futex_q as soon as
* q->lock_ptr = NULL is written, without taking any locks. A
* memory barrier is required here to prevent the following
* store to lock_ptr from getting ahead of the plist_del.
*/
smp_wmb();
q->lock_ptr = NULL;
wake_up_state(p, TASK_NORMAL);
put_task_struct(p);
}
wake_up_state(p, TASK_NORMAL); 的实现位于kernel/sched.c中，属于linux进程调度的技术。
B. linux proc下etime和time的区别
当你同熟练的UNIX用户进行交谈时，你经常会听到他们傲慢地讲出术语“改变时间(change time)”和“修改时间(modification time)”。对于许多人(和许多字典而言),改变和修改是相同的。这里会有什么不同那？
改变和修改之间的区别在于是改某个组件的标签还是更改它的内容。如果有人说chmod a-w myfile,那么这是一个改变；如果有人说echo foo >> myfile,那么
这是一个修改。改变是文件的索引节点发生了改变；修改是文本本身的内容发生了变化。[文件的修改时间也叫时间标志 (timestamp).]
只要讨论改变时间和修改时间，就不可能不提到“访问时间(access time)”.访问时间是文件最后一次被读取的时间。因此阅读一个文件会更新它的访问时间，当它的改变时间并没有变化(有关文件的信息没有被改变)，它的修改时间也同样如此(文件本身没有被改变)
有时，在许多地方改变时间或者“ctime”被错误地写成“创建时间”，包括某些UNIX参考手册。不要相信他们
下面是我man出来的内容，仅供参考！
st_atime
Time when file data was last accessed. Changed by the
following functions: creat(), mknod(), pipe(),
utime(2), and read(2).
st_mtime
Time when data was last modified. Changed by the fol-
lowing functions: creat(), mknod(), pipe(), utime(),
and write(2).
st_ctime
Time when file status was last changed. Changed by the
following functions: chmod(), chown(), creat(),
link(2), mknod(), pipe(), unlink(2), utime(), and
write().
ls显示出的time应该是mtime。
touch后，文件的三个时间应该都会改变，可以试一试。
问题描述
文件的 ctime、mtime、atime 之间有什么区别?
配置信息
解决方法
文件的 Access time，atime 是在读取文件或者执行文件时更改的。
文件的 Modified time，mtime 是在写入文件时随文件内容的更改而更改的。
文件的 Create time，ctime 是在写入文件、更改所有者、权限或链接设置时随 Inode 的内容更改而更改的。
因此，更改文件的内容即会更改 mtime 和 ctime，但是文件的 ctime 可能会在 mtime 未发生任何变化时更改 - 在权限更改，但是文件内容没有变化的情况下。
ls(1) 命令可用来列出文件的 atime、ctime 和 mtime。
ls -lc filename 列出文件的 ctime
ls -lu filename 列出文件的 atime
ls -l filename 列出文件的 mtime
atime不一定在访问文件之后被修改，因为：使用ext3文件系统的时候，如果在mount的时候使用了noatime参数那么就不会更新atime的 信息。而这是加了 noatime 取消了, 不代表真实情况.反正, 这三个 time stamp 都放在 inode 中.若 mtime, atime 修改, inode 就一定会改, 既然 inode 改了, 那 ctime 也就跟着要改了.之所以在 mount option 中使用 noatime, 就是不想 file system 做太多的修改, 而改善读取效能.
C. linux c 对链表进行操作需要哪些头文件
linux和windows平台下，能够对应的头文件就是符合C11标准的头文件。其他的头文件不仅和平台有关系，还和平台下的编译环境有关，很难画上等号的。C语言符合标准的头文件.
#include <assert.h> //设定插入点
#include <ctype.h> //字符处理
#include <errno.h> //定义错误码
#include <float.h> //浮点数处理
#include <fstream.h> //文件输入／输出
#include <iomanip.h> //参数化输入／输出
#include <iostream.h> //数据流输入／输出
#include <limits.h> //定义各种数据类型最值常量
#include <locale.h> //定义本地化函数
#include <math.h> //定义数学函数
#include <stdio.h> //定义输入／输出函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <strstrea.h> //基于数组的输入／输出
#include <time.h> //定义关于时间的函数
#include <wchar.h> //宽字符处理及输入／输出
#include <wctype.h> //宽字符分类
linux常用头文件如下：
POSIX标准定义的头文件
<dirent.h> 目录项
<fcntl.h> 文件控制
<fnmatch.h> 文件名匹配类型
<glob.h> 路径名模式匹配类型
<grp.h> 组文件
<netdb.h> 网络数据库操作
<pwd.h> 口令文件
<regex.h> 正则表达式
<tar.h> TAR归档值
<termios.h> 终端I/O
<unistd.h> 符号常量
<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> 基本系统数据类型
<sys/un.h> UNIX域套接字定义
<sys/utsname.h> 系统名
<sys/wait.h> 进程控制
------------------------------
POSIX定义的XSI扩展头文件
D. linux c++ 如何获取 系统时间
用cstlib函数time，比如
#include <iostream>
#include <cstlib>
using namespace std;
int main()
{
int t, h, m, s;
t = time( 0 );
t = t % 86400;
s = t % 60;
t = ( t - s ) / 60;
m = t % 60;
t = ( t - m ) / 60;
h = t;
cout << "现在是" << h << ":" << m << ":" << s << endl;
return 0;
}
即可显示
E. windows与linux 头文件对照
1.linux和windows平台下，能够对应的头文件就是符合C11标准的头文件。其他的头文件不仅和平台有关系，还和平台下的编译环境有关，很难画上等号的。
2.C语言符合标准的头文件
#include <assert.h> //设定插入点
#include <ctype.h> //字符处理
#include <errno.h> //定义错误码
#include <float.h> //浮点数处理
#include <fstream.h> //文件输入／输出
#include <iomanip.h> //参数化输入／输出
#include <iostream.h> //数据流输入／输出
#include <limits.h> //定义各种数据类型最值常量
#include <locale.h> //定义本地化函数
#include <math.h> //定义数学函数
#include <stdio.h> //定义输入／输出函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <strstrea.h> //基于数组的输入／输出
#include <time.h> //定义关于时间的函数
#include <wchar.h> //宽字符处理及输入／输出
#include <wctype.h> //宽字符分类
3.linux常用头文件如下：
POSIX标准定义的头文件
<dirent.h> 目录项
<fcntl.h> 文件控制
<fnmatch.h> 文件名匹配类型
<glob.h> 路径名模式匹配类型
<grp.h> 组文件
<netdb.h> 网络数据库操作
<pwd.h> 口令文件
<regex.h> 正则表达式
<tar.h> TAR归档值
<termios.h> 终端I/O
<unistd.h> 符号常量
<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> 基本系统数据类型
<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> 事件跟踪
F. Linux下touch命令有什么作用如何使用
touch命令有两个功能：一是用于把已存在文件的时间标签更新为系统当前的时间（默认方式），它们的数据将原封不动地保留下来；二是用来创建新的空文件。
其它说明：
语法
touch(选项)(参数)
选项
-a：或--time=atime或--time=access或--time=use 只更改存取时间；
-c：或--no-create 不建立任何文件；
-d：<时间日期> 使用指定的日期时间，而非现在的时间；
-f：此参数将忽略不予处理，仅负责解决BSD版本touch指令的兼容性问题；
-m：或--time=mtime或--time=modify 只更该变动时间；
-r：<参考文件或目录> 把指定文件或目录的日期时间，统统设成和参考文件或目录的日期时间相同；
-t：<日期时间> 使用指定的日期时间，而非现在的时间；
--help：在线帮助；
--version：显示版本信息。
参数
文件：指定要设置时间属性的文件列表。
实例
touch ex2
在当前目录下建立一个空文件ex2，然后，利用ls -l命令可以发现文件ex2的大小为0，表示它是空文件。
G. 怎样查询linux系统调用函数
以下是Linux系统调用的一个列表，包含了大部分常用系统调用和由系统调用派生出的的函数。这可能是你在互联网上所能看到的唯一一篇中文注释的Linux系统调用列表，即使是简单的字母序英文列表，能做到这么完全也是很罕见的。
按照惯例，这个列表以man pages第2节，即系统调用节为蓝本。按照笔者的理解，对其作了大致的分类，同时也作了一些小小的修改，删去了几个仅供内核使用，不允许用户调用的系统调用，对个别本人稍觉不妥的地方作了一些小的修改，并对所有列出的系统调用附上简要注释。
其中有一些函数的作用完全相同，只是参数不同。（可能很多熟悉C++朋友马上就能联想起函数重载，但是别忘了Linux核心是用C语言写的，所以只能取成不同的函数名）。还有一些函数已经过时，被新的更好的函数所代替了（gcc在链接这些函数时会发出警告），但因为兼容的原因还保留着，这些函数我会在前面标上“*”号以示区别。
一、进程控制：
fork 创建一个新进程
clone 按指定条件创建子进程
execve 运行可执行文件
exit 中止进程
_exit 立即中止当前进程
getdtablesize 进程所能打开的最大文件数
getpgid 获取指定进程组标识号
setpgid 设置指定进程组标志号
getpgrp 获取当前进程组标识号
setpgrp 设置当前进程组标志号
getpid 获取进程标识号
getppid 获取父进程标识号
getpriority 获取调度优先级
setpriority 设置调度优先级
modify_ldt 读写进程的本地描述表
nanosleep 使进程睡眠指定的时间
nice 改变分时进程的优先级
pause 挂起进程，等待信号
personality 设置进程运行域
prctl 对进程进行特定操作
ptrace 进程跟踪
sched_get_priority_max 取得静态优先级的上限
sched_get_priority_min 取得静态优先级的下限
sched_getparam 取得进程的调度参数
sched_getscheler 取得指定进程的调度策略
sched_rr_get_interval 取得按RR算法调度的实时进程的时间片长度
sched_setparam 设置进程的调度参数
sched_setscheler 设置指定进程的调度策略和参数
sched_yield 进程主动让出处理器,并将自己等候调度队列队尾
vfork 创建一个子进程，以供执行新程序，常与execve等同时使用
wait 等待子进程终止
wait3 参见wait
waitpid 等待指定子进程终止
wait4 参见waitpid
capget 获取进程权限
capset 设置进程权限
getsid 获取会晤标识号
setsid 设置会晤标识号
二、文件系统控制
1、文件读写操作
fcntl 文件控制
open 打开文件
creat 创建新文件
close 关闭文件描述字
read 读文件
write 写文件
readv 从文件读入数据到缓冲数组中
writev 将缓冲数组里的数据写入文件
pread 对文件随机读
pwrite 对文件随机写
lseek 移动文件指针
_llseek 在64位地址空间里移动文件指针
p 复制已打开的文件描述字
p2 按指定条件复制文件描述字
flock 文件加/解锁
poll I/O多路转换
truncate 截断文件
ftruncate 参见truncate
umask 设置文件权限掩码
fsync 把文件在内存中的部分写回磁盘
2、文件系统操作
access 确定文件的可存取性
chdir 改变当前工作目录
fchdir 参见chdir
chmod 改变文件方式
fchmod 参见chmod
chown 改变文件的属主或用户组
fchown 参见chown
lchown 参见chown
chroot 改变根目录
stat 取文件状态信息
lstat 参见stat
fstat 参见stat
statfs 取文件系统信息
fstatfs 参见statfs
readdir 读取目录项
getdents 读取目录项
mkdir 创建目录
mknod 创建索引节点
rmdir 删除目录
rename 文件改名
link 创建链接
symlink 创建符号链接
unlink 删除链接
readlink 读符号链接的值
mount 安装文件系统
umount 卸下文件系统
ustat 取文件系统信息
utime 改变文件的访问修改时间
utimes 参见utime
quotactl 控制磁盘配额
三、系统控制
ioctl I/O总控制函数
_sysctl 读/写系统参数
acct 启用或禁止进程记账
getrlimit 获取系统资源上限
setrlimit 设置系统资源上限
getrusage 获取系统资源使用情况
uselib 选择要使用的二进制函数库
ioperm 设置端口I/O权限
iopl 改变进程I/O权限级别
outb 低级端口操作
reboot 重新启动
swapon 打开交换文件和设备
swapoff 关闭交换文件和设备
bdflush 控制bdflush守护进程
sysfs 取核心支持的文件系统类型
sysinfo 取得系统信息
adjtimex 调整系统时钟
alarm 设置进程的闹钟
getitimer 获取计时器值
setitimer 设置计时器值
gettimeofday 取时间和时区
settimeofday 设置时间和时区
stime 设置系统日期和时间
time 取得系统时间
times 取进程运行时间
uname 获取当前UNIX系统的名称、版本和主机等信息
vhangup 挂起当前终端
nfsservctl 对NFS守护进程进行控制
vm86 进入模拟8086模式
create_mole 创建可装载的模块项
delete_mole 删除可装载的模块项
init_mole 初始化模块
query_mole 查询模块信息
*get_kernel_syms 取得核心符号,已被query_mole代替
四、内存管理
brk 改变数据段空间的分配
sbrk 参见brk
mlock 内存页面加锁
munlock 内存页面解锁
mlockall 调用进程所有内存页面加锁
munlockall 调用进程所有内存页面解锁
mmap 映射虚拟内存页
munmap 去除内存页映射
mremap 重新映射虚拟内存地址
msync 将映射内存中的数据写回磁盘
mprotect 设置内存映像保护
getpagesize 获取页面大小
sync 将内存缓冲区数据写回硬盘
cacheflush 将指定缓冲区中的内容写回磁盘
五、网络管理
getdomainname 取域名
setdomainname 设置域名
gethostid 获取主机标识号
sethostid 设置主机标识号
gethostname 获取本主机名称
sethostname 设置主机名称
六、socket控制
socketcall socket系统调用
socket 建立socket
bind 绑定socket到端口
connect 连接远程主机
accept 响应socket连接请求
send 通过socket发送信息
sendto 发送UDP信息
sendmsg 参见send
recv 通过socket接收信息
recvfrom 接收UDP信息
recvmsg 参见recv
listen 监听socket端口
select 对多路同步I/O进行轮询
shutdown 关闭socket上的连接
getsockname 取得本地socket名字
getpeername 获取通信对方的socket名字
getsockopt 取端口设置
setsockopt 设置端口参数
sendfile 在文件或端口间传输数据
socketpair 创建一对已联接的无名socket
七、用户管理
getuid 获取用户标识号
setuid 设置用户标志号
getgid 获取组标识号
setgid 设置组标志号
getegid 获取有效组标识号
setegid 设置有效组标识号
geteuid 获取有效用户标识号
seteuid 设置有效用户标识号
setregid 分别设置真实和有效的的组标识号
setreuid 分别设置真实和有效的用户标识号
getresgid 分别获取真实的,有效的和保存过的组标识号
setresgid 分别设置真实的,有效的和保存过的组标识号
getresuid 分别获取真实的,有效的和保存过的用户标识号
setresuid 分别设置真实的,有效的和保存过的用户标识号
setfsgid 设置文件系统检查时使用的组标识号
setfsuid 设置文件系统检查时使用的用户标识号
getgroups 获取后补组标志清单
setgroups 设置后补组标志清单
八、进程间通信
ipc 进程间通信总控制调用
1、信号
sigaction 设置对指定信号的处理方法
sigprocmask 根据参数对信号集中的信号执行阻塞/解除阻塞等操作
sigpending 为指定的被阻塞信号设置队列
sigsuspend 挂起进程等待特定信号
signal 参见signal
kill 向进程或进程组发信号
*sigblock 向被阻塞信号掩码中添加信号,已被sigprocmask代替
*siggetmask 取得现有阻塞信号掩码,已被sigprocmask代替
*sigsetmask 用给定信号掩码替换现有阻塞信号掩码,已被sigprocmask代替
*sigmask 将给定的信号转化为掩码,已被sigprocmask代替
*sigpause 作用同sigsuspend,已被sigsuspend代替
sigvec 为兼容BSD而设的信号处理函数,作用类似sigaction
ssetmask ANSI C的信号处理函数,作用类似sigaction
2、消息
msgctl 消息控制操作
msgget 获取消息队列
msgsnd 发消息
msgrcv 取消息
3、管道
pipe 创建管道
4、信号量
semctl 信号量控制
semget 获取一组信号量
semop 信号量操作
5、共享内存
shmctl 控制共享内存
shmget 获取共享内存
shmat 连接共享内存
shmdt 拆卸共享内存
H. linux用make语句编译
$ cat makefile
.SUFFEXES:.c .o
.c.o:
gcc -Wall -c $<
OBJS=my_file.o
all: my_exec_file
my_exec_file:$(OBJS)
gcc -Wall $(OBJS) -o $@
$ make
gcc -Wall -c my_file.c
gcc -Wall my_file.o -o my_exec_file
简单说明：
.SUFFEXES:.c .o ：告诉make识别哪些源程序和目标程序
.c.o: ：告诉make命令.c程序如何生成.o文件，采用其下的gcc -Wall -c $<（$<代表任意一个编译时用到的.c文件）命令。
all: my_exec_file ：告诉make命令自动生成哪个可执行程序
my_exec_file:$(OBJS) ：告诉make命令如何生成my_exec_file文件，需要哪些目标代码（$(OBJS)），采用其下的命令： gcc -Wall $(OBJS) -o $@ （$@代表my_exec_file，即要编译的可执行文件名）
I. linux编译程序时出现错误fatal error: sys/utime.h: No such file or directory
缺少头文件utime.h, find utime.h得到真实路径, 然后修改makefile文件，修改指向它的位置。