Hick - » Linux 编程

数据管理2(Beginning Linux Programming 笔记11)

Posted in: Linux 编程 — Hick @ 2009/06/15 22:18:53 Comments (5)

p297 文件锁定

有两种类型的文件锁定，最常见的是非内核实现的劝告式锁定(advisory locking)，其方法是所有进程遵循一个约定，也就是下面说的文件锁。另外一种是强制锁(mandatory locking)，它是由内核强制实施的，当一个锁被创建时，其他进程对被锁文件进行读写操作时会被挂起，椅子后到锁定释放，因为锁定在 read 和 write 上，会降低系统调用的性能。

文件锁定对多用户多任务操作系统是非常重要的，进程之间经常需要通过文件来共享数据。linux 下的文件锁不仅仅可以通过创建锁定文件(lock file)的原子操作来保证操作唯一性，还能针对文件的某一部分做排他性访问的锁操作。有一种说法，分别称这俩种锁为文件锁和记录锁(record lock)。

如果程序需要排他性的访问某个资源，可以通过先创建一个约定的文件锁的方式，约定其他访问该资源的程序都先检查该文件是否存在。处理完某个资源后，把该锁文件 unlink ，以便其他进程访问该资源。linux 系统一般把文件锁创建在 /var/spool 下。使用 open 创建文件锁时，需要使用 O_CREAT 和 O_EXCL 标识，这样才能以原子操作的方式保证创建有效锁，下面的程序中，只创建了锁，没有释放锁：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>

int main()
{
   int file_desc;
   int save_errno;

   file_desc = open("/tmp/LCK.test", O_RDWR | O_CREAT | O_EXCL, 0444);
   if (file_desc == -1) {
   save_errno = errno;
   printf("Open failed with error %d\n", save_errno);
   }
   else {
   printf("Open succeeded\n");
   }
   exit(EXIT_SUCCESS);
}

linux 下第二次执行上面的程序，会返回错误码为 17 ，是因为文件存在的错误码 EEXIST 的值被定义为 17 ，这也正是由于指定了 O_CREAT | O_EXCL 。一种常见创建文件锁的方法是把发起锁的进程的 id 写到文件中，这样可以通过检查进程 id 是否存在，防止锁被创建以后，在删除文件锁之前程序意外终止导致文件琐一直存在。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>

const char *lock_file = "/tmp/LCK.test2";

int main() {
   int file_desc;
   int tries = 10;

   while (tries--) {
   file_desc = open(lock_file, O_RDWR | O_CREAT | O_EXCL, 0444);
   if (file_desc == -1) {
   printf("%d - Lock already present\n", getpid());
   sleep(3);
   }
   else {
   /* critical region */
   printf("%d - I have exclusive access\n", getpid());
   sleep(1);
   (void)close(file_desc);
   (void)unlink(lock_file);
   /* non-critical region */
   sleep(2);
   }
   } /* while */
   exit(EXIT_SUCCESS);
}

p301 局部锁(locking regions)

PS: 这里很多笔记都来自<>一书第二版。

就是别的书上说的记录锁。需要访问一个大的共享文件时，文件锁就显得局限了。linux 允许锁定文件的某些部分(regions)，其他进程可以访问文件的其他没有锁定的部分。记录锁可以锁定文件的任意部分，比如进程 A 可以锁定一个文件从 50 字节 200 字节的部分，另一个进程 B 则可以锁定 300 字节到 350 字节的部分，这两个锁之间并不冲突。记录锁的另外一个优点是被内核保存，而不是文件系统实现的。当一个进程终止后，它所保存的所有锁都会被自动释放。这种锁也是劝告式的。linux 有提记录锁的强制式变体，但是使用不是很方便。

记录锁有两种类型，读锁和写锁，读锁实际上是共享锁，因为多个进程可以同时对一个区域保持读锁。但是对一个记录只能有一个进程保持写锁，写锁必须的胡斥的。进程在需要写文件时，必须得到一个写锁，写锁存在时，这个记录应该也应该没有读锁存在。保证读写不冲突。

至少有两种方法能实现局部锁： fcntl 和 lockf ，下面主要看用 fcntl 来实现的方式，注意两者虽然比较相似，但是不能同时奏效，对同一个文件，不能混合使用两种锁定方法。

#include <fcntl.h>
int fcntl(int fildes, int command, struct flock *flock_structure);

第一个参数为需要操作的文件 fd ，第二个参数为需要执行任务或者说命令： F_GETLK, F_SETLK, F_SETLKW 后面分别详细介绍。第三个参数为一个文件结构体 flock ，包含以下成员:

- l_type 锁的类型，可以是 F_RDLCK 设置为读锁(共享锁)；F_WRLCK 设置为写锁(互斥锁)；F_UNLCK 删除锁
- l_start l_whence 配合使用指定锁定区域, 可以是 SEEK_SET, SEEK_CUR, SEEK_END ，具体 lseek 函数
- l_len 指定锁定长度
- l_pid 只有当查询锁的时候才会使用，它被设置为拥有被查询锁的进程的 pid

command 取值:

- F_SETLK 设置 flock 结构描述的锁，如果因为与另外一个进程的锁冲突而使得锁无法创建，则返回 EAGAIN 。l_type 为 F_UNLCK 则删除锁
- F_SETLKW 和 F_SETLK 类似，但是一直阻塞锁直到锁被创建创建成功，如果在进程被阻塞时有信号发生， fcntl 调用返回 EAGAIN
- F_GETLK 检查所描述的锁是否被创建成功，如果已经创建，flock 结构除了 l_type 以外不会改变: l_type 被改成 F_UNLCK (还不大明白)；如果创建锁失败，l_pid 被设置为保持这个锁的进程 pid 。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>

