原创 设备驱动程序中的一些具体问题及main.c函数分析

__setup("root=", root_dev_setup);

static int __init checksetup(char *line)
{
 struct kernel_param *p;

 p = &__setup_start;
 do {
  int n = strlen(p->str);
  if (!strncmp(line,p->str,n)) {
   if (p->setup_func(line+n))
    return 1;
  }
  p++;
 } while (p < &__setup_end);
 return 0;
}

/* this should be approx 2 Bo*oMips to start (note initial shift), and will
   still work even if initially too large, it will just take slightly longer */
unsigned long loops_per_jiffy = (1<<12);

/* This is the number of bits of precision for the loops_per_jiffy.  Each
   bit takes on average 1.5/HZ seconds.  This (like the original) is a little
   better than 1% */
#define LPS_PREC 8

void __init calibrate_delay(void)
{
 unsigned long ticks, loopbit;
 int lps_precision = LPS_PREC;

 loops_per_jiffy = (1<<12);

 printk("Calibrating delay loop... ");
 while (loops_per_jiffy <<= 1) {
  /* wait for "start of" clock tick */
  ticks = jiffies;
  while (ticks == jiffies)
   /* nothing */;
  /* Go .. */
  ticks = jiffies;
  __delay(loops_per_jiffy);
  ticks = jiffies - ticks;
  if (ticks)
   break;
 }

/* Do a binary approximation to get loops_per_jiffy set to equal one clock
   (up to lps_precision bits) */
 loops_per_jiffy >>= 1;
 loopbit = loops_per_jiffy;
 while ( lps_precision-- && (loopbit >>= 1) ) {
  loops_per_jiffy |= loopbit;
  ticks = jiffies;
  while (ticks == jiffies);
  ticks = jiffies;
  __delay(loops_per_jiffy);
  if (jiffies != ticks) /* longer than 1 tick */
   loops_per_jiffy &= ~loopbit;
 }

/* Round the value and print it */ 
 printk("%lu.%02lu BogoMIPS\n",
  loops_per_jiffy/(500000/HZ),
  (loops_per_jiffy/(5000/HZ)) % 100);
}

static int __init readonly(char *str)
{
 if (*str)
  return 0;
 root_mountflags |= MS_RDONLY;
 return 1;
}

static int __init readwrite(char *str)
{
 if (*str)
  return 0;
 root_mountflags &= ~MS_RDONLY;
 return 1;
}

static int __init debug_kernel(char *str)
{
 if (*str)
  return 0;
 console_loglevel = 10;
 return 1;
}

static int __init quiet_kernel(char *str)
{
 if (*str)
  return 0;
 console_loglevel = 4;
 return 1;
}

__setup("ro", readonly);
__setup("rw", readwrite);
__setup("debug", debug_kernel);
__setup("quiet", quiet_kernel);

/*
 * This is a simple kernel command line parsing function: it parses
 * the command line, and fills in the arguments/environment to init
 * as appropriate. Any cmd-line option is taken to be an environment
 * variable if it contains the character '='.
 *
 * This routine also checks for options meant for the kernel.
 * These options are not given to init - they are for internal kernel use only.
 */
