APUE函数笔记五: 进程环境

原创 2012年03月24日 15:09:00

第七章  进程环境:

#include <stdlib.h>
void exit(int status);
void _Exit(int status);

#include <unistd.h>
void _exit(int status);

#include <stdlib.h>
int atexit(void (*func)(void));
    ret is 0 means success, log-func-total-counts <= 32 in one process

extern char ** environ;

    argc, argv[], envp[]/environ
              stack
               ||
               \/
               /\
               ||
              heap
uninit-data(bss: block started by symbol)
            init-data
              text

#include <stdlib.h>
void * malloc(size_t size);
void * calloc(size_t nobj, size_t size);
    alloc >= nobj * size, each-block >= size
    will init with 0, not means 0.0 of float, NULL of pointer
void * realloc(void * ptr, size_t newsize);
    if ptr is NULL, same as malloc
void free(void * ptr);

void * alloca(size_t size);
    alloc from stack, will free itself, but not surpport by some OS

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

#include <stdlib.h>
int putenv(char * str);
    add or rewrite an environ item to env-table, bit-copy, may be not safe
    ret is 0 means success
int setenv(char * name, char * value, int rewrite);
    add or rewrite an environ item to env-table, 
    function will generic string: "name=value" itself, so it is safe
    rewrite is 0, if name exist, do nothing, return 0
    ret is 0 means success
int unsetenv(char * name);
    delete an environ item
    if name not exist, will return 0
    ret is 0 means success

#include <setjmp.h>
int setjmp(jmp_buf env);
    if call it directly, return 0, 
    callback after longjmp will return non-zero value
void longjmp(jmp_buf env, int val);

#include <sys/resource.h>
int getrlimit(int resource, struct rlimit * rlptr);
int setrlimit(int resource, const struct rlimit * rlptr);
    ret is 0 means success
    struct rlimit {
        rlim_t rlim_cur; /* soft limit: current limit */
        rlim_t rlim_max; /* hard limit: maximum value for rlim_cur */
    };
    RLIM_INFNITY: no limit

示例:

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

void 
my_exit1(void)
{
    printf("first exit handler\n");
}

void 
my_exit2(void)
{
    printf("second exit handler\n");
}

int 
main(void)
{
    if (atexit(my_exit1) != 0) {
        printf("cannot register my_exit1\n");
        return -1;
    }

    if (atexit(my_exit2) != 0) {
        printf("cannot register my_exit2\n");
        return -1;
    }

    if (atexit(my_exit2) != 0) {
        printf("cannot register my_exit2\n");
        return -1;
    }

    printf("main is done\n");
    return 0;
}

#include <stdio.h>

void 
show1(int argc, char * argv[])
{
    int i;

    for (i = 0; i < argc; ++i) {
        printf("argv[%d]: %s\n", i, argv[i]);
    }
}

void 
show2(char * argv[])
{
    int i;

    for (i = 0; argv[i] != NULL; ++i) {
        printf("argv[%d]: %s\n", i, argv[i]);
    }
}

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

    return 0;
}

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

static jmp_buf jmpbuffer;
static int     globval;

void 
jump(void)
{
    longjmp(jmpbuffer, 1);
}

void 
doit(int i, int j, int k, int l)
{
    printf("in doit():\n");
    printf("globval = %d, autoval = %d, regival = %d, "
           "volaval = %d, statval = %d\n", globval, i, j, k, l);
    jump();
}

int 
main(void)
{
    int            val;
    int            autoval;
    register int   regival;
    volatile int   volaval;
    static   int   statval;

    globval = 1;
    autoval = 2;
    regival = 3;
    volaval = 4;
    statval = 5;

    if ((val = setjmp(jmpbuffer)) != 0) {
        printf("after longjmp: %d\n", val);
        printf("globval = %d, autoval = %d, regival = %d, "
               "volaval = %d, statval = %d\n", 
               globval, autoval, regival, volaval, statval);
        exit(-1);
    }

    globval = 95;
    autoval = 96;
    regival = 97;
    volaval = 98;
    statval = 99;

    doit(autoval, regival, volaval, statval);
    exit(0);
}