const char *test_file = "/tmp/test_lock";
#define SIZE_TO_TRY 5

void show_lock_info(struct flock *to_show);

int main() {
   int file_desc;
   int res;
   struct flock region_to_test;
   int start_byte;

   /* open a file descriptor */
   file_desc = open(test_file, O_RDWR | O_CREAT, 0666);
   if (!file_desc) {
   fprintf(stderr, "Unable to open %s for read/write", test_file);
   exit(EXIT_FAILURE);
   }

   for (start_byte = 0; start_byte < 99; start_byte += SIZE_TO_TRY) {
   /* set up the region we wish to test */
   region_to_test.l_type = F_WRLCK;
   region_to_test.l_whence = SEEK_SET;
   region_to_test.l_start = start_byte;
   region_to_test.l_len = SIZE_TO_TRY;
   region_to_test.l_pid = -1;

   printf("Testing F_WRLCK on region from %d to %d\n",
   start_byte, start_byte + SIZE_TO_TRY);

   /* now test the lock on the file */
   res = fcntl(file_desc, F_GETLK, &region_to_test);
   if (res == -1) {
   fprintf(stderr, "F_GETLK failed\n");
   exit(EXIT_FAILURE);
   }
   if (region_to_test.l_pid != -1) {
   printf("Lock would fail. F_GETLK returned:\n");
   show_lock_info(&region_to_test);
   }
   else {
   printf("F_WRLCK - Lock would succeed\n");
   }

   /* now repeat the test with a shared (read) lock */

   /* set up the region we wish to test */
   region_to_test.l_type = F_RDLCK;
   region_to_test.l_whence = SEEK_SET;
   region_to_test.l_start = start_byte;
   region_to_test.l_len = SIZE_TO_TRY;
   region_to_test.l_pid = -1;

   printf("Testing F_RDLCK on region from %d to %d\n",
   start_byte, start_byte + SIZE_TO_TRY);

   /* now test the lock on the file */
   res = fcntl(file_desc, F_GETLK, &region_to_test);
   if (res == -1) {
   fprintf(stderr, "F_GETLK failed\n");
   exit(EXIT_FAILURE);
   }
   if (region_to_test.l_pid != -1) {
   printf("Lock would fail. F_GETLK returned:\n");
   show_lock_info(&region_to_test);
   }
   else {
   printf("F_RDLCK - Lock would succeed\n");
   }

   } /* for */

   close(file_desc);
   exit(EXIT_SUCCESS);
}

void show_lock_info(struct flock *to_show) {
   printf("\tl_type %d, ", to_show->l_type);
   printf("l_whence %d, ", to_show->l_whence);
   printf("l_start %d, ", (int)to_show->l_start);
   printf("l_len %d, ", (int)to_show->l_len);
   printf("l_pid %d\n", to_show->l_pid);
}

书中还讲述了竞争锁以及另外一种记录锁实现 lockf ，暂不细看。

p314 数据库

大多数 unix 系的操作系统都支持一种高效的数据库管理系统 dbm 。其实有些人怀疑它是否可以作为一种数据库，因为它只具备很简单的数据库功能，可以说就是一个文件索引存储系统。RPM 打包系统就使用 dbm 保存已经安装包的信息的存储介质。开源的 Open LDAP 以及 apache , sendmail 也使用 dbm 保存数据。相比 mysql 等数据库系统， dbm 非常轻量，不需要安装独立的数据库 server 。dbm 非常适合读很读多但是写很少的数据。linux 系统一般带 dbm 的 GNU 版，也就是 gdbm 。下面是个操作实例:

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>

#include <ndbm.h>
/* On some systems you need to replace the above with
#include <gdbm-ndbm.h>
*/

#include <string.h>

#define TEST_DB_FILE "/tmp/dbm1_test"
#define ITEMS_USED 3

/* A struct to use to test dbm */
struct test_data {
   char misc_chars[15];
   int any_integer;
   char more_chars[21];
};

int main() {

   struct test_data items_to_store[ITEMS_USED];
   struct test_data item_retrieved;

   char key_to_use[20];
   int i, result;

   datum key_datum;
   datum data_datum;

   DBM *dbm_ptr;

   dbm_ptr = dbm_open(TEST_DB_FILE, O_RDWR | O_CREAT, 0666);
   if (!dbm_ptr) {
   fprintf(stderr, "Failed to open database\n");
   exit(EXIT_FAILURE);
   }

   /* put some data in the structures */
   memset(items_to_store, '\0', sizeof(items_to_store));
   strcpy(items_to_store[0].misc_chars, "First!");
   items_to_store[0].any_integer = 47;
   strcpy(items_to_store[0].more_chars, "foo");
   strcpy(items_to_store[1].misc_chars, "bar");
   items_to_store[1].any_integer = 13;
   strcpy(items_to_store[1].more_chars, "unlucky?");
   strcpy(items_to_store[2].misc_chars, "Third");
   items_to_store[2].any_integer = 3;
   strcpy(items_to_store[2].more_chars, "baz");

   for (i = 0; i < ITEMS_USED; i++) {
   /* build a key to use */
   sprintf(key_to_use, "%c%c%d",
   items_to_store[i].misc_chars[0],
   items_to_store[i].more_chars[0],
   items_to_store[i].any_integer);

   /* build the key datum strcture */
   key_datum.dptr = (void *)key_to_use;
   key_datum.dsize = strlen(key_to_use);
   data_datum.dptr = (void *)&items_to_store[i];
   data_datum.dsize = sizeof(struct test_data);

   result = dbm_store(dbm_ptr, key_datum, data_datum, DBM_REPLACE);
   if (result != 0) {
   fprintf(stderr, "dbm_store failed on key %s\n", key_to_use);
   exit(2);
   }
   } /* for */

   /* now try and retrieve some data */
   sprintf(key_to_use, "bu%d", 13); /* this is the key for the second item */
   key_datum.dptr = key_to_use;
   key_datum.dsize = strlen(key_to_use);

   data_datum = dbm_fetch(dbm_ptr, key_datum);
   if (data_datum.dptr) {
   printf("Data retrieved\n");
   memcpy(&item_retrieved, data_datum.dptr, data_datum.dsize);
   printf("Retrieved item - %s %d %s\n",
   item_retrieved.misc_chars,
   item_retrieved.any_integer,
   item_retrieved.more_chars);
   }
   else {
   printf("No data found for key %s\n", key_to_use);
   }

   dbm_close(dbm_ptr);

   exit(EXIT_SUCCESS);
}