static void __init parse_options(char *line)
{
 char *next,*quote;
 int args, envs;

 if (!*line)
  return;
 args = 0;
 envs = 1; /* TERM is set to 'linux' by default */
 next = line;
 while ((line = next) != NULL) {
                quote = strchr(line,'"');
                next = strchr(line, ' ');
                while (next != NULL && quote != NULL && quote < next) {
                        /* we found a left quote before the next blank
                         * now we have to find the matching right quote
                         */
                        next = strchr(quote+1, '"');
                        if (next != NULL) {
                                quote = strchr(next+1, '"');
                                next = strchr(next+1, ' ');
                        }
                }
                if (next != NULL)
                        *next++ = 0;
  if (!strncmp(line,"init=",5)) {
   line += 5;
   execute_command = line;
   /* In case LILO is going to boot us with default command line,
    * it prepends "auto" before the whole cmdline which makes
    * the shell think it should execute a script with such name.
    * So we ignore all arguments entered _before_ init=... [MJ]
    */
   args = 0;
   continue;
  }
  if (checksetup(line))
   continue;
  
  /*
   * Then check if it's an environment variable or
   * an option.
   */
  if (strchr(line,'=')) {
   if (envs >= MAX_INIT_ENVS)
    break;
   envp_init[++envs] = line;
  } else {
   if (args >= MAX_INIT_ARGS)
    break;
   if (*line)
    argv_init[++args] = line;
  }
 }
 argv_init[args+1] = NULL;
 envp_init[envs+1] = NULL;
}

extern void setup_arch(char **);
extern void cpu_idle(void);

unsigned long wait_init_idle;

#ifndef CONFIG_SMP

#ifdef CONFIG_X86_LOCAL_APIC
static void __init smp_init(void)
{
 APIC_init_uniprocessor();
}
#else
#define smp_init() do { } while (0)
#endif

#else

/* Called by boot processor to activate the rest. */
static void __init smp_init(void)
{
 /* Get other processors into their bootup holding patterns. */
 smp_boot_cpus();
 wait_init_idle = cpu_online_map;
 clear_bit(current->processor, &wait_init_idle); /* Don't wait on me! */

 smp_threads_ready=1;
 smp_commence();

 /* Wait for the other cpus to set up their idle processes */
 printk("Waiting on wait_init_idle (map = 0x%lx)\n", wait_init_idle);
 while (wait_init_idle) {
  cpu_relax();
  barrier();
 }
 printk("All processors have done init_idle\n");
}

#endif

/*
 * We need to finalize in a non-__init function or else race conditions
 * between the root thread and the init thread may cause start_kernel to
 * be reaped by free_initmem before the root thread has proceeded to
 * cpu_idle.
 */