#include <stdio.h>
#include <stdlib.h>
#if defined(BSD) || defined(MACOS)
#include <sys/time.h>
#define  FMT  "%10lld  "
#else
#define  FMT  "%10ld  "
#endif
#include <sys/resource.h>

void 
pr_limits(char * name, int resource)
{
    struct rlimit limit;

    if (getrlimit(resource, &limit) < 0) {
        printf("getrlimit error for %s\n", name);
        return;
    }
    printf("%-14s  ", name);
    if (limit.rlim_cur == RLIM_INFINITY) {
        printf("(infinity)  ");
    }
    else {
        printf(FMT, limit.rlim_cur);
    }
    if (limit.rlim_max == RLIM_INFINITY) {
        printf("(infinity)");
    }
    else {
        printf(FMT, limit.rlim_max);
    }
    printf("\n");
}

#define   doit(resource)  pr_limits(#resource, resource)

int 
main(void)
{
#ifdef   RLIMIT_AS
    doit(RLIMIT_AS);
#endif
    doit(RLIMIT_CORE);
    doit(RLIMIT_CPU);
    doit(RLIMIT_DATA);
    doit(RLIMIT_FSIZE);
#ifdef   RLIMIT_LOCKS
    doit(RLIMIT_LOCKS);
#endif
#ifdef   RLIMIT_MEMLOCK
    doit(RLIMIT_MEMLOCK);
#endif
    doit(RLIMIT_NOFILE);
#ifdef   RLIMIT_NPROC
    doit(RLIMIT_NPROC);
#endif
#ifdef   RLIMIT_RSS
    doit(RLIMIT_RSS);
#endif
#ifdef   RLIMIT_SBSIZE
    doit(RLIMIT_SBSIZE);
#endif
    doit(RLIMIT_STACK);
#ifdef   RLIMIT_VMEM
    doit(RLIMIT_VMEM);
#endif

    exit(0);
}



相关文章推荐

读书笔记-APUE第三版-(7)进程环境

本章关注单进程运行环境:启动&终止、参数传递和内存布局等。 进程启动终止 如图所示: 启动:内核通过exec函数执行程序,在main函数运行之前,会调用启动例程(start-...
  • cargogo
  • cargogo
  • 2014年05月06日 13:24
  • 1566

APUE笔记---第七章 进程环境

APUE笔记—第7章 进程环境1. main函数C程序的总是从main函数开始执行。main函数的原型:int main(int argc, char *argv[]) 参数argc是命令行参数的数目...
  • men_wen
  • men_wen
  • 2016年11月05日 18:52
  • 319

(APUE读书笔记)进程环境

进程环境 一. main()函数   当内核执行C程序时(使用一个exec函数),在调用main前先调用一个特殊的启动例程。可执行程序文件将此启动例程指定为程序的起始地址——这是由连接编辑器设置...

APUE学习笔记——进程环境

在main中调用exit(1)和reutrn 1是等价的。内核启动一个进程的唯一的方法是调用exec,用户程序终止进程的唯一方法是显示或者隐式的调用_exit或者_EXIT。每个进程都会有一个进程表。...

APUE学习笔记5——第七章——进程环境

APUE学习笔记5——第七章——进程环境

《APUE》笔记-第七章-进程环境

1.引言 重要知识:命令行参数、环境变量(环境指针、环境表、环境字符串)、进程终止方式、c程序的启动和终止、c程序的存储空间布局、setjmp、longjmp、进程资源限制 2.main函数 int ...

APUE第7章 UNIX进程环境 笔记

1.五种方式使进程终止 正常: return
  • mct123
  • mct123
  • 2014年08月14日 16:52
  • 391

APUE学习笔记——第七章 进程环境

1、main函数 原型:int main(int argc, char *argv[])  其中argc是命令行参数的数目,argv是指向参数的各个指针构成的数组。 main函数的命令行参数代码如...

APUE函数笔记十一: 守护进程

第十三章  守护进程: #include void openlog(const char * ident, int option, int facility); void syslog(int...

APUE函数笔记十五: 高级进程间通信(部分)

第十七章  高级进程间通信(部分): #include int fattach(int filedes, const char * path); if success return 0, ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:APUE函数笔记五: 进程环境
举报原因:
原因补充:

(最多只允许输入30个字)