dbm 以及 mysql 更具体详细介绍暂不看。后面几章也不是我关注的点，暂时忽略不看。直接跳到第十一章进程和信号。

数据管理1(Beginning Linux Programming 笔记10)

Posted in: Linux 编程 — Hick @ 2009/06/14 13:14:18 Comments (0)

本章主要讲 linux 的动态内存管理、文件锁定以及 dbm 数据库.

p289 linux 中最基本的内存操作为 malloc 函数:

#include <stdlib.h>
void *malloc(size_t size);

#example:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#define A_MEGABYTE (1024 * 1024)

int main() {
   char *some_memory;
   int megabyte = A_MEGABYTE;
   int exit_code = EXIT_FAILURE;

   some_memory = (char *)malloc(megabyte);
   if (some_memory != NULL) {
   sprintf(some_memory, "Hello World\n");
   printf("%s", some_memory);
   exit_code = EXIT_SUCCESS;
   }
   exit(exit_code);
}

虽然定义 malloc 返回的是 void * 指针，但是可以用 char * 类型变量来保存，注意这主要是因为当前使用的系统大都是 32 位， 32 位指针可以保存到一个 char * 类型中，64 位下不可以。这里把字符串保存到内存(变量是用的 sprintf 函数)。

p291 以每次 1M 的方式申请内存，并在申请到的内存中写入一掉段字符串，不断分配直到达到两倍物理内存的量(作者给出的为 2G)，最终成功执行。接下来每次只分配 1k 内存，程序不断分配下去，执行的时间比较长，磁盘的读写的操作也会很明显，在分配到 1526M 以后，提示 Out of memory, Killed process 2365 。

p292 这里内存的管理(读、写)是由 linux 内核负责的，每次内存操作请求，内核会觉得如何响应。一开始进程申请使用内存时，会分配物理内存给进程使用；当物理内存耗尽，就会开始使用交换分区(swap space, 把磁盘当内存用)；比如无法再分配内存时，结束申请内存的进程。内核根据算法在物理内存和交换分区之间移动数据，但是程序中调用起来是没有差别的，当时候到交换分区的时候，由于磁盘操作会比较慢，所以会影响到程序和系统性能。

对进程来说，它使用的内存是虚拟的。Linux 把内存以页为单元进行管理，一般来说一页 4k (分配了 1M 内存不一定就使用了这么多内存)。当进程进行内存操作时，先需要做一个虚拟地址-物理地址的映射。

p293 内存滥用申请内存的时候需要指定大小，接着往申请的内存中写入数据的时候，有可能申请的内存不够用：

#include <unistd.h>
#include <stdlib.h>

#define ONE_K (1024)

int main() {
   char *some_memory;
   char *scan_ptr;

   some_memory = (char *)malloc(ONE_K);
   if (some_memory == NULL) exit(EXIT_FAILURE);

   scan_ptr = some_memory;
   while(1) {
   *scan_ptr = '\0';
   scan_ptr++;
   }

   exit(EXIT_SUCCESS);
}

上面的程序中，申请了 1k 的内存，但是以一个死循环的方式，不断的往内存中保存一个一个字符。编译都不会出错，执行程序时，会报告: Segmentation fault 。

p294 空指针

linux 系统对内存有一些保护性措施，可以读一个空指针(返回 null)，而写空指针时，会出现 Sagmentation fault 的错误：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main() {
   char *some_memory = (char *)0;

   printf("A read from null %s\n", some_memory);
   sprintf(some_memory, "A write to null\n");

   exit(EXIT_SUCCESS);
}

p295 释放内存

虽然当一个进程结束时，其申请使用的内存会被系统自动释放，但是很多场景下，我们需要主动的释放内存：使用 free 函数。当一个进程的内存 page 被释放，不再使用时，linux 的内存管理器会把它从物理内存移动到交换分区。如果一个进程尝试操作被移到交换分区的内存 page 的数据，系统会先挂起进程，然后把相关 page 从交换分区移动到物理内存，然后让进程继续执行。是对程序来说，相关内存块就像是一直在物理内存中一样。

#include <stdlib.h>
void free(void *ptr_to memory);

free 函数只能释放 malloc, calloc, realloc 申请的内存。

p297 其他内存分配函数: calloc()函数有两个参数,分别为元素的数目和每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小，如果调用成功，返回所分配的内存空间的首地址。且会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那麽这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那麽这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。calloc()函数是malloc的简单包装。它的主要优点是把动态分配的内存清零。用经验的程序员更喜欢使用calloc()，因为这样的话新分配内存的内容就不会有什么问题，调用calloc()肯定会清0，并且可以避免调用memset().(部分摘自网文)