static void rest_init(void)
{
 kernel_thread(init, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
 unlock_kernel();                                     //解锁内核
 current->need_resched = 1;
  cpu_idle();                                            //表示空闲进程
}

/*
 * Activate the first processor.
 */

asmlinkage void __init start_kernel(void) //程序会从head.s文件跳到start_kernel()这个函数开始执行，__init关键字，加其linux内核会注册一个init，这样会使前面标有这个关键字的程序自动执行，一般为初始化操作
{
 char * command_line;
 unsigned long mempages;
 extern char saved_command_line[];
/*
 * Interrupts are still disabled. Do necessary setups, then
 * enable them
 */
 lock_kernel();                               //linux内核启动后会加入内核中断锁lock_kernel()
 printk(linux_banner);                   //，再打印出相关信息。
 setup_arch(&command_line);      //基本的结构配置，如对2410的寄存器的初始化，寄存器的使能，配置相关的cache,使用的相关命令等。           
 printk("Kernel command line: %s\n", saved_command_line);
 parse_options(command_line);   //为解析command_line对应的启动信息中的noinitrd root="/dev/bon/3" init="/linuxrc" console="ttyS0"
 trap_init();                                    //陷阱初始化
 init_IRQ();                                  //初始化中断
 sched_init();                                 //调用初始化
 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();                             //初始化控制台，通过串口进行连接的控制台
#ifdef CONFIG_MODULES                   //如果配置了MODULES，还要初始化modules,就是初始化注册的那些modules
 init_modules();
#endif
 if (prof_shift) {
  unsigned int size;
  /* only text is profiled */
  prof_len = (unsigned long) &_etext - (unsigned long) &_stext;
  prof_len >>= prof_shift;
  
  size = prof_len * sizeof(unsigned int) + PAGE_SIZE-1;
  prof_buffer = (unsigned int *) alloc_bootmem(size);
 }

 kmem_cache_init();                   //初始化系统cache
 sti();                                          //开中断
 calibrate_delay();                    //同步延时
#ifdef CONFIG_BLK_DEV_INITRD      //检测是否配置了块设备，如果有进行相应配置
 if (initrd_start && !initrd_below_start_ok &&
   initrd_start < min_low_pfn << PAGE_SHIFT) {
  printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "
      "disabling it.\n",initrd_start,min_low_pfn << PAGE_SHIFT);
  initrd_start = 0;
 }
#endif
 mem_init();                                //初始化内存空间
 kmem_cache_sizes_init();          //初始化cache
 pgtable_cache_init();                  //将cache重新映射为页表

#ifdef CONFIG_PERFMON
 perfmon_init();
#endif
 mempages = num_physpages;

 fork_init(mempages);                //系统启动会有1号进程，此处为创建1号进程
 proc_caches_init();                     //对proc目录里的cache进行初始化
 vfs_caches_init(mempages);       //对虚拟文件系统cache进行初始化
 buffer_init(mempages);               //缓存初始化
 page_cache_init(mempages);     //pagecache初始化
#if defined(CONFIG_ARCH_S390)      //如果配置了相应的结构进行初始化
 ccwcache_init();
#endif
 signals_init();                           //内核当中的信号，进行相应的信号初始化
#ifdef CONFIG_PROC_FS                   //是否配置proc文件系统，如果配置进行proc根目录的初始化
 proc_root_init();
#endif
#if defined(CONFIG_SYSVIPC)             //是否配置了文件系统的进程间通信
 ipc_init();                                   //进程间通信相关通信方式的初始化
#endif
 check_bugs();                            //检测错误
 printk("POSIX conformance testing by UNIFIX\n");

 /*
  * We count on the initial thread going ok
  * Like idlers init is an unlocked kernel thread, which will
  * make syscalls (and thus be locked).
  */
 smp_init();                               //多内核处理器的初始化
 rest_init();                               //说明在具体函数体内
}

#ifdef CONFIG_BLK_DEV_INITRD
static int do_linuxrc(void * shell)
{
 static char *argv[] = { "linuxrc", NULL, };

 close(0);close(1);close(2);
 setsid();
 (void) open("/dev/console",O_RDWR,0);
 (void) dup(0);
 (void) dup(0);
 return execve(shell, argv, envp_init);
}

#endif

struct task_struct *child_reaper = &init_task;

static void __init do_initcalls(void)
{
 initcall_t *call;

 call = &__initcall_start;
 do {
  (*call)();
  call++;
 } while (call < &__initcall_end);

 /* Make sure there is no pending stuff from the initcall sequence */
 flush_scheduled_tasks();
}

/*
 * Ok, the machine is now initialized. None of the devices
 * have been touched yet, but the CPU subsystem is up and
 * running, and memory and process management works.
 *
 * Now we can finally start doing some real work..
 */
static void __init do_basic_setup(void)
{

 /*
  * 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;

#if defined(CONFIG_MTRR) /* Do this after SMP initialization */          //是否配置多处理器
/*
 * We should probably create some architecture-dependent "fixup after
 * everything is up" style function where this would belong better
 * than in init/main.c..
 */
 mtrr_init();
#endif

#ifdef CONFIG_SYSCTL                                                                          //是否配置系统控制
 sysctl_init();
#endif

 /*
  * Ok, at this point all CPU's should be initialized, so
  * we can start looking into devices..
  */
#if defined(CONFIG_ARCH_S390)
 s390_init_machine_check();
#endif

#ifdef CONFIG_PCI                     //配置PCI
 pci_init();
#endif
#ifdef CONFIG_SBUS                  //配置系统总线
 sbus_init();
#endif
#if defined(CONFIG_PPC)            //配置powerPC
 ppc_init();
#endif
#ifdef CONFIG_MCA
 mca_init();
#endif
#ifdef CONFIG_ARCH_ACORN
 ecard_init();
#endif
#ifdef CONFIG_ZORRO
 zorro_init();
#endif
#ifdef CONFIG_DIO
 dio_init();
#endif
#ifdef CONFIG_NUBUS
 nubus_init();
#endif
#ifdef CONFIG_ISAPNP
 isapnp_init();
#endif
#ifdef CONFIG_TC
 tc_init();
#endif

 /* Networking initialization needs a process context */
 sock_init();                            //网络相关初始化

 start_context_thread();           //启动基本的内核线程
 do_initcalls();                        //对加了__int关键字的函数进行全部调用，并进行初始化

#ifdef CONFIG_IRDA                       //是否定义红外接口
 irda_proto_init();
 irda_device_init(); /* Must be done after protocol initialization */
#endif
#ifdef CONFIG_PCMCIA                  //是否定义PCMCIA卡
 init_pcmcia_ds();  /* Do this last */
#endif
}

