UNIX标准化及实现之限制

前言

UNIX系统实现定义了很多幻数和常量,其中有很多已被硬编码(关于硬编码和软编码:http://www.cnblogs.com/chenkai/archive/2009/04/10/1432903.html)进程序中,或用特定的技术确定。由于大量标准化工作的努力,已有若干种可移植的方法用以确定这些幻数和实现定义的限制。这非常有助于软件的可移植性。

以下两种类型的限制是必需的:

(1)编译时限制(例如,短整型的最大值是什么?)。

(2)运行时限制(例如,文件名可以有多少个字符?)。

编译时限制可在头文件中定义,程序在编译时可以包含这些头文件。但是,运行时限制则要求进程调用一个函数以获得此种限制值。

另外,某些限制在一个给定的实现中可能是固定的(因此可以静态地在一个头文件中定义),而在另一个实现上则可能是变化的(需要一个运行时函数调用)。

为了解决这类问题,提供了以下三种限制:

(1)编译时限制(头文件)。

(2)不与文件或目录相关联的运行时限制(sysconf函数)。

(3)与文件或目录相关联的运行时限制(pathconf和fpathconf函数)。

使事情变得更复杂的是,如果一个特定的运行时限制在一个给定的系统上并不改变,则可将其静态地定义在一个头文件中。但是,如果没有将其定义在头文件中,则应用程序就必须调用三个conf函数中的一个,以确定其运行时的值。

一、ISO C 限制

ISO C定义的限制都是编译时限制。文件<limits.h>中定义的C标准限制如下:

表1 <limits.h>中定义的整型值大小

名字 说明 最小可接受值(用于16位整型系统) 典型值(32位Linux系统)
CHAR_BIT
CHAR_MAX
CHAR_MIN
SCHAR_MAX
SCHAR_MIN
UCHAR_MAX
字符的位数
字符的最大值
字符的最小值
带符号字符的最大值
带符号字符的最小值
不带符号字符的最大值

8
127
-128
127
-127
255

8
127
-128
127
-128
255

INT_MAX
INT_MIN
UINT_MAX
整型的最大值
整型的最小值
不带符号整型的最大值

32 767
-32 767
65535

2 147 483 647
-2 147 483 648
4 294 967 295

SHRT_MIN
SHRT_MAX
USHRT_MAX
短整型的最小值
短整型的最大值
不带符号短整型的最大值

-32767
32767
65535

-32768
32767
65535

LONG_MAX
LONG_MIN
ULONG_MAX
长整型的最大值
长整型的最小值
不带符号长整型的最大值

2 147 483 647
-2 147 483 647
4 294 967 295

2 147 483 647
-2 147 483 648
4 294 967 295

LLONG_MAX
LLONG_MIN
ULLONG_MAX
长长整型的最大值
长长整型的最小值
不带符号长长整型的最大值

9 223 372 036 854 775 807
-9 223 372 036 854 775 807
18 446 744 073 709 551 615

9 223 372 036 854 775 807
-9 223 372 036 854 775 808
18 446 744 073 709 551 615

MB_LEN_MAX 多字节字符常量中的最大字节数

1

16

这些常量总是定义在头文件中,而且在一个给定系统中不会改变。注意,对不带符号的数据类型都没有列出其最小值,它们都应为0。在64位系统中,其long整型的最大值与表中long long整型最大值相匹配。

我们将会遇到的一个不同之处是系统是否提供带符号或不带符号的字符集。从上表中,我们可以看到CHAR_MIN等于SCHAR_MIN,CHAR_MAX等于SCHAR_MAX;如果系统使用不带符号的字符集,则CHAR_MIN等于0,CHAR_MAX等于UCHAR_MAX。

我们会遇到的另一个ISO C常量是FOPEN_MAX,这是具体实现保证可同时打开的标准I/O流的最小数。该值在头文件<stdio.h>中定义,其值最小是8。POSIX.1中的STREAM_MAX(若定义的话)必需有与FOPEN_MAX相同的值。

ISO C在<stdio.h>中还定义了常量TMP_MAX,这是由tmpnam函数产生的唯一文件名的最大数。

表2 在各种平台上的ISO限制

限制 FreeBSD5.2.1 Linux 2.4.22 Mac OS X 10.3 Solaris 9
FOPEN_MAX
TMP_MAX

20
308 915 776

16
238 328

20
308 915 776

20
17 576

ISO C还定义了常量FILENAME_MAX,因为某些操作系统实现在历史上将它定义得太小,以至于不能满足应用的需求,所以我们应避免使用该常量。

二、POSIX限制

POSIX.1定义了很多涉及操作系统实现限制的常量,我们只关心与基本POSIX.1接口有关的部分。这些限制和常量被分成下列5类。

(1)不变的最小值:见表3。

(2)不变值:SSIZE_MAX。

(3)运行时可以增加的值:CHARCLASS_NAME_MAX、COLL_WEIGHTS_MAX、LINE_MAX、NGROUPS_MAX以及RE_DUP_MAX。

(4)运行时不变的值(可能不确定):ARG_MAX、CHILD_MAX、HOST_NAME_MAX、LOGIN_NAME_MAX、OPEN_MAX、PAGESIZE、RE_DUP_MAX、STREAM_MAXS、SYMLOOP_MAX、TTY_NAME_MAX以及TZNAME_MAX。

(5)路径名可变值(可能不确定):FILESIZEBITS、LINK_MAX、MAX_CANON、MAX_INPUT、NAME_MAX、PATH_MAX、PIPE_BUF以及SYMLINK_MAX。

表3 <limits.h>中的POSIX.1不变最小值

名字

说明:以下各项的最小可接受值

_POSIX_ARG_MAX exec函数的参数长度

4096

_POSIX_CHILD_MAX 每个实际用户ID的子进程数

25

_POSIX_HOST_NAME_MAX gethostname函数返回的主机名最大长度

255

_POSIX_LINK_MAX 指向一个文件的链接数

8

_POSIX_LOGIN_NAME_MAX 登录名的最大长度

9

_POSIX_MAX_CANON 终端规范输入队列的字节数

255

_POSIX_MAX_INPUT 终端输入队列的可用空间

255

_POSIX_NAME_MAX 文件名中的字节数,不包括终止字符null

14

_POSIX_NGROUPS_MAX 每个进程同时对添加组ID数

8

_POSIX_OPEN_MAX 每个进程的打开文件数

20

_POSIX_PATH_MAX 路径名中的字节数,包括终止字符null

256

_POSIX_PIPE_BUF 能原子地写到管道的字节数

512

_POSIX_RE_DUP_MAX 当使用间隔表示法\{m,n\}时,regexec和regcomp函数允许的基本正则表达式的重复出现次数

255

_POSIX_SSIZE_MAX 能存储在ssize_t对象中的值

32767

_POSIX_STREAM_MAX 一个进程能同时打开的标准I/O流数

8

_POSIX_SYMLINK_MAX 符号链接中的字节数

255

_POSIX_SYMLOOP_MAX 在解析路径名时可遍历的符号链接数

8

_POSIX_TTY_NAME_MAX 终端设备名长度,包括终止字符null

9

_POSIX_TZNAME_MAX 时区名字节数

6

上述5类共44个限制和常量中,有一些可定义在<limits.h>中,其余的则按照具体条件可定义或不定义。

表3中列出了19个不变最小值,这些值是不变的——它们并不随系统而改变。它们指定了这些特征最具约束性的值。一个符合POSIX.1的实现应当提供至少这样大的值。这就是为什么将它们称为最小值的原因,虽然它们的名字都包含了MAX。另外,为了保证可移植性,一个严格遵循POSIX的应用程序不应要求更大的值。

一个严格遵循(strictly conforming)POSIX的应用程序有别于仅遵循POSIX(merely POSIX Confirming)的应用程序。一个遵循POSIX的应用程序只使用在IEEE标准1003.1-2001中定义的接口。一个严格遵循POSIX的应用程序也是遵循POSIX的,但除此之外,它还应不依赖于POSIX未定义的行为,不使用任何已废弃的接口,以及不要求所使用的常量值大于上表中所列出的最小值。

不幸的是,这些不变最小值中的某一些在实际应用中太小了。例如,目前在大多数UNIX系统中,每个进程可同时打开的文件数远远超过20。另外,_POSIX_PATH_MAX的最小限制值为255,这也太小了,路径名可能会超过这一限制。这意味着在编译时不能使用_POSIX_OPEN_MAX和_POSIX_PATH_MAX这两个常量作为数组长度。

表3中的每一个不变最小值都有一个相关的实现值,其名字是将表中的名字删除前缀_POSIX_后构成的。不带有前导_POSIX_的名称打算作为给定实现支持的实际值(这19个实现值是上面5类中(2)-(5):不变值、运行时可增加的值、运行时不变的值以及路径名可变值)。问题是并不能确保所有这19个实现值都在<limits.h>头文件中定义。

例如,某个特定值可能不在此头文件中定义,其理由是:一个给定进程的实际值可能依赖于系统的存储总量。如果没有在头文件中定义这些值,则不能在编译时使用它们作为数组边界。所以POSIX提供了三个运行时函数以供调用,它们是:sysconf、pathconf以及fpathconf。使用这三个函数可以在运行时得到实际的实现值。但是,还有一个问题,其中某些值由POSIX.1定义为“可能不确定的”(逻辑上无限的),这就意味着该值没有实际上限。例如在Linux中,readv或writev可用的iovec结构数仅受系统存储总量的限制。所以,在Linux系统中,IOV_MAX被认为是不确定的。

三、XSI限制

XSI还定义了处理实现限制的下面几个常量:

(1)不变最小值:表4中列出的10个常量。

(2)数值限制:LONG_BIT和WORE_BIT。

(3)运行时不变值(可能不确定):ATEXIT_MAX、IOV_MAX以及PAGE_SIZE。

表4 <limits.h>中的XSI不变最小值

名字 说明 最小可接受值 典型值
NL_ARGMAX printf和scanf调用中的最大数字值 9 9
NL_LANGMAX LANG环境变量中的最大字节数 14 14
NL_MSGMAX 最大消息数 32767 32767
NL_NMAX N对1映射字符中的最大字节数 未指定 1
NL_SETMAX 最大集合数 255 255
NL_TEXTMAX 消息字符串中的最大字符数 _POSIX2_LINE_MAX 2048
NZERO 默认的进程优先级 20 20
_XOPEN_IOV_MAX readv或writev可使用的最大iovec结构数 16 16
_XOPEN_NAME_MAX 文件名中的字节数 255 255
_XOPEN_PATH_MAX 路径名中的字节数 1024 1024

四、sysconf、pathconf和fpathconf函数

我们已列出了实现必须支持的各种最小值,但是怎样才能找到一个特定系统实际支持的限制值呢?正如前面提到的,某些限制值在编译时是可用的,而另外一些则必须在运行时确定。我们也曾提及在一个给定的系统中某些限制值是不会更改的,而其他限制值则与文件和目录相关联,是可以改变的。运行时限制可通过调用下面三个函数中的一个而取得:

#include <unistd.h>
      long sysconf( int name );
      long pathconf( const char *pathname, int name );
      long fpathconf( int filedes, int name );

所有函数返回值:若成功则返回相应值;若出错则返回-1。(此处说的有点太过笼统,可参考下面的英文解释了解详情)

SYNOPSIS
       #include <unistd.h>

long sysconf(int name);

DESCRIPTION
       POSIX  allows  an application to test at compile- or run-time whether cer-
       tain options are supported, or what the value is of  certain  configurable
       constants or limits.

RETURN VALUE
       If  name  is  invalid, -1 is returned, and errno is set to EINVAL.  Other-
       wise, the value returned is the value of the system resource and errno  is
       not  changed
In  the case of options, a positive value is returned if a
       queried option is available, and -1 if it is not. 
In the case of  limits,
       -1 means that there is no definite limit.

SYNOPSIS
       #include <unistd.h>

long fpathconf(int filedes, int name);
       long pathconf(char *path, int name);

DESCRIPTION
       fpathconf()  gets  a  value for the configuration option name for the open
       file descriptor filedes.

pathconf() gets a value for configuration option  name  for  the  filename
       path.

RETURN VALUE
       The limit is returned, if one exists.  If the system does not have a limit
       for  the  requested  resource, -1 is returned, and errno is unchanged.
  If
       there is an error, -1 is returned, and errno is set to reflect the  nature
       of the error.

后两个函数之间的差别是一个用路径名作为其参数,另一个则取文件描述符作为参数。

表5 sysconf的限制及name参数(用于标识系统限制,以_SC_开始的常量用作标识运行时限制的sysconf参数)

限制名 说明 name参数
ARG_MAX exec函数的参数最大长度(字节数) _SC_ARG_MAX
ATEXIT_MAX 可用atexit函数登记的最大函数个数 _SC_ATEXIT_MAX
CHILD_MAX 每个实际用户ID的最大进程数 _SC_CHILD_MAX
clock ticks/second 每秒时钟滴答数 _SC_CLK_TCK
COLL_WEIGHTS_MAX 在本地定义文件中可以赋予LC_COLLATE顺序关键字项的最大权重数 _SC_COLL_WEIGHTS_MAX
HOST_NAME_MAX gethostname函数返回的主机名最大长度 _SC_HOST_NAME_MAX
IOV_MAX readv或writev函数可以使用的iovec结构的最大数 _SC_IOV_MAX
LINE_MAX 实用程序输入行的最大长度 _SC_LINE_MAX
LOGIN_NAME_MAX 登录名的最大长度 _SC_LOGIN_NAME_MAX
NGROUPS_MAX 每个进程同时添加的最大进程组ID数 _SC_NGROUPS_MAX
OPEN_MAX 每个进程的最大打开文件数 _SC_OPEN_MAX
PAGESIZE 系统存储页长度(字节数) _SC_PAGESIZE
PAGE_SIZE 系统存储页长度(字节数) _SC_PAGE_SIZE
RE_DUP_MAX 当使用间隔表示法\{m,n\}时,regexec和regcomp函数允许的基本正则表达式的重复出现次数 _SC_RE_DUP_MAX
STREAM_MAX 在任一时刻每个进程的最大标准I/O流数,如若定义,则其值一定与FOPEN_MAX相同 _SC_STREAM_MAX
SYMLOOP_MAX 在解析路名期间,可遍历的符号链接数 _SC_SYMLOOP_MAX
TTY_NAME_MAX 终端设备名长度,包括终止字符null _SC_TTY_NAME_MAX
TZNAME_MAX 时区名的最大字节数 _SC_TZNAME_MAX

 

表6 pathconf和fpathconf的限制及name参数(以_PC_开始的常量用作标识运行时限制的pathconf或fpathconf参数)

限制名 说明 name参数
FILESIZEBITS 以带符号整型值表示在指定目录中允许的普通文件最大长度所需的最少位数 _PC_FILESIZEBITS
LINK_MAX 文件链接数的最大值 _PC_LINK_MAX
MAX_CANON 终端规范输入队列的最大字节数 _PC_MAX_CANON
MAX_INPUT 终端输入队列可用空间的字节数 _PC_MAX_INPUT
NAME_MAX 文件名的最大字节数(不包括终止字符null) _PC_NAME_MAX
PATH_MAX 相对路径名的最大字节数,包括终止字符null _PC_PATH_MAX
PIPE_BUF 能原子地写到管道的最大字节数 _PC_PIPE_BUF
SYMLINK_MAX 符号链接中的字节数 _PC_SYMLINK_MAX

 

我们需要更详细地说明这三个函数的不同返回值:

(1)如果name不是表5和表6的第3列中的一个合适的常量,则所有这三个函数都会返回-1,并将errno设置为EINVAL。

(2)有些name可以返回变量的值(返回值>=0),或者返回-1,这表示该值是不确定的,此时并不改变errno的值。

(3)_SC_CLK_TCK的返回值是每秒钟的时钟滴答数,以用于times函数的返回值。

对于pathconf的参数pathname以及fpathconf的参数filedes有一些限制。如果不满足其中任何一个限制,则结果是未定义的:

(1)_PC_MAX_CANON和_PC_MAX_INPUT所引用的文件必须是终端文件

(2)_PC_LINK_MAX所引用的文件可以是文件或目录。如果是目录,则返回值用于目录本身(而不是用于目录内的文件名项)。

(3)_PC_FILESIZEBITS和_PC_NAME_MAX所引用的文件必须是目录,返回值用于该目录中的文件名。

(4)_PC_PATH_MAX引用的文件必须是目录。当所指定的目录是工作目录时,返回值是相对路径名的最大长度(不幸的是,这不是我们想要知道的一个绝对路径名的实际最大长度)。

(5)_PC_PIPE_BUF所引用的文件必须是管道、FIFO或目录。在管道或FIFO情况下,返回值是对所引用的管道或FIFO的限制值。对于目录,返回值是对在该目录中创建的任一FIFO的限制值。

(6)_PC_SYMLINK_MAX所引用的文件必须是目录。返回值是该目录中符号链接可能包含的字符串的最大长度。

程序清单2-1 构建C程序以打印所有得到支持的系统配置限制(竟然可以使用awk编写C程序,就这个实例来说,使用awk构建C程序比直接编写要简单高效多了)

[root@localhost apue]# cat prog2-1.awk 
BEGIN{
        printf("#include \"apue.h\"\n")
        printf("#include <errno.h>\n")
        printf("#include <limits.h>\n")
        printf("\n")
        printf("static void pr_sysconf(char *, int);\n")
        printf("static void pr_pathconf(char *, char *, int);\n")
        printf("\n")
        printf("int\n")
        printf("main(int argc, char *argv[])\n")
        printf("{\n")
        printf("\tif(argc != 2)\n")
        printf("\t\terr_quit(\"usage: a.out <dirname>\");\n\n")
        FS="\t+"
        while(getline <"sysconf.sym" > 0)
        {
                printf("#ifdef %s\n", $1)
                printf("\tprintf(\"%s defined to be %%d\\n\", %s+0);\n", $1, $1)
                printf("#else\n")
                printf("\tprintf(\"no symbol for %s\\n\");\n", $1)
                printf("#endif\n")
                printf("#ifdef %s\n", $2)
                printf("\tpr_sysconf(\"%s =\", %s);\n", $1, $2)
                printf("#else\n")
                printf("\tprintf(\"no symbol for %s\\n\");\n", $2)
                printf("#endif\n")
        }
        close("sysconf.sym")

        while(getline <"pathconf.sym" > 0)
        {
                printf("#ifdef %s\n", $1)
                printf("\tprintf(\"%s defined to be %%d\\n\", %s+0);\n", $1, $1)
                printf("#else\n")
                printf("\tprintf(\"no symbol for %s\\n\");\n", $1)
                printf("#endif\n")
                printf("#ifdef %s\n", $2)
                printf("\tpr_pathconf(\"%s =\", argv[1], %s);\n", $1, $2)
                printf("#else\n")
                printf("\tprintf(\"no symbol for %s\\n\");\n", $2)
                printf("#endif\n")
        }
        close("pathconf.sym")
        exit
}
END{
        printf("\texit(0);\n")
        printf("}\n\n")
        printf("static void\n")
        printf("pr_sysconf(char *mesg, int name)\n")
        printf("{\n")
        printf("\tlong  val;\n\n")
        printf("\tfputs(mesg, stdout);\n")
        printf("\terrno = 0;\n")
        printf("\tif((val = sysconf(name)) < 0) {\n")
        printf("\t\tif(errno != 0) {\n")
        printf("\t\t\tif(errno == EINVAL)\n")
        printf("\t\t\t\tfputs(\" (not supported)\\n\", stdout);\n")
        printf("\t\t\telse\n")
        printf("\t\t\t\terr_sys(\"sysconf error\");\n")
        printf("\t\t} else {\n")
        printf("\t\t\tfputs(\"(no limit)\\n\", stdout);\n")
        printf("\t\t}\n")
        printf("\t}else {\n")
        printf("\t\tprintf(\" %%ld\\n\", val);\n")
        printf("\t}\n")
        printf("}\n\n")
        printf("static void\n")
        printf("pr_pathconf(char *mesg, char *path, int name)\n")
        printf("{\n")
        printf("\tlong val;\n")
        printf("\n")
        printf("\tfputs(mesg, stdout);\n")
        printf("\terrno = 0;\n")
        printf("\tif((val = pathconf(path, name)) < 0) {\n")
        printf("\t\tif(errno != 0){\n")
        printf("\t\t\tif(errno == EINVAL)\n")
        printf("\t\t\t\tfputs(\" (not supported)\\n\", stdout);\n")
        printf("\t\t\telse\n")
        printf("\t\t\t\terr_sys(\"pathconf error, path = %%s\", path);\n")
        printf("\t\t} else {\n")
        printf("\t\t\tfputs(\" (no limits)\\n\", stdout);\n")
        printf("\t\t}\n")
        printf("\t} else {\n")
        printf("\t\tprintf(\" %%ld\\n\", val);\n")
        printf("\t}\n")
        printf("}\n")
}

该awk程序读取两个输入文件——pathconf.sym和sysconf.sym(可从www.apuebook.com获取),这两个文件中包含了用制表符分隔的限制名和符号列表。并非每种平台都会定义所有符号,所以围绕每个pathconf和sysconf调用,awk程序都使用了必要的#ifdef语句。

例如,awk程序将输入文件中类似于下列形式的行:

NAME_MAX    _PC_NAME_MAX

转换成下列C代码:

#ifdef NAME_MAX
        printf("NAME_MAX defined to be %d\n", NAME_MAX+0);
#else
        printf("no symbol for NAME_MAX\n");
#endif
#ifdef _PC_NAME_MAX
        pr_pathconf("NAME_MAX =", argv[1], _PC_NAME_MAX);
#else
        printf("no symbol for _PC_NAME_MAX\n");
#endif

要使用程序清单2-1生成C程序代码程序清单2-2,只要在命令终端运行命令:

[root@localhost apue]# awk -f prog2-1.awk sysconf.sym pathconf.sym >prog2-2.c

即可产生如下的prog2-2.c

程序清单2-2 打印所有可能的sysconf和pathconf值

[root@localhost apue]# cat prog2-2.c 
#include "apue.h"
#include <errno.h>
#include <limits.h>

static void pr_sysconf(char *, int);
static void pr_pathconf(char *, char *, int);

int
main(int argc, char *argv[])
{
        if(argc != 2)
                err_quit("usage: a.out <dirname>");

#ifdef ARG_MAX
        printf("ARG_MAX defined to be %d\n", ARG_MAX+0);
#else
        printf("no symbol for ARG_MAX\n");
#endif
#ifdef _SC_ARG_MAX
        pr_sysconf("ARG_MAX =", _SC_ARG_MAX);
#else
        printf("no symbol for _SC_ARG_MAX\n");
#endif
#ifdef ATEXIT_MAX
        printf("ATEXIT_MAX defined to be %d\n", ATEXIT_MAX+0);
#else
        printf("no symbol for ATEXIT_MAX\n");
#endif
#ifdef _SC_ATEXIT_MAX
        pr_sysconf("ATEXIT_MAX =", _SC_ATEXIT_MAX);
#else
        printf("no symbol for _SC_ATEXIT_MAX\n");
#endif
#ifdef CHARCLASS_NAME_MAX
        printf("CHARCLASS_NAME_MAX defined to be %d\n", CHARCLASS_NAME_MAX+0);
#else
        printf("no symbol for CHARCLASS_NAME_MAX\n");
#endif
#ifdef _SC_CHARCLASS_NAME_MAX
        pr_sysconf("CHARCLASS_NAME_MAX =", _SC_CHARCLASS_NAME_MAX);
#else
        printf("no symbol for _SC_CHARCLASS_NAME_MAX\n");
#endif
#ifdef CHILD_MAX
        printf("CHILD_MAX defined to be %d\n", CHILD_MAX+0);
#else
        printf("no symbol for CHILD_MAX\n");
#endif
#ifdef _SC_CHILD_MAX
        pr_sysconf("CHILD_MAX =", _SC_CHILD_MAX);
#else
        printf("no symbol for _SC_CHILD_MAX\n");
#endif
#ifdef CLOCKTICKSPERSECOND /*clock ticks/second*/
        printf("CLOCKTICKSPERSECOND /*clock ticks/second*/ defined to be %d\n", CLOCKTICKSPERSECOND /*clock ticks/second*/+0);
#else
        printf("no symbol for CLOCKTICKSPERSECOND /*clock ticks/second*/\n");
#endif
#ifdef _SC_CLK_TCK
        pr_sysconf("CLOCKTICKSPERSECOND /*clock ticks/second*/ =", _SC_CLK_TCK);
#else
        printf("no symbol for _SC_CLK_TCK\n");
#endif
#ifdef COLL_WEIGHTS_MAX
        printf("COLL_WEIGHTS_MAX defined to be %d\n", COLL_WEIGHTS_MAX+0);
#else
        printf("no symbol for COLL_WEIGHTS_MAX\n");
#endif
#ifdef _SC_COLL_WEIGHTS_MAX
        pr_sysconf("COLL_WEIGHTS_MAX =", _SC_COLL_WEIGHTS_MAX);
#else
        printf("no symbol for _SC_COLL_WEIGHTS_MAX\n");
#endif
#ifdef HOST_NAME_MAX
        printf("HOST_NAME_MAX defined to be %d\n", HOST_NAME_MAX+0);
#else
        printf("no symbol for HOST_NAME_MAX\n");
#endif
#ifdef _SC_HOST_NAME_MAX
        pr_sysconf("HOST_NAME_MAX =", _SC_HOST_NAME_MAX);
#else
        printf("no symbol for _SC_HOST_NAME_MAX\n");
#endif
#ifdef IOV_MAX
        printf("IOV_MAX defined to be %d\n", IOV_MAX+0);
#else
        printf("no symbol for IOV_MAX\n");
#endif
#ifdef _SC_IOV_MAX
        pr_sysconf("IOV_MAX =", _SC_IOV_MAX);
#else
        printf("no symbol for _SC_IOV_MAX\n");
#endif
#ifdef LINE_MAX
        printf("LINE_MAX defined to be %d\n", LINE_MAX+0);
#else
        printf("no symbol for LINE_MAX\n");
#endif
#ifdef _SC_LINE_MAX
        pr_sysconf("LINE_MAX =", _SC_LINE_MAX);
#else
        printf("no symbol for _SC_LINE_MAX\n");
#endif
#ifdef LOGIN_NAME_MAX
        printf("LOGIN_NAME_MAX defined to be %d\n", LOGIN_NAME_MAX+0);
#else
        printf("no symbol for LOGIN_NAME_MAX\n");
#endif
#ifdef _SC_LOGIN_NAME_MAX
        pr_sysconf("LOGIN_NAME_MAX =", _SC_LOGIN_NAME_MAX);
#else
        printf("no symbol for _SC_LOGIN_NAME_MAX\n");
#endif
#ifdef NGROUPS_MAX
        printf("NGROUPS_MAX defined to be %d\n", NGROUPS_MAX+0);
#else
        printf("no symbol for NGROUPS_MAX\n");
#endif
#ifdef _SC_NGROUPS_MAX
        pr_sysconf("NGROUPS_MAX =", _SC_NGROUPS_MAX);
#else
        printf("no symbol for _SC_NGROUPS_MAX\n");
#endif
#ifdef OPEN_MAX
        printf("OPEN_MAX defined to be %d\n", OPEN_MAX+0);
#else
        printf("no symbol for OPEN_MAX\n");
#endif
#ifdef _SC_OPEN_MAX
        pr_sysconf("OPEN_MAX =", _SC_OPEN_MAX);
#else
        printf("no symbol for _SC_OPEN_MAX\n");
#endif
#ifdef PAGESIZE
        printf("PAGESIZE defined to be %d\n", PAGESIZE+0);
#else
        printf("no symbol for PAGESIZE\n");
#endif
#ifdef _SC_PAGESIZE
        pr_sysconf("PAGESIZE =", _SC_PAGESIZE);
#else
        printf("no symbol for _SC_PAGESIZE\n");
#endif
#ifdef PAGE_SIZE
        printf("PAGE_SIZE defined to be %d\n", PAGE_SIZE+0);
#else
        printf("no symbol for PAGE_SIZE\n");
#endif
#ifdef _SC_PAGE_SIZE
        pr_sysconf("PAGE_SIZE =", _SC_PAGE_SIZE);
#else
        printf("no symbol for _SC_PAGE_SIZE\n");
#endif
#ifdef RE_DUP_MAX
        printf("RE_DUP_MAX defined to be %d\n", RE_DUP_MAX+0);
#else
        printf("no symbol for RE_DUP_MAX\n");
#endif
#ifdef _SC_RE_DUP_MAX
        pr_sysconf("RE_DUP_MAX =", _SC_RE_DUP_MAX);
#else
        printf("no symbol for _SC_RE_DUP_MAX\n");
#endif
#ifdef STREAM_MAX
        printf("STREAM_MAX defined to be %d\n", STREAM_MAX+0);
#else
        printf("no symbol for STREAM_MAX\n");
#endif
#ifdef _SC_STREAM_MAX
        pr_sysconf("STREAM_MAX =", _SC_STREAM_MAX);
#else
        printf("no symbol for _SC_STREAM_MAX\n");
#endif
#ifdef SYMLOOP_MAX
        printf("SYMLOOP_MAX defined to be %d\n", SYMLOOP_MAX+0);
#else
        printf("no symbol for SYMLOOP_MAX\n");
#endif
#ifdef _SC_SYMLOOP_MAX
        pr_sysconf("SYMLOOP_MAX =", _SC_SYMLOOP_MAX);
#else
        printf("no symbol for _SC_SYMLOOP_MAX\n");
#endif
#ifdef TTY_NAME_MAX
        printf("TTY_NAME_MAX defined to be %d\n", TTY_NAME_MAX+0);
#else
        printf("no symbol for TTY_NAME_MAX\n");
#endif
#ifdef _SC_TTY_NAME_MAX
        pr_sysconf("TTY_NAME_MAX =", _SC_TTY_NAME_MAX);
#else
        printf("no symbol for _SC_TTY_NAME_MAX\n");
#endif
#ifdef TZNAME_MAX
        printf("TZNAME_MAX defined to be %d\n", TZNAME_MAX+0);
#else
        printf("no symbol for TZNAME_MAX\n");
#endif
#ifdef _SC_TZNAME_MAX
        pr_sysconf("TZNAME_MAX =", _SC_TZNAME_MAX);
#else
        printf("no symbol for _SC_TZNAME_MAX\n");
#endif
#ifdef MAX_CANON
        printf("MAX_CANON defined to be %d\n", MAX_CANON+0);
#else
        printf("no symbol for MAX_CANON\n");
#endif
#ifdef _PC_MAX_CANON
        pr_pathconf("MAX_CANON =", argv[1], _PC_MAX_CANON);
#else
        printf("no symbol for _PC_MAX_CANON\n");
#endif
#ifdef MAX_INPUT
        printf("MAX_INPUT defined to be %d\n", MAX_INPUT+0);
#else
        printf("no symbol for MAX_INPUT\n");
#endif
#ifdef _PC_MAX_INPUT
        pr_pathconf("MAX_INPUT =", argv[1], _PC_MAX_INPUT);
#else
        printf("no symbol for _PC_MAX_INPUT\n");
#endif
#ifdef FILESIZEBITS
        printf("FILESIZEBITS defined to be %d\n", FILESIZEBITS+0);
#else
        printf("no symbol for FILESIZEBITS\n");
#endif
#ifdef _PC_FILESIZEBITS
        pr_pathconf("FILESIZEBITS =", argv[1], _PC_FILESIZEBITS);
#else
        printf("no symbol for _PC_FILESIZEBITS\n");
#endif
#ifdef LINK_MAX
        printf("LINK_MAX defined to be %d\n", LINK_MAX+0);
#else
        printf("no symbol for LINK_MAX\n");
#endif
#ifdef _PC_LINK_MAX
        pr_pathconf("LINK_MAX =", argv[1], _PC_LINK_MAX);
#else
        printf("no symbol for _PC_LINK_MAX\n");
#endif
#ifdef NAME_MAX
        printf("NAME_MAX defined to be %d\n", NAME_MAX+0);
#else
        printf("no symbol for NAME_MAX\n");
#endif
#ifdef _PC_NAME_MAX
        pr_pathconf("NAME_MAX =", argv[1], _PC_NAME_MAX);
#else
        printf("no symbol for _PC_NAME_MAX\n");
#endif
#ifdef PATH_MAX
        printf("PATH_MAX defined to be %d\n", PATH_MAX+0);
#else
        printf("no symbol for PATH_MAX\n");
#endif
#ifdef _PC_PATH_MAX
        pr_pathconf("PATH_MAX =", argv[1], _PC_PATH_MAX);
#else
        printf("no symbol for _PC_PATH_MAX\n");
#endif
#ifdef PIPE_BUF
        printf("PIPE_BUF defined to be %d\n", PIPE_BUF+0);
#else
        printf("no symbol for PIPE_BUF\n");
#endif
#ifdef _PC_PIPE_BUF
        pr_pathconf("PIPE_BUF =", argv[1], _PC_PIPE_BUF);
#else
        printf("no symbol for _PC_PIPE_BUF\n");
#endif
#ifdef SYMLINK_MAX
        printf("SYMLINK_MAX defined to be %d\n", SYMLINK_MAX+0);
#else
        printf("no symbol for SYMLINK_MAX\n");
#endif
#ifdef _PC_SYMLINK_MAX
        pr_pathconf("SYMLINK_MAX =", argv[1], _PC_SYMLINK_MAX);
#else
        printf("no symbol for _PC_SYMLINK_MAX\n");
#endif
        exit(0);
}

static void
pr_sysconf(char *mesg, int name)
{
        long  val;

        fputs(mesg, stdout);
        errno = 0;
        if((val = sysconf(name)) < 0) {
                if(errno != 0) {
                        if(errno == EINVAL)
                                fputs(" (not supported)\n", stdout);
                        else
                                err_sys("sysconf error");
                } else {
                        fputs("(no limit)\n", stdout);
                }
        }else {
                printf(" %ld\n", val);
        }
}

static void
pr_pathconf(char *mesg, char *path, int name)
{
        long val;

        fputs(mesg, stdout);
        errno = 0;
        if((val = pathconf(path, name)) < 0) {
                if(errno != 0){
                        if(errno == EINVAL)
                                fputs(" (not supported)\n", stdout);
                        else
                                err_sys("pathconf error, path = %s", path);
                } else {
                        fputs(" (no limits)\n", stdout);
                }
        } else {
                printf(" %ld\n", val);
        }
 }

五、不确定的运行时限制

前面已经提及某些限制值可能是不确定的。我们遇到的问题是,如果这些限制值没有在头文件<limits.h>中定义,那么在编译时也就不能使用它们。但是,如果它们的值是不确定的,那么在运行时它们可能也是未定义的!让我们来观察两种特殊的情况:为一个路径名分配存储区,以及确定文件描述符的数目。

1、路径名

很多程序需要为路径名分配存储区。一般来说,在编译时就为其分配了存储区,而且不同的程序使用各种不同的幻数(其中很少是正确的)作为数组长度。例如,256、512、1024或标准I/O常量BUFSIZ。4.3BSD头文件<sys/param.h>中的常量MAXPATHLEN是正确的,但是很多4.3BSD应用程序并未使用它。

POSIX.1试图使用PATH_MAX值来帮助我们,但是如果此值是不确定的,那么仍是毫无帮助的。

如若在<limits.h>中定义了常量PATH_MAX,那么就没有任何问题;如果没有定义,则需调用pathconf。因为pathconf的返回值是基于工作目录的相对路径名的最大长度,而工作目录是其第一个参数,所以,指定根目录为第一个参数,并将得到的返回值加1作为结果值。如果pathconf指明PATH_MAX是不确定的,那么我们就只能猜测某个值。

对于PATH_MAX是否在路径名末尾包括一个null字符这一点,SUS v3之前的标准表述得不清楚。出于安全方面的考虑,如果操作系统实现遵循先前的标准版本,则需要在为路径名分配的存储数量上加1。

处理不确定结果这种情况的正确方法与如何使用所分配的存储空间有关。例如,如果我们为getcwd调用分配空间(返回当前工作目录的绝对路径名),并且分配的空间太小,则返回一个出错,并将errno设置为ERANGE。然后可调用realloc来增加分配的空间并重试。不断重复此操作,直到getcwd调用成功执行。

程序清单2-3 为路径名动态地分配空间

[root@localhost apue]# cat prog2-3.c 
#include "apue.h"
#include <errno.h>
#include <limits.h>

#ifdef PATH_MAX
static int pathmax = PATH_MAX;
#else
static int pathmax = 0;
#endif

#define SUSV3 200112L

static long posix_version = 0;

/* If PATH_MAX is indeterminate, no guarantee  this is adequate */
#define PATH_MAX_GUESS 1024

char *
path_alloc(int *sizep) /* also return allocated size, if nonull */
{
        char *ptr;
        int size;

        if(posix_version == 0)
                posix_version = sysconf(_SC_VERSION);

        if(pathmax == 0) {   /* first time trough */
                errno = 0;
                if((pathmax = pathconf("/", _PC_PATH_MAX)) < 0) {
                        if(errno == 0)
                                pathmax = PATH_MAX_GUESS;  /* it's indeterminate */
                        else
                                err_sys("pathconf error for _PC_PATH_MAX");
                } else {
                        pathmax++;    /* add one since it's relative to root */
                }
        }
        if(posix_version < SUSV3)
                size = pathmax + 1;
        else
                size = pathmax;

        if((ptr = malloc(size)) == NULL)
                err_sys("malloc error for pathname");

        if(sizep != NULL)
                *sizep = size;
        return(ptr);
}

2、最大打开文件数

守护进程(daemon process,是指在后台运行且不与终端相连接的一种进程,也常被称为精灵进程或后台进程)中一个常见的代码序列是关闭所有打开的文件。某些程序中有下列形式的代码序列:

#include <sys/param.h>

for( i=0; i<NOFILE; i++ )
    close( i );

这段程序假定在<sys/param.h>头文件中定义了常量NOFILE。另外一些程序则使用某些<stdio.h>版本提供作为上限的常量_NFILE。某些程序则将其上限值硬编码为20.

我们希望用POSIX.1的OPEN_MAX来确定此值以提高可移植性,但是,如果此值是不确定的,则仍然有问题。如果我们编写了下列代码:

#include <unistd.h>

for( i=0; i<sysconf( _SC_OPEN_MAX ); i++ )
    close( i );

而且如果OPEN_MAX是不确定的,那么for循环根本不会执行因为sysconf将返回-1。在这种情况下,最好的选择就是关闭所有描述符直至某个限制值(例如256)。如同上面的路径名实例一样,这样并不能保证在所有情况下都能正常工作,但这却是我们所能选择的最好方法。程序清单2-4中使用了这种技术:

程序清单2-4 确定文件描述符数

[root@localhost apue]# cat prog2-4.c 
#include "apue.h"
#include <errno.h>
#include <limits.h>

#ifdef OPEN_MAX
static long openmax = OPEN_MAX;
#else
static long openmax = 0;
#endif

/*
* If OPEN_MAX is indeterminate, we're not
* guaranteed than this is adequate.
*/
#define OPEN_MAX_GUESS 256

long
open_max(void)
{
        if(openmax == 0) {      /* first time through */
                errno = 0;
                if((openmax = sysconf(_SC_OPEN_MAX)) < 0) {
                        if(errno == 0)
                                openmax = OPEN_MAX_GUESS; /* it's indeterminate */
                        else
                                err_sys("sysconf error for _SC_OPEN_MAX");
                }
        }
        return(openmax);
}

我们可以耐心地调用close,直至得到一个出错返回,但是从close(EBADF)出错返回并不区分无效描述符和没有打开的描述符。如果使用此技术,而且描述符9未打开,描述符10却打开了,那么将停止在9上,而不会关闭10.

某些实现将返回LONG_MAX作为限制值,但这与不限制其值在效果上是相同的。Linux对ATEXIT_MAX所取的限制值就属于此种情况。这将使程序的运行行为变得非常糟糕(浪费大量时间),因此它并不是一个好方法。

本篇博文内容摘自《UNIX环境高级编程》(第二版),仅作个人学习记录所用。关于本书可参考:http://www.apuebook.com/

posted @ 2013-12-29 14:14  ITtecman  阅读(3324)  评论(0编辑  收藏  举报