realloc 函数用于改变分配已申请的内存的大小： void *realloc(void *existing_memory, size_t new_size);

Linux 环境2(Beginning Linux Programming 笔记9)

Posted in: Linux 编程 — Hick @ 2009/06/13 14:33:59 Comments (0)

p181 时间和日期

linux 下时间一般用 long int 型的类型 time_t ，其定义在 time.h 中，我们可以通过 time 函数获得 UNIX 时间戳值，原型以及实例如下:

// 原型
#include <time.h>
time_t time(time_t *tloc);
// 实例
#include <time.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
   int i;
   time_t the_time;

   for(i = 1; i <= 10; i++) {
   the_time = time((time_t *)0);
   printf("The time is %ld\n", the_time);
   sleep(2);
   }
   exit(0);
}

该函数返回时间戳，同时把时间戳保存字 tlog 中。注意 (time_t *)0 为 null 指针的写法。

p183 difftime 函数用来计算时间差。gmtime 则用来把时间戳输出成包含可读时间的 tm 结构体：

#include <time.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
   struct tm *tm_ptr;
   time_t the_time;

   (void) time(&the_time);
   tm_ptr = gmtime(&the_time);

   printf("Raw time is %ld\n", the_time);
   printf("gmtime gives:\n");
   printf("date: %02d/%02d/%02d\n",
   tm_ptr->tm_year, tm_ptr->tm_mon+1, tm_ptr->tm_mday);
   printf("time: %02d:%02d:%02d\n",
   tm_ptr->tm_hour, tm_ptr->tm_min, tm_ptr->tm_sec);
   exit(0);
}

p184 gmtime 得到的是 GMT 标准时间，要想得到本地(本时区)时间，需要用 localtime 函数，它跟 gmtime 的区别只在输出不同时区的时间。

tm 结构体可以由 mkdir 函数转换回时间戳，转换失败函数返回 -1 :

#include <time.h>
time_t mktime(struct tm *timeptr);

另外 asctime 函数可以把 tm 结构转换成”Sun Jun 9 12:34:56 2007\n\0″这样的字符串。 ctime 则相当于下面的第四行代码：

#include <time.h>
char *asctime(const struct tm *timeptr);
char *ctime(const time_t *timeval);
asctime(localtime(timeval));

p186 strftime 用来格式化输出自定义的可读的时间格式。

#include <time.h>
size_t strftime(char *s, size_t maxsize, const char *format, struct tm *timeptr);

把 timeptr 表示的 tm 结构体时间转化成 format 指定格式的字符串，date 命令对应的输出为: “%a %b %d %H:%M:%S %Y”。另外 strptime 功能类似：

#include <time.h>
char *strptime(const char *buf, const char *format, struct tm *timeptr);

使用例子：

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
   struct tm *tm_ptr, timestruct;
   time_t the_time;
   char buf[256];
   char *result;

   (void) time(&the_time);
   tm_ptr = localtime(&the_time);
   strftime(buf, 256, "%A %d %B, %I:%S %p", tm_ptr);

   printf("strftime gives: %s\n", buf);

   strcpy(buf,"Thu 26 July 2007, 17:53 will do fine");

   printf("calling strptime with: %s\n", buf);
   tm_ptr = &timestruct;

   result = strptime(buf,"%a %d %b %Y, %R", tm_ptr);
   printf("strptime consumed up to: %s\n", result);

   printf("strptime gives:\n");
   printf("date: %02d/%02d/%02d\n",
   tm_ptr->tm_year % 100, tm_ptr->tm_mon+1, tm_ptr->tm_mday);
   printf("time: %02d:%02d\n",
   tm_ptr->tm_hour, tm_ptr->tm_min);
   exit(0);
}

p189 临时文件

tmpnam 函数可以用来生成唯一文件名(文件系统中不存在的文件)，同一个进程中它可以被调用 TMP_MAX 次。参数非 null 时，生成的文件名会赋予给该变量：

#include <stdio.h>
char *tmpnam(char *s);

如果生成文件名以后马上就需要创建文件，可以直接使用 tmpfile 函数，这样能防止在生成文件名到创建文件的过程中，另外一个进程创建了同样的文件。

#include <stdio.h>
FILE *tmpfile(void);

该函数返回指向临时文件的文件流指针，并且以读写方式打开文件，当所有指向该文件的引用被关闭时，临时文件会被自动删除。注意因为有上面说到的风险，所以一般创建临时文件都用 tmpfile 来，实际上 GNU C 编译器会对 tmpname 的使用产生一条 warning 。另外，某些 UNIX 版本中提供另外一种方式:

#include <stdlib.h>
char *mktemp(char *template);
int mkstemp(char *template);

p191 用户信息

linux 中，除了 init 进程以外，所有的进程都是由用户或者其他进程启动的。进程启动以后，都会有一个与之想关联的用户，程序中以用户的唯一标识 UID 来表示。(su 命令可以改变进程的启动用户) 。 UID 的结构体为 sys/types.h 中定义的 uid_t ，一般是个整型，非系统进程也就是用户进程的 UID 一般大于 100 ， init 进程为系统初始进程， UID 为 0 。可以通过下面的函数获得进程的 UID 或者用户名:

#include <sys/types.h>
#include <unistd.h>
uid_t getuid(void);
char *getlogin(void);

系统文件 /etc/passwd 中保存着系统用户的信息，每行为一个用户的信息: 用户名:加密密码:UID:GID/全名:HOME目录:默认shell ，比如:

neil:zBqxfqedfpk:500:100:Neil Matthew:/home/neil:/bin/bash