extern void rd_load(void);
extern void initrd_load(void);

/*
 * Prepare the namespace - decide what/where to mount, load ramdisks, etc.
 */
static void prepare_namespace(void)
{
#ifdef CONFIG_BLK_DEV_INITRD
 int real_root_mountflags = root_mountflags;
 if (!initrd_start)
  mount_initrd = 0;
 if (mount_initrd)
  root_mountflags &= ~MS_RDONLY;
 real_root_dev = ROOT_DEV;
#endif

#ifdef CONFIG_BLK_DEV_RAM
#ifdef CONFIG_BLK_DEV_INITRD
 if (mount_initrd)
  initrd_load();
 else
#endif
 rd_load();
#endif

 /* Mount the root filesystem.. */
 mount_root();

 mount_devfs_fs ();

#ifdef CONFIG_BLK_DEV_INITRD
 root_mountflags = real_root_mountflags;
 if (mount_initrd && ROOT_DEV != real_root_dev
     && MAJOR(ROOT_DEV) == RAMDISK_MAJOR && MINOR(ROOT_DEV) == 0) {
  int error;
  int i, pid;

  pid = kernel_thread(do_linuxrc, "/linuxrc", SIGCHLD);
  if (pid > 0) {
   while (pid != wait(&i)) {
    current->policy |= SCHED_YIELD;
    schedule();
   }
  }
  if (MAJOR(real_root_dev) != RAMDISK_MAJOR
       || MINOR(real_root_dev) != 0) {
   error = change_root(real_root_dev,"/initrd");
   if (error)
    printk(KERN_ERR "Change root to /initrd: "
        "error %d\n",error);
  }
 }
#endif
}

static int init(void * unused)
{
 lock_kernel();                                   //内核加锁
 do_basic_setup();                          //做基本的配置，在具体函数体内

 prepare_namespace();                   //解析名字空间

 /*
  * 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..
  */
 free_initmem();            //释放初始化内存空间，最初启动时要开辟内存空间，进行初始化，做完后要释放这段内存空间
 unlock_kernel();              //解锁内核
 if (open("/dev/console", O_RDWR, 0) < 0)                            //打开控制台串口程序
  printk("Warning: unable to open an initial console.\n");    //如果出错提示

 (void) dup(0);
 (void) dup(0);
 
 /*
  * 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)                                                        //如果有执行命令，执行最初的进程
  execve(execute_command,argv_init,envp_init);        //到此就将init进程执行起来了，会调用/bin或是/sbin下的init进程进程创建后
 execve("/sbin/init",argv_init,envp_init);                              //只是一个外壳，还执行起来，这4个的相关内容全部执行一遍，sbin的优
 execve("/etc/init",argv_init,envp_init);                               //先级最高，/bin/sh里的shell程序启动后会自动进入init进程
 execve("/bin/init",argv_init,envp_init);
 execve("/bin/sh",argv_init,envp_init);
 panic("No init found.  Try passing init= option to kernel.");
}