linux启动过程

lhui_ch

v\:* {behavior:url(#default#VML);}
o\:* {behavior:url(#default#VML);}
w\:* {behavior:url(#default#VML);}
.shape {behavior:url(#default#VML);}

  Normal
  0
  
  7.8 磅
  0
  2
  
  false
  false
  false
  
   
   
   
   
   
   
   
   
   
   
   
   
  
  MicrosoftInternetExplorer4



/* Style Definitions */
table.MsoNormalTable
        {mso-style-name:普通表格;
        mso-tstyle-rowband-size:0;
        mso-tstyle-colband-size:0;
        mso-style-noshow:yes;
        mso-style-parent:"";
        mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
        mso-para-margin:0cm;
        mso-para-margin-bottom:.0001pt;
        mso-pagination:widow-orphan;
        font-size:10.0pt;
        font-family:"Times New Roman";
        mso-fareast-font-family:"Times New Roman";
        mso-ansi-language:#0400;
        mso-fareast-language:#0400;
        mso-bidi-language:#0400;}


  

Liunx 启动的过程：
1上电
2硬件将bootloader的第一段载入内存，跳到入口
3bootloader的第一段将第二段载入内存，跳到第二段的入口
3bootloader第二段运行，进行一定的初始化，为加载内核做好准备
4加载内核自引导块到内存，加载内核的其他部分到内存，跳到内核的自引导块入口
5自引导块运行，一般是steup()函数
6setup函数运行完后，跳到startup_32入口      linux/arch/arm/boot/compressed/head.S
7starup_32()解压内核，并跳到内核入口
/*
*
linux/arch/arm/boot/compressed/head.S
#include
#include

/*
*
Debugging stuff
*
*
Note that these macros must not contain any code which is not
*
100% relocatable.  Any attempt to do so
will result in a crash.
*
Please select one of the following when turning on debugging.
*/
#ifdef DEBUG


#include

              .macro    writeb,    ch,
rb
              senduart
\ch, \rb
              .endm

#if defined
…………..
#elif defined(CONFIG_ARCH_S3C2410)
              .macro
loadsp, rb
              mov \rb, #0x50000000
              add  \rb, \rb, #0x4000 *
CONFIG_S3C2410_LOWLEVEL_UART_PORT
              .endm
#else
              .macro    loadsp,    rb
              addruart
\rb
              .endm
#endif
#endif
#endif

              .macro    kputc,val
              mov r0, \val
              bl     putc
              .endm

              .macro    kphex,val,len
              mov r0, \val
              mov r1, #\len
              bl     phex
              .endm

              .macro    debug_reloc_start
#ifdef DEBUG
              kputc      #'\n'
              kphex      r6, 8              /*
processor id */
              kputc      #':'
              kphex      r7, 8              /*
architecture id */
              kputc      #':'
              mrc p15, 0, r0, c1, c0
              kphex      r0, 8              /*
control reg */
              kputc      #'\n'
              kphex      r5, 8              /* decompressed kernel start */
              kputc      #'-'
              kphex      r8, 8              /* decompressed kernel end  */
              kputc      #'>'
              kphex      r4, 8              /*
kernel execution address */
              kputc      #'\n'
#endif
              .endm

              .macro    debug_reloc_end
#ifdef DEBUG
              kphex      r5, 8              /*
end of kernel */
              kputc      #'\n'
              mov r0, r4
              bl     memdump             /*
dump 256 bytes at start of kernel */
#endif
              .endm

              .section
".start", #alloc, #execinstr
/*
*
sort out different calling conventions
*/
              .align
start:
              .type       start,#function
              .rept 8
              mov r0, r0
              .endr

              b     1f
              .word      0x016f2818           @ Magic numbers to help the loader
              .word      start               @ absolute load/run zImage
address
              .word      _edata                   @ zImage end address
1:            mov r7, r1                    @ save architecture ID
              mov r8, #0                    @ save r0
…………………………………….
              bl     decompress_kernel

              add  r0, r0, #127
              bic   r0, r0, #127           @
align the kernel length
/*
* r0   
= decompressed kernel length
* r1-r3
= unused
* r4   
= kernel execution address
* r5   
= decompressed kernel start
* r6   
= processor ID
* r7   
= architecture ID
* r8-r14 = unused
*/
              add  r1, r5, r0        @ end of decompressed kernel
              adr   r2, reloc_start
              ldr   r3, LC1
              add  r3, r2, r3
1:            ldmia       r2!, {r8 - r13}              @ copy relocation code
              stmia       r1!, {r8 - r13}
              ldmia       r2!, {r8 - r13}
              stmia       r1!, {r8 - r13}
              cmp r2, r3
              blo   1b

              bl     cache_clean_flush
              add  pc, r5, r0        @
call relocation code

/*
*
We're not in danger of overwriting ourselves.
Do this the simple way.
*
*
r4     = kernel execution address
*
r7     = architecture ID
*/
wont_overwrite:     mov r0, r4
              mov r3, r7
              bl     decompress_kernel
              b     call_kernel

* All code following this line is
relocatable.  It is relocated by
*
the above code to the end of the decompressed kernel image and
*
executed there.  During this time, we
have no stacks.
*
* r0     = decompressed
kernel length
* r1-r3
= unused
* r4   
= kernel execution address
* r5   
= decompressed kernel start
* r6     = processor ID
* r7   
= architecture ID
*
r8-r14 = unused
*/
              .align       5
reloc_start:     add  r8, r5, r0
              debug_reloc_start
              mov r1, r4
1:
              .rept 4
              ldmia       r5!, {r0, r2, r3, r9 - r13}      @ relocate kernel
              stmia       r1!, {r0, r2, r3, r9 - r13}
              .endr

              cmp r5, r8
              blo   1b
              debug_reloc_end

call_kernel:     bl     cache_clean_flush
              bl     cache_off
              mov r0, #0
              mov r1, r7                    @
restore architecture number
              mov pc, r4                    @
call kernel
……………………………………….
/*
*
Here follow the relocatable cache support functions for the
*
various processors.  This is a generic
hook for locating an
*
entry and jumping to an instruction at the specified offset
*
from the start of the block.  Please note
this is all position
*
independent code.
*
………………………………

reloc_end:

              .align
              .section
".stack", "w"
user_stack:     .space     4096
8从内核入口开始执行，被执行的函数名startup_32()
startup_32()为创建第一个内核线程做准备，然后跳到函数start_kernel()的入口
9start_kernel()开始运行源代码如下,这个过程比较复杂，主要是内核的初始化工作
在linux/init/main.c中
asmlinkage void __init start_kernel(void)
{
       char * command_line;            内核命令行
       extern
struct kernel_param __start___param[], __stop___param[];
/*
* Interrupts are still disabled. Do necessary
setups, then
* enable them
*/关闭中断
       lock_kernel();
       page_address_init();
       printk(KERN_NOTICE);
       printk(linux_banner);
       setup_arch(&command_line);          /解释bootloader传递过来的参数
       setup_per_cpu_areas();

       /*
        * Mark the boot cpu "online" so that
it can call console drivers in
        * printk() and can access its per-cpu storage.
        */
       smp_prepare_boot_cpu();

       /*
        * Set up the scheduler prior starting any
interrupts (such as the
        * timer interrupt). Full topology setup happens
at smp_init()
        * time - but meanwhile we still have a
functioning scheduler.
        */
       sched_init();   
       /*
        * Disable preemption - early bootup scheduling
is extremely
        * fragile until we cpu_idle() for the first
time.
        */
preempt_disable();
  关闭preempting ,在bootup阶段的进程轮询是很脆弱的，直到cpu_idle进程建立
       build_all_zonelists();
       page_alloc_init();
       printk(KERN_NOTICE
"Kernel command line: %s\n", saved_command_line);
       parse_early_param();
       parse_args("Booting
kernel", command_line, __start___param,
                 __stop___param - __start___param,
                 &unknown_bootoption);
       sort_main_extable();
       trap_init();
       rcu_init();
       init_IRQ();
       pidhash_init();
       init_timers();
       softirq_init();
       time_init();

       /*
        * HACK ALERT! This is early. We're enabling
the console before
        * we've done PCI setups etc, and
console_init() must be aware of
        * this. But we do want output early, in case
something goes wrong.
        */
       console_init();           
输出终端初始化
       if
(panic_later)
              panic(panic_later,
panic_param);
       profile_init();
       local_irq_enable();
#ifdef CONFIG_BLK_DEV_INITRD
       if
(initrd_start && !initrd_below_start_ok &&
                     initrd_start
              printk(KERN_CRIT
"initrd overwritten (0x%08lx
                  "disabling
it.\n",initrd_start,min_low_pfn
              initrd_start
= 0;
       }
#endif
       vfs_caches_init_early();                     vfs_caches_init_early(void)
{
       dcache_init_early();
       inode_init_early();                   * Initialize the waitqueues
and inode hash table.
}
       mem_init();
       kmem_cache_init();
       setup_per_cpu_pageset();
       numa_policy_init();
       if
(late_time_init)
              late_time_init();
       calibrate_delay();
       pidmap_init();
       pgtable_cache_init();
       prio_tree_init();
       anon_vma_init();
#ifdef CONFIG_X86
       if
(efi_enabled)
              efi_enter_virtual_mode();
#endif
       fork_init(num_physpages);
       proc_caches_init();
       buffer_init();
       unnamed_dev_init();
       key_init();
       security_init();
       vfs_caches_init(num_physpages);      vfs_caches 初始化
       radix_tree_init();
       signals_init();
       /*
rootfs populating might need page-writeback */
       page_writeback_init();
#ifdef CONFIG_PROC_FS
       proc_root_init();
proc_root_init(void)
{
       int err = proc_init_inodecache();
       if (err)
              return;
       err =
register_filesystem(&proc_fs_type);  
/注册文件系统
       if (err)
              return;
       proc_mnt = kern_mount(&proc_fs_type);    /挂载文件系统
       err = PTR_ERR(proc_mnt);
       if (IS_ERR(proc_mnt)) {
              unregister_filesystem(&proc_fs_type);
              return;。。。。。。。。。。。。。。。。。。。

#endif
       cpuset_init();

       check_bugs();

       acpi_early_init();
/* before LAPIC and SMP init */

       /*
Do the rest non-__init'ed, we're now alive */
       rest_init();
}
其中最后一步要执行的是Rest_init()的源代码如下，主要是创建线程1 init,
static void noinline rest_init(void)
       __releases(kernel_lock)
{
       kernel_thread(init, NULL, CLONE_FS | CLONE_SIGHAND);
       numa_default_policy();
       unlock_kernel();   开启时间中断

       /*
        * The boot idle thread must execute schedule()
        * at least one to get things moving:
        */
       preempt_enable_no_resched();
       schedule();         进程调度函数开始运行
       preempt_disable();   

       /*
Call into cpu_idle with preempt disabled */
       cpu_idle();   cpu_idle运行
}

Init的源代码：init内核线程主要是挂载根文件系统，设备驱动初始化，启动用户级进程init在目录sbin/init             /etc/init                 /bin/init之一

static int init(void * unused)
{
       lock_kernel();         
关闭时间中断
       /*
        * init can run on any cpu.
        */
       set_cpus_allowed(current,
CPU_MASK_ALL)
       /*
        * Tell the world that we're going to be the
grim
        * reaper of innocent orphaned children.
        *
        * We don't want people to have to make
incorrect
        * assumptions about where in the task array
this
        * can be found.
        */
       child_reaper
= current;

       /*
Sets up cpus_possible() */
       smp_prepare_cpus(max_cpus);

       do_pre_smp_initcalls();

       fixup_cpu_present_map();
       smp_init();
       sched_init_smp();

       cpuset_init_smp();

       /*
        * Do this before initcalls, because some
drivers want to access
        * firmware files.                       有一部分驱动需要从文件系统加载，在初始化驱动以前应该先把文件系统建立起来，虽然只是一个临时的内存文件系统，有了这部分，就能够加载大部分的驱动，进行初始化了
        */
       populate_rootfs();         
这个函数用来挂载基于内存的文件系统 initramfs

void __init
populate_rootfs(void)
{
       char *err =
unpack_to_rootfs(__initramfs_start,
                      __initramfs_end - __initramfs_start, 0);   __initramfs_start
__initramfs_end 是全局变量描述了应该将文件系统解压到哪里
       if (err)
              panic(err);
#ifdef CONFIG_BLK_DEV_INITRD    如果配置的时候选定了使用initrd
       if (initrd_start) {    给出了initrd_start
              int fd;
              err = unpack_to_rootfs((char
*)initrd_start,     解压 initrd  使用的工具是gzip
                     initrd_end - initrd_start,
1);
              if (!err) {
                     printk(" it
is\n");
                     unpack_to_rootfs((char
*)initrd_start,
                            initrd_end -
initrd_start, 0);
                     free_initrd();   如果错误就释放掉这个内存空间，initrd_start 到initrd_end
                     return;
              }
              printk("it isn't (%s); looks
like an initrd\n", err);
              fd =
sys_open("/initrd.image", O_WRONLY|O_CREAT, 700);  打开initrd.image
              if (fd >= 0) {                                         打开正确
                     sys_write(fd, (char
*)initrd_start,
initrd_end - initrd_start);         将initrd_end-initrd_start 这么大的内存内容，从initrd_start指定的地址写到文件fd      
                     sys_close(fd);                        关闭文件
                     free_initrd();                         释放内存
              }
       }
       do_basic_setup();
tatic void __init
do_basic_setup(void)
{




  
  
   
   
   
    /* These are the core pieces */
           devices_init();
           buses_init();
           classes_init();
           firmware_init();
     
           /*
    These are also core pieces, but must come after the
            * core core pieces.
            */
           platform_bus_init();
           system_bus_init();
           cpu_dev_init();
           memory_dev_init();
           attribute_container_init();
   
   
   
  
  
file:///C:/DOCUME%7E1/ADMINI%7E1/LOCALS%7E1/Temp/msohtml1/01/clip_image001.gif
       /* drivers will
send hotplug events */
       init_workqueues();
       usermodehelper_init();
       driver_init();                  初始化设备驱动


file:///C:/DOCUME%7E1/ADMINI%7E1/LOCALS%7E1/Temp/msohtml1/01/clip_image002.gif
#ifdef CONFIG_SYSCTL
       sysctl_init();
#endif

       /* Networking initialization needs a process context */
       sock_init();

       do_initcalls();
}
       /*
        * check if there is an
early userspace init.  If yes, let it do
all
        * the work    看看是否一个用户inti存在，如果存在就让它把所有工作了
        */

       if
(!ramdisk_execute_command)
              ramdisk_execute_command
= “/init”;

       if
(sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
              ramdisk_execute_command
= NULL;
              prepare_namespace();        
挂载rootfs ,其代码如下
mount_devfs();

          if (root_delay) {
              printk(KERN_INFO "Waiting %dsec before mounting
root device...\n",
                    
root_delay);
              ssleep(root_delay);
       }

       md_run_setup();

       if (saved_root_name[0]) {                  bootloader传过来的参数
              root_device_name = saved_root_name;
              ROOT_DEV = name_to_dev_t(root_device_name);
              if (strncmp(root_device_name, "/dev/", 5) ==
0)
                     root_device_name += 5;
       }

       is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR;

       if (initrd_load())
              goto out;

       if (is_floppy && rd_doload && rd_load_disk(0))
              ROOT_DEV = Root_RAM0;

       mount_root();
out:
       umount_devfs("/dev");
       sys_mount(".", "/", NULL, MS_MOVE, NULL);
       sys_chroot(".");
       security_sb_post_mountroot();
       mount_devfs_fs ();
}
       }

       /*
        * Ok, we have completed the initial bootup,
and
        * we're essentially up and running. Get rid of
the
        * initmem segments and start the user-mode
stuff..         完成了initial bootup
        */
       free_initmem();
       unlock_kernel();          开时间中断
       system_state
= SYSTEM_RUNNING;           系统状态运行
       numa_default_policy();

       if
(sys_open((const char __user *) "/dev/console", O_RDWR, 0)
              printk(KERN_WARNING
"Warning: unable to open an initial console.\n"); 打开用户输入终端

       (void)
sys_dup(0);
       (void)
sys_dup(0);

       if
(ramdisk_execute_command) {
              run_init_process(ramdisk_execute_command);
              printk(KERN_WARNING
"Failed to execute %s\n",
                            ramdisk_execute_command);
       }

       /*
        * We try each of these until one succeeds.
        *
        * The Bourne shell can be used instead of init
if we are
        * trying to recover a really broken machine.
        */
       if
(execute_command) {
              run_init_process(execute_command);
              printk(KERN_WARNING
"Failed to execute %s.  Attempting
"
                                   "defaults...\n",
execute_command);
       }
       run_init_process("/sbin/init");     开始调用用户初始化 init 存放目录在
sbin  etc  bin 下
       run_init_process("/etc/init");
       run_init_process("/bin/init");
       run_init_process("/bin/sh");

       panic("No
init found.  Try passing init= option to
kernel.");
}
10init进程的进程号是1，这个进程主要的作用就是进行系统应用程序的初始化，这个进程是所有用户进程的父进程，这个进程就一直运行到关机。
它会根据inittab中的内容依次执行脚本，inittab的内容如下
#
# inittab       This file describes how the INIT process
should set up
#               the system in a certain
run-level.
#
# Author:       Miquel van Smoorenburg,
#               Modified for RHS Linux by Marc
Ewing and Donnie Barnes
#

# Default runlevel. The runlevels used by
RHS are:
#   0
- halt (Do NOT set initdefault to this)
#   1
- Single user mode
#   2
- Multiuser, without NFS (The same as 3, if you do not have networking)
#   3
- Full multiuser mode
#   4
- unused
#   5
- X11
#   6
- reboot (Do NOT set initdefault to this)
#
id:5:initdefault:

# System initialization.
si::sysinit:/etc/rc.d/rc.sysinit

l0:0:wait:/etc/rc.d/rc 0
l1:1:wait:/etc/rc.d/rc 1
l2:2:wait:/etc/rc.d/rc 2
l3:3:wait:/etc/rc.d/rc 3
l4:4:wait:/etc/rc.d/rc 4
l5:5:wait:/etc/rc.d/rc 5
l6:6:wait:/etc/rc.d/rc 6

# Trap CTRL-ALT-DELETE
ca::ctrlaltdel:/sbin/shutdown -t3 -r now

# When our UPS tells us power has failed,
assume we have a few minutes
# of power left.  Schedule a shutdown for 2 minutes from now.
# This does, of course, assume you have
powerd installed and your
# UPS connected and working correctly.  
pf::powerfail:/sbin/shutdown -f -h +2
"Power Failure; System Shutting Down"

# If power was restored before the shutdown
kicked in, cancel it.
pr:12345:powerokwait:/sbin/shutdown -c
"Power Restored; Shutdown Cancelled"


# Run gettys in standard runlevels
1:2345:respawn:/sbin/mingetty tty1
2:2345:respawn:/sbin/mingetty tty2
3:2345:respawn:/sbin/mingetty tty3
4:2345:respawn:/sbin/mingetty tty4
5:2345:respawn:/sbin/mingetty tty5
6:2345:respawn:/sbin/mingetty tty6

# Run xdm in runlevel 5
x:5:respawn:/etc/X11/prefdm -nodaemon

init进程将从上到下的读取/etc/inittab文件，只要状态符合当前运行级就会去执行脚本。
inittab由几行组成，每行被三个冒号分隔成四个部分，每个部分具有不同的含义。格式如下：
行标识符：状态：动作：命令
行标识符是你的运行级脚本的名字，不能使用重复的行标识符。
状态是表示运行级脚本何时应该执行的数字。状态由0,1,2,3,4,5,6和S一个或多个数字字母组成。如果状态为空，就是系统启动必须执行的脚本。
下面是slackware的状态定义：
0 = halt
1 = single user mode
2 = unused (but configured the same as
runlevel 3)
3 = multiuser mode (default Slackware
runlevel)
4 = X11 with KDM/GDM/XDM (session managers)
5 = unused (but configured the same as
runlevel 3)
6 = reboot
S同状态1相同。
动作有once, wait,
respawn, sysinit, crtlaltdel, initdefault组成，说明了init执行脚本的方式。
once：init在进入后只执行一次。init不等待命令的结束。
wait：和once不同的是，init等待命令的结束。
respawn：命令结束后会被重起。
sysinit：init最先执行的运行级脚本，状态被忽略。说穿了就是无论何是都优先执行的脚本，应指向系统初始化脚本。
ctrlaltdel：当“三指禅”被按下时，该运行级被启动，一般是指向重启脚本。
initdefault：指定系统启动时的缺省运行级。在sysinit后执行。
对于slackware的inittab：
id：3：initdefault：
id指出缺省为多用户字符界面（3），不要把它设置成0或6！注意没有命令。
si：S：sysinit：/etc/rc.d/rc.S
si指出系统初始化运行级，其中S等同于状态1，它指向/etc/rc.d/rc.S，也就是说init第一个去执行的shell脚本。
rc：2345：wait：/etc/rc.d/rc.M
rc指出多用户启动运行级，当状态为2,3,4,5时被执行，init等待命令的结束，这也是为什么启动时没有shell可用的原因。
c1：1235：respawn：/sbin/agetty 38400 tty1 linux
c1指出控制台1，当它被杀死时init将重启它。它打开一个终端tty1供你使用。
x1：4：wait：/etc/rc.d/rc.4
x1指出多用户GUI运行级，指向脚本rc.4。
rc.S(系统初始化运行级脚本）做的事：
#安装proc文件系统。
#决定是否有需要使用Hotplug自动检测硬件。
#启动devfsd。
#安装devfs。
#为2.6内核启动udev。
#打开交换分区，其中要读取/etc/fstab中获取分区信息。
#检查根分区是否为只读，因为只有只读时才能检查硬盘。
#如有需要检查根分区。
#安装sysfs到/proc/sys。
#设置硬件时钟。
#配置isa设备。
#执行/etc/rc.d/rc.modules (这个文件将剩下的内核模块装入内核，稍后再讲）。
#初始化lvm卷，不要问我为什么。
#检查非根分区。
#安装本地硬盘分区。
#删除临时文件。
#initrd被安装在/initrd中，它用来在内核启动第一时间载入一些内核模块和必需程序（如fsck)等。现在卸载它。
#创建utmp。
#如果你是用的zipslack（一个工作在vfat上的linux套件），配置umsdos。
#把Linux 2.4.27写入你的mtod文件
#执行rc.sysvinit。（不像rh，slackware是一个“叛徒”。它的init脚本结构不像大多数linux套件（基于SVR4），而像BSD,所以只是一个假文件。）
#执行rc.serical。（串口）
#安装随机数种子
rc.modules：
#决定内核版本，到目录”/lib/modules/你的内核版本号/“去寻找模块
#更新内核模块依赖关系。
#装入APM高级管理，它被注释掉了，建议你启用它以正常关机。
#一大堆被注释掉了的硬件模块，如果hotplug找不到你的硬件就到这里来。
rc.S执行完成后，slackware将执行缺省的运行级（3），也就是先执行rc.M（多用户进程级）。
#设置黑屏时间。
#设置主机名，主机名存储在/etc/HOSTNAME里，缺省为darkstar.example.net。
#设置dmesg缓冲区的大小。越多越好。
#执行rc.syslog，打开syslog和klogd。
#执行rc.pcmcia，初始化PCMCIA卡，我不懂。
#执行rc.inet1，设置网络。重点。
#执行rc.hotplug，即插即用。
#执行rc.inet2，网络守护进程。重点。
#把所有的锁文件删掉。
#把黑洞设备和临时目录设成777。
#运行ldconfig，更新共享库，我喜欢关掉。
#更新X字体缓存，关掉吧。不过安了新字体后自己要手动运行一次”fc-cache"而已。
#执行rc.CUPS，UNIX打印守护进程。
#打开appletalk。关了吧。
#打开用户限额。请看/usr/doc/Linux-HowTOs/Quota。
#执行rc.acpid。高级能源管理。
#执行rc.alsa。alsa声音系统。
#执行rc.font。用户自己的字体。
#执行rc.keymap。用户自己的keymap。
#把你的一大堆网络standalone进程打开。
#执行rc.gpm。字符界面上用鼠标。
#又执行rc.sysinit一次。这不是Bug，这是sysinit的特点：sysinit脚本应被放在/etc/rc.d/rcX.d中。
#执行rc.local。最后，执行用户你的自己的配置文件。（用户如果想开机就自动运行程序的话可以在里面添加）
rc.inet1：
#读入另一个脚本文件rc.inet1.conf的变量，里面有网络的基本配置。
#打开lo环回接口。
#打开eth0 eth1 eth3 eth4, 请看eth_up函数，很长。
#如有需要使用无线网卡。
#如有需要使用DHCP。
rc.inet2
#启动rc.portmap，准备安装NFS文件系统
#安装所有smb文件系统
#执行rc.firewall，防火墙脚本。
#执行rc.ip_forward，IP转发脚本，如果你要共享上网，改它。
#一大堆网络服务程序（NFS，BIND，SSH，INETD）
rc.M执行完了，init按照inittab的配置打开终端，它创建若干个agetty进程，这些进程通过系统调用执行login程序，用户密码验证成功后，再执行shell。一天的工作开始了。在这之后，init除了监视运行级的改变外，还干一些副业：收养孤儿进程。
如果你是用的运行级4(多用户GUI运行级)，init就会去执行rc.4，并打开gdm或kdm（Gnome和Kde的登录界面）。
11用户登录
Login会根据用户输入的用户帐号与
/etc/passwd 和/etc/shadow  存放的是用户的帐号和密码进行比对如果正确就启动
并为用户配置好应用环境
很重要的就是/etc/profile  /etc/bashrc
面向所有用户的配置
/root 下的.profile .bashrc            面向root用户的配置
/home/$user/ 下的.profile .bashrc 这些文件关系到用户使用的很多环境变量
面向一般用户的配置
.profile 如果被改变要起作用需要重新登陆，bashrc如果被改变，只要打开终端就会生效



               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u3/94887/showart_1911595.html