现在的大多数系统中已经不再把密码加密串保存在这里，而是使用”影子密码(shadow password)”文件，一般在 /etc/shadow ，通过限制对它的操作，来加强系统的安全性。

我们可以通过下面的函数获得用户的信息:

#include <sys/types.h>
#include <pwd.h>
struct passwd *getpwuid(uid_t uid);
struct passwd *getpwnam(const char *name);

getpwuid 根据 UID 返回 passwd 结构， getpwnam 则是通过用户名返回 passwd 结构，跟 /etc/passwd 文件对应，该结构包含以下成员：

. char *pw_name 用户名
. uid_t pw_uid UID
. gid_t pw_gid GID - group id
. char *pw_dir HOME 目录
. char *pw_gecos 用户全名
. char *pw_shell 用户默认 shell

注意获取用户全名在不同系统下可能定义不一样，上面是 linux 下的定义，其他系统可能是 pw_comment 。下面是一个使用示范:

#include <sys/types.h>
#include <pwd.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
   uid_t uid;
   gid_t gid;
   struct passwd *pw;

   uid = getuid();
   gid = getgid();

   printf("User is %s\n", getlogin());

   printf("User IDs: uid=%d, gid=%d\n", uid, gid);

   pw = getpwuid(uid);
   printf("UID passwd entry:\n name=%s, uid=%d, gid=%d, home=%s, shell=%s\n",
   pw->pw_name, pw->pw_uid, pw->pw_gid, pw->pw_dir, pw->pw_shell);

   pw = getpwnam("root");
   printf("root passwd entry:\n");
   printf("name=%s, uid=%d, gid=%d, home=%s, shell=%s\n",
   pw->pw_name, pw->pw_uid, pw->pw_gid, pw->pw_dir, pw->pw_shell);
   exit(0);
}

如果需要遍历所有用户信息，可以通过 getpwent 函数来实现，不详述。

p194 获得主机信息

如果一个 linux 机器在网络环境下，可以使用 gethostname 函数获得主机名，而用 uname 可以获得更多的主机信息，包括操作系统以及部分硬件信息。

#include <unistd.h>
int gethostname(char *name, size_t namelen);

#include <sys/utsname.h>
int uname(struct utsname *name);

p196 系统日志

根据不同的目的，linux 下会有不同的目录保存系统日志信息。常见的的比如 /usr/adm , /var/log 下。/var/log/message 包含所有的系统消息， /var/log/mail 为邮件系统的日志，/var/log/debug 为调试性信息，可以在 /etc/syslog.conf 或者 /etc/syslog-ng/syslog-ng.conf 看到相关目录和文件的配置。syslog 函数用来记录系统日志：

#include <syslog.h>
void syslog(int priority, const char *message, arguments...);

日志级别定义： LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR, LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG 。很多系统默认设置会把 LOG_EMERG 级的信息广播给所有用户，LOG_ALERT 则是 mail 给系统管理员，LOG_DEBUG 可能被忽略。使用 syslog 的时候，可以如下通过 %m 来插入当前错误的信息(errno 对应的错误信息): syslog(LOG_ERR|LOG_USER, “oops - %m\n”) 。

可以通过 setlogmask 定义需要记录的日志级别。

p201 资源限制

出于硬件限制(比如内存)或者系统策略等的需要，linux 会丢一些资源的使用做限制，比如单进程同时打开的文件数。limits.h 中定义了一些常量(列了部分):

- NAME_MAX 文件名最大字符数
- CHAR_BIT 字符的字节数
- CHAR_MAX 字符最大值
- INT_MAX int 型最大值

对系统资源的限制定义在 sys/resource.h 中。下面是获得或者设置系统资源限制的常用函数:

#include <sys/resource.h>
int getpriority(int which, id_t who);
int setpriority(int which, id_t who, int priority);
int getrlimit(int resource, struct rlimit *r_limit);
int setrlimit(int resource, const struct rlimit *r_limit);
int getrusage(int who, struct rusage *r_usage);

上面结构中的 rusage 是表示 CPU 时间的，至少包括两个成员： struct timeval ru_utime 用户时间; struct timeval ru_stime 系统时间。 timeval 是 sys/time.h 中定义的包括表示秒和微秒两个成员的结构。简单的说，系统时间就是进程使用系统调用所耗费的时间，用户时间则是进程进行系统调用之外的运算耗费的时间。getruage 函数还可以由参数指定获取包括当前进程的子进程的信息。

系统默认的进程优先级是 0 ，可用值范围为 -20 到 +20 。所以 getpriority 函数获得进程优先级时，返回 -1 可能是函数执行出错也可能是优先级为 -1 ，这时候就需要检查系统的 errno 中是否有值了。

最大打开文件数等资源限制可以由 getrlimit 和 setrlimit 获得和设置。 rlimit 结构描述一个限制，两个成员分别代表软限制(当前进程的限制)以及硬限制(系统的限制)。定义在 sys/resource.h 的常见限制:

- RLIMIT_CORE 字节表示的 cordump 文件最大值
- RLIMIT_CPU 秒为单元的 CPU 最大使用时间
- RLIMIT_DATA 程序数据段使用的字节数限制
- RLIMIT_FSIZE 字节为单位的文件大小限制
- RLIMIT_NOFILE 同时打开最大文件数
- RLIMIT_STACK 程序栈大小(字节)
- RLIMIT_AS 地址空间(栈和数据)限制

接下来的俩章：终端和基于文本和光标的屏幕处理没有什么实际价值，不细看。

Linux 环境1(Beginning Linux Programming 笔记8)

Posted in: Linux 编程 — Hick @ 2009/06/07 8:32:56 Comments (0)

p170 程序参数

先明确两个概念：选项、选项参数。比如 gcc -g -o test test.c ，这里 g 和 o 是选项，其中 test 是 o 的选项参数，一般也直接称为参数。

c 语言里最常见的 main 函数原型：

int main(int argc, char *argv[])

其中 argc 为选项和参数的个数， argv 为选项和参数字符串数组。

p171 在 main 函数中可以直接读取上面的两个变量获得参数信息：

$ myprog left right ‘and center’

rgc: 4
argv: {“myprog”, “left”, “right”, “and center”}

由于一些历史原因，linux/unix 下的命令的选项和参数格式并没有得到很好的统一规和范。比如解压缩命令 tar zxvf httpd-2.0.59.tar.gz ，查看当前目录文件列表命令 ls -lt 或者 ls -l -t 。一般建议使用横杠加单个字符或者数字的方式，没有附加参数的选项一般跟上面的 ls 命令一样，可以合并到横杠以后。有些命令会有相对应的反向操作命令，比如 set -o xtrace 用来打开 shell 脚本执行跟踪，而反向操作为 set +o xtrace 来关闭该功能。

p172 下面的程序演示获得一个程序参数的方式：

for(arg = 0; arg < argc; arg++) {
   if(argv[arg][0] == '-')
   printf("option: %s\n", argv[arg]+1);
   else
   printf("argument %d: %s\n", arg, argv[arg]);
}

注意上面第三行 argv[arg]+1 实际上是指针操作，输出以后得到字符传的一部分。

p173 针对上面的建议规范，Linux 提供 getopt 来解析选项和参数(注意区分选项和参数)。函数原型：

#include <unistd.h>
int getopt(int argc, char *const argv[], const char *optstring);
extern char *optarg;
extern int optind, opterr, optopt;

getopt 扫描 argv 中的选项和参数，返回 optstring 中定义过的选项名。optstring 中定义的选项名后加冒号表示该选项需要参数，getopt 在扫描到这样的选项后，会把参数值保存在全局变量 optarg 中。(###待定) optopt 中保存最后一个由 getopt() 返回的已知的选项；扫描到最后一项目返回 -1 ；遇到无效选项返回问号，optopt 包含了无效选项字符。当 getopt 检测到错误，比如 optstring 定义有参数的选项没有参数时，可能会抛出错误，通过在调用 getopt 之前把 opterr 设置为 0 或者 optstring 的第一个字符为冒号可以让 getopt 不抛出错误；抑制了错误后，需要指定参数的选项没有选项时，getopt 在返回该选项的地方返回冒号，没有抑制错误时返回问号。实例:

int main(int argc, char * argv[])
{
   int ch;

   while ((ch = getopt(argc, argv, "abcd:")) != -1)
   {
   switch (ch) {
   case 'a':
   printf("option: -a\n");
   break;
   case 'b':
   printf("option: -b\n");
   break;
   case 'c':
   printf("HAVE option: -c\n");
   break;
   case 'd':
   printf("option: -c\n");
   printf("The argument of -b is %s\n", optarg);
   break;
   case '?':
   printf("Unknown option: %c\n",(char)optopt);
   break;
   }
   printf("optind: %d\n", optind);
   }
}

先看下比较正常的执行方式:

$ ./a -a -b -c -d hick1 hick2
option: -a
optind: 2
option: -b
optind: 3
HAVE option: -c
optind: 4
option: -c
The argument of -b is hick1
optind: 6

上面有一个”不正常”的地方，就是最后一个选项多了一个参数，getopt 函数会忽略这个参数。在扫描到 -a 选项的时候，optind 中保存的是下一个选项也就是 -b 在 agrv 数组中的索引； -d 在 argv 中的索引为 4 ，按照程序设计后面需要跟一个参数，所以 optind 中保存的值应该是 6 — 尽管该索引值并不是真正的选项。总结来说， optind 保存的是根据 optstring 的规则， getopt 即将判断的下一个是否是选项的项在 argv 中的索引值。把 -a 放到最后执行一下就可以验证。

变量 opterr 和 optind 都被初始化为1。如果想要略去命令行的前几个参数，可以在调用 getopt() 前将 optind 设成其他值。

p175 getopt_long 用来解析另外一种风格的参数，比如 –help 。例子虽然是看懂了，但是还是有不少疑问，考虑到这块应用面不广，需要的时候再详细深入。

p177 环境变量我们可以通过 getenv 函数和 putenv 两个函数来操作环境变量。

#include <stdlib.h>
char *getenv(const char *name);
int putenv(const char *string);

注意环境变量有这样的字符串组成 name=value 。getenv 会返回 value 的值，找不着时会返回 null 。如果由于可用内存不足导致修改失败(应该很难发生吧)，会返回 -1 ，这时候全局变量 errno 会百设置成 ENOMEM 。设置函数的参数就是 name=value 这样的字符串。

p180 environ 变量所有的环境变量都保存在一个名为 environ 的字符串数组中：

#include <stdlib.h>
extern char **environ;

不过没有特殊要求，一般建议通过 getenv 和 putenv 来操作环境变量，不要直接操作 environ 。下面这样可以输出所有的环境变量：

#include <stdlib.h>
#include <stdio.h>
extern char **environ;
int main()
{
   char **env = environ;
   while(*env) {
   printf(“%s\n”,*env);
   env++;
   }
   exit(0);
}

文件操作4(Beginning Linux Programming 笔记7)

Posted in: Linux 编程 — Hick @ 2009/06/06 8:59:14 Comments (0)

p152 stream 错误：标准 io 库出错的时候，通常都返回一个 null 指针或者 EOF ，同时把错误的具体信息保存到全局变量 errno 中。这是个很多函数比如 fprintf 都可能改写的变量，只有当出错时，其值才具备参考价值。

#include <errno.h>
extern int errno;

由于文件到达末尾和出错都可能返回同样的值比如 EOF ，库函数提供一些方法来区分。

#include <stdio.h>
int ferror(FILE *stream);
int feof(FILE *stream);
void clearerr(FILE *stream);

ferror 用来检查 stream 上是否发生了错误，没有出错返回 0 ，出错返回非 0 值。 feof 检测是否到达了 stream 的末尾，非 0 值表示到达文件末尾。

stream 和 fd 的关系：每个 stream 都和个 fd 相关联，甚至是 fd 的操作和 stream 的操作在转换后可以混合使用，但是这样没法利用 io 库的 buffer 等特性，如果有相关操作可能造成不可预见的问题。他们之间通过下面的函数可以进行转换：

#include <stdio.h>
int fileno(FILE *stream);
FILE *fdopen(int fildes, const char *mode);

有些特殊情况下，这些函数会比较实用。比如如果要通过系统调用获得已经打开的 stream 的一些信息，可以通过 fileno 获得 fd ，然后调用系统调用比如 fstat 来获得文件的信息；反过来，也可以把已经打开的 fd 转换为 stream 以后，利用标准库的 buffer 等特性操作文件。

p153 文件和目录维护下面介绍系统调用一般都有对应 shell 命令可以参照。chmod 和 chown 为系统调用:

# chmod
#include <sys/stat.h>
int chmod(const char *path, mode_t mode);

# chown
#include <sys/types.h>
#include <unistd.h>
int chown(const char *path, uid_t owner, gid_t group);

unlink 用来删除一个文件在目录中的入口，返回 0 表示删除成功。通常有一个小技巧就是先 open 一个文件，然后进行完一定的操作以后进行 unlink 操作，这就意味着这个文件只在程序执行时存在，为临时文件，进程执行完毕以后，文件自动被关闭。

#include <unistd.h>
int unlink(const char *path);
int link(const char *path1, const char *path2);
int symlink(const char *path1, const char *path2);

rmdir 和 mkdir 分别用来删除和创建目录:

# mkdir
#include <sys/types.h>
#include <sys/stat.h>
int mkdir(const char *path, mode_t mode);

# rmdir
#include <unistd.h>
int rmdir(const char *path);

每个进程都会有一个当前目录，可以通过 chdir 来改变当前目录，也可以通过 getcwd 来获得当前工作目录。

# chdir
#include <unistd.h>
int chdir(const char *path);

# getcwd
#include <unistd.h>
char *getcwd(char *buf, size_t size);

getcwd 函数会把获得路径名保存到 buffer ，如果路径名大于 size(ERANGE error), 函数返回 null ，如果操作成功则返回 buf 。

p155 遍历目录目录操作的相关函数是在 dirent.h 中声明的，标准库定义了一个结构 DIR 用来描述目录。指向这种结构的指针被称为 directory stream, 跟 file stream 类似。需要包含的头文件都一样，相关函数原型如下:

#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);
struct dirent *readdir(DIR *dirp);
long int telldir(DIR *dirp);
void seekdir(DIR *dirp, long int loc);
int closedir(DIR *dirp);

- opendir 打开一个目录(文件)，操作成功返回 directory stream ，否则返回 null 指针。

- readdir 返回指定的 directory stream 中的下一个项(文件或子目录)的结构。按照 POSIX 兼容标准，读到最后返回 null ，并且不改变 errno 的值；读取出错时也返回 null ，同时改变 errno 的值。注意如果该函数执行过程中有其他进程在对该目录下的项进行操作，该函数不保证拿到最新修改后的数据。返回的 dirent 结构中包含下面两项： ino_t d_ino 文件(包括子目录)的 inode 节点; char d_name[]: 文件(包括子目录)名。要检查获得的项是一般文件还是目录，需要调用前面介绍的 stat 函数。

- telldir 用来返回表示当前 directory stream 的位置的整数，一般通过配合下面的 seekdir 使用。

- seekdir 重设读取的 dirp 的位置。

- closedir 用来关闭一个 directory stream ，在遍历目录时，为了保证当前打开的目录数不达到系统限制，一般需要即使关闭打开的 directory stream 。

下面是一个相关函数的使用实例:

#include <unistd.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <stdlib.h>

void printdir(char *dir, int depth)
{
   DIR *dp;
   struct dirent *entry;
   struct stat statbuf;

   if((dp = opendir(dir)) == NULL) {
   fprintf(stderr,"cannot open directory: %s\n", dir);
   return;
   }
   chdir(dir);
   while((entry = readdir(dp)) != NULL) {
   lstat(entry->d_name,&statbuf);
   if(S_ISDIR(statbuf.st_mode)) {
   /* Found a directory, but ignore . and .. */
   if(strcmp(".",entry->d_name) == 0 ||
   strcmp("..",entry->d_name) == 0)
   continue;
   printf("%*s%s/\n",depth,"",entry->d_name);
   /* Recurse at a new indent level */
   printdir(entry->d_name,depth+4);
   }
   else printf("%*s%s\n",depth,"",entry->d_name);
   }
   chdir("..");
   closedir(dp);
}

/* Now we move onto the main function. */
int main()
{
   printf("Directory scan of /home:\n");
   printdir("/home",0);
   printf("done.\n");

   exit(0);
}

p160 错误 error.h 中定义的常用错误包括：

- EPERM 没有操作权限
- ENOENT 操作的文件或者目录不存在
- EINTR 系统调用被中断
- EIO I/O 错误
- EBUSY 设置或者资源繁忙
- EEXIST 文件已经存在
- EINVAL 参数不合法
- EMFILE 打开文件 fd 太多
- ENODEV 没有需要打开的设备
- EISDIR 操作对象是目录
- ENOTDIR 操作对象不是目录

另外还有两个用有的函数用来解读 errno ：

#include <string.h>
char *strerror(int errnum);

#include <stdio.h>
void perror(const char *s);

strerror 用来把错误号 errno 错误信息的文本描述。而 perror 则是自动获取当前的 errno 并用文本描述错误信息，在错误信息前面加上字符串 s 和一个空格。

p162 文件系统中的 /proc 通过系统调用访问 /dev 下的文件没有可以实现和硬件的交互。通常我们都会有一些实用工具能够访问系统硬件设备，比如 hdparm 用来控制磁盘参数， ifconfig 用来配置网络设备的参数。 linux 也提供特殊的文件系统 procfs ，也就是 /proc 下的文件，让我们能够从更高的层面访问驱动程序和系统内核。

/proc 下的某些文件中保存了一些只读的系统信息，比如 /proc/cpuinfo 中保存了系统 CPU 的情况， /proc/meminfo 和 /proc/version 保存了内存以及内核版本的情况。每次这些文件被读取时，系统会去获得最新的相关信息。比如 /proc/net/sockstat 中保存了当前的网络 socket 的使用情况，而其使用情况是变化比较频繁的。

/proc 下也有一些文件可以被写，比如系统同时运行的进程打开的总文件数可以直接从 /proc/sys/fs/file-max 中获得(为内核参数)，我们也可以用 echo 80000 >/proc/sys/fs/file-max 的方式来临时修改该值。

/proc 目录下有很多数字命令的目录，每个目录代表一个正在运行的进程，目录名即进程 id，目录下保存了当前进程的相关执行信息，比如进程的路径，进程执行的”当前路径”等。下面的第四章会有详细探讨。注意 fd 子目录保存了当前进程打开的文件信息，具体来说，我能够看到 fd 数字，比如标准设备 0, 1, 2 。

p165 fcntl 和 mmap

fcntl 能够对原始的 fd 进行上面介绍以外的更多操作，比如复制 fd, 获得或设置 fd 的标记(flag)，管理文件块等。

#include <fcntl.h>
int fcntl(int fildes, int cmd);
int fcntl(int fildes, int cmd, long arg);

不同的操作有不同的第三个参数。比如:

- fcntl(fildes, F_DUPFD, newfd) 用来复制一个 fd ，它根据 fildes 复制出一个 fd 数等于或者大于 newfd 的数，并返回一个新的 fd ，跟 filedes 指向同一个文件。也就是说，该功能很大程度上跟 dup 函数类似。

- fcntl(fildes, F_GETFD) 返回 fcntl.h 中定义的 fd 标记，比如 FD_CLOEXEC 表示 exec 系列函数调用成功以后，fd 是否被关闭。

- fcntl(fildes, F_SETFD, flags) 跟上面的函数对应，是用来设置 fd 标记的，一般常用的也是 FD_CLOEXEC 。

- fcntl(fildes, F_GETFL) 和 fcntl(fildes, F_SETFL, flags) 用类获得和设置文件状态标记以及访问方式(access mode)，你可以使用 fcntl.h 中定义的 mask O_ACCMODE 来对比出文件访问方式。open 函数 O_CREAT 时第三个参数的相关 flag 也可以通过这里来设置，注意并不是所有的设置都能够在这里操作，典型的是文件访问权限不能够通过 fcntl 设置。

p166 mmap 是 memery map 的意思，是 linux 内核 2.0 以后支持的功能，它允许我们把文件映射到内存中，这样不同进程能够像操作文件一样来操作内存。 mmap 函数就是用来把一个打开的文件 fd 映射到内存：

#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);

可以通过指定 off 文件内容中映射到内存的开始位置；addr 为内存的开始地址，为 0 时，会自动分配可用的内存，为了防止一出现访问到使用中的内存，一般使用 0 作为该参数值; len 为分配的内存长度; filedes 为需要映射的文件的 fd； prot 为内存保护标志(访问模式)，不能与文件的打开模式冲突，一般使用下列值的或运算：

- PROT_EXEC 内存段(segment)可执行
- PROT_READ 可以被读取
- PROT_WRITE 可以被写入
- PROT_NONE 不可访问

flags 参数控制程序修改内存段内容时影响文件的方式:

- MAP_PRIVATE 内存段为私有(改变只针对该进程)
- MAP_SHARED 内存段共享, 所有改变都会被刷到文件中
- MAP_FIXED 必须指定内存段的地址 addr(###)

msync 将映射内存中的数据写回磁盘。可以指定内存地址和长度以及写回模式：

#include <sys/mman.h>
int msync(void *addr, size_t len, int flags);

munmap 函数用来释放内存:

#include <sys/mman.h>
int munmap(void *addr, size_t len);

— Next Page »

HICK 者，乡巴佬也

数据管理2(Beginning Linux Programming 笔记11)

数据管理1(Beginning Linux Programming 笔记10)

Linux 环境2(Beginning Linux Programming 笔记9)

Linux 环境1(Beginning Linux Programming 笔记8)

文件操作4(Beginning Linux Programming 笔记7)

最新日志:

日志分类:

最新评论:

RSS:

Admin:

Friends:

Tech Friends:

Tech Resource: