Linux 内核源代码情景分析（一）（上）

// include/asm-i386/io.h
extern inline void * ioremap (unsigned long offset, unsigned long size)
{
  return __ioremap(offset, size, 0);
}

// arch/i386/mm/ioremap.c
/*
 * Remap an arbitrary physical address space into the kernel virtual
 * address space. Needed when the kernel wants to access high addresses
 * directly.
 *
 * NOTE! We need to allow non-page-aligned mappings too: we will obviously
 * have to convert them into an offset in a page-aligned mapping, but the
 * caller shouldn't need to know that small detail.
 */
void * __ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags)
{
  void * addr;
  struct vm_struct * area;
  unsigned long offset, last_addr;

  /* Don't allow wraparound or zero size */
  last_addr = phys_addr + size - 1;
  if (!size || last_addr < phys_addr)
    return NULL;

  /*
   * Don't remap the low PCI/ISA area, it's always mapped..
   */
  if (phys_addr >= 0xA0000 && last_addr < 0x100000)
    return phys_to_virt(phys_addr);

  /*
   * Don't allow anybody to remap normal RAM that we're using..
   */
  if (phys_addr < virt_to_phys(high_memory)) {
    char *t_addr, *t_end;
    struct page *page;

    t_addr = __va(phys_addr);
    t_end = t_addr + (size - 1);
     
    for(page = virt_to_page(t_addr); page <= virt_to_page(t_end); page++)
      if(!PageReserved(page))
        return NULL;
  }

  /*
   * Mappings have to be page-aligned
   */
  offset = phys_addr & ~PAGE_MASK;
  phys_addr &= PAGE_MASK;
  size = PAGE_ALIGN(last_addr) - phys_addr;

  /*
   * Ok, go for it..
   */
  area = get_vm_area(size, VM_IOREMAP);
  if (!area)
    return NULL;
  addr = area->addr;
  if (remap_area_pages(VMALLOC_VMADDR(addr), phys_addr, size, flags)) {
    vfree(addr);
    return NULL;
  }
  return (void *) (offset + (char *)addr);
}

// mm/vmalloc.c
struct vm_struct * get_vm_area(unsigned long size, unsigned long flags)
{
  unsigned long addr;
  struct vm_struct **p, *tmp, *area;

  area = (struct vm_struct *) kmalloc(sizeof(*area), GFP_KERNEL);
  if (!area)
    return NULL;
  size += PAGE_SIZE;
  addr = VMALLOC_START;
  write_lock(&vmlist_lock);
  for (p = &vmlist; (tmp = *p) ; p = &tmp->next) {
    if ((size + addr) < addr) {
      write_unlock(&vmlist_lock);
      kfree(area);
      return NULL;
    }
    if (size + addr < (unsigned long) tmp->addr)
      break;
    addr = tmp->size + (unsigned long) tmp->addr;
    if (addr > VMALLOC_END-size) {
      write_unlock(&vmlist_lock);
      kfree(area);
      return NULL;
    }
  }
  area->flags = flags;
  area->addr = (void *)addr;
  area->size = size;
  area->next = *p;
  *p = area;
  write_unlock(&vmlist_lock);
  return area;
}

// include/linux/vmalloc.h
struct vm_struct {
  unsigned long flags;
  void * addr;
  unsigned long size;
  struct vm_struct * next;
};

// include/asm-i386/pgtable.h
/* Just any arbitrary offset to the start of the vmalloc VM area: the
 * current 8MB value just means that there will be a 8MB "hole" after the
 * physical memory until the kernel virtual memory starts.  That means that
 * any out-of-bounds memory accesses will hopefully be caught.
 * The vmalloc() routines leaves a hole of 4kB between each vmalloced
 * area for the same reason. ;)
 */
#define VMALLOC_OFFSET  (8*1024*1024)
#define VMALLOC_START (((unsigned long) high_memory + 2*VMALLOC_OFFSET-1) & \
            ~(VMALLOC_OFFSET-1))
#define VMALLOC_VMADDR(x) ((unsigned long)(x))
#define VMALLOC_END (FIXADDR_START)

// arch/i386/mm/ioremap.c
static int remap_area_pages(unsigned long address, unsigned long phys_addr,
         unsigned long size, unsigned long flags)
{
  pgd_t * dir;
  unsigned long end = address + size;

  phys_addr -= address;
  dir = pgd_offset(&init_mm, address);
  flush_cache_all();
  if (address >= end)
    BUG();
  do {
    pmd_t *pmd;
    pmd = pmd_alloc_kernel(dir, address);
    if (!pmd)
      return -ENOMEM;
    if (remap_area_pmd(pmd, address, end - address,
           phys_addr + address, flags))
      return -ENOMEM;
    address = (address + PGDIR_SIZE) & PGDIR_MASK;
    dir++;
  } while (address && (address < end));
  flush_tlb_all();
  return 0;
}

// arch/i386/mm/ioremap.c
static inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
  unsigned long phys_addr, unsigned long flags)
{
  unsigned long end;

  address &= ~PMD_MASK;
  end = address + size;
  if (end > PMD_SIZE)
    end = PMD_SIZE;
  if (address >= end)
    BUG();
  do {
    if (!pte_none(*pte)) {
      printk("remap_area_pte: page already exists\n");
      BUG();
    }
    set_pte(pte, mk_pte_phys(phys_addr, __pgprot(_PAGE_PRESENT | _PAGE_RW | 
          _PAGE_DIRTY | _PAGE_DIRTY  | flags)));
    address += PAGE_SIZE;
    phys_addr += PAGE_SIZE;
    pte++;
  } while (address && (address < end));
}

// include/linux/irq.h
/*
 * Interrupt controller descriptor. This is all we need
 * to describe about the low-level hardware. 
 */
struct hw_interrupt_type {
  const char * typename;
  unsigned int (*startup)(unsigned int irq);
  void (*shutdown)(unsigned int irq);
  void (*enable)(unsigned int irq);
  void (*disable)(unsigned int irq);
  void (*ack)(unsigned int irq);
  void (*end)(unsigned int irq);
  void (*set_affinity)(unsigned int irq, unsigned long mask);
};

typedef struct hw_interrupt_type  hw_irq_controller;

/*
 * This is the "IRQ descriptor", which contains various information
 * about the irq, including what kind of hardware handling it has,
 * whether it is disabled etc etc.
 *
 * Pad this out to 32 bytes for cache and indexing reasons.
 */
typedef struct {
  unsigned int status;    /* IRQ status */
  hw_irq_controller *handler;
  struct irqaction *action; /* IRQ action list */
  unsigned int depth;   /* nested irq disables */
  spinlock_t lock;
} ____cacheline_aligned irq_desc_t;

extern irq_desc_t irq_desc [NR_IRQS];

// include/linux/interrupt.h
struct irqaction {
  void (*handler)(int, void *, struct pt_regs *);
  unsigned long flags;
  unsigned long mask;
  const char *name;
  void *dev_id;
  struct irqaction *next;
};

// arch/i386/kernel/irq.c
/**
 *  request_irq - allocate an interrupt line
 *  @irq: Interrupt line to allocate
 *  @handler: Function to be called when the IRQ occurs
 *  @irqflags: Interrupt type flags
 *  @devname: An ascii name for the claiming device
 *  @dev_id: A cookie passed back to the handler function
 *
 *  This call allocates interrupt resources and enables the
 *  interrupt line and IRQ handling. From the point this
 *  call is made your handler function may be invoked. Since
 *  your handler function must clear any interrupt the board 
 *  raises, you must take care both to initialise your hardware
 *  and to set up the interrupt handler in the right order.
 *
 *  Dev_id must be globally unique. Normally the address of the
 *  device data structure is used as the cookie. Since the handler
 *  receives this value it makes sense to use it.
 *
 *  If your interrupt is shared you must pass a non NULL dev_id
 *  as this is required when freeing the interrupt.
 *
 *  Flags:
 *
 *  SA_SHIRQ    Interrupt is shared
 *
 *  SA_INTERRUPT    Disable local interrupts while processing
 *
 *  SA_SAMPLE_RANDOM  The interrupt can be used for entropy
 *
 */
 
int request_irq(unsigned int irq, 
    void (*handler)(int, void *, struct pt_regs *),
    unsigned long irqflags, 
    const char * devname,
    void *dev_id)
{
  int retval;
  struct irqaction * action;

#if 1
  /*
   * Sanity-check: shared interrupts should REALLY pass in
   * a real dev-ID, otherwise we'll have trouble later trying
   * to figure out which interrupt is which (messes up the
   * interrupt freeing logic etc).
   */
  if (irqflags & SA_SHIRQ) {
    if (!dev_id)
      printk("Bad boy: %s (at 0x%x) called us without a dev_id!\n", devname, (&irq)[-1]);
  }
#endif

  if (irq >= NR_IRQS)
    return -EINVAL;
  if (!handler)
    return -EINVAL;

  action = (struct irqaction *)
      kmalloc(sizeof(struct irqaction), GFP_KERNEL);
  if (!action)
    return -ENOMEM;

  action->handler = handler;
  action->flags = irqflags;
  action->mask = 0;
  action->name = devname;
  action->next = NULL;
  action->dev_id = dev_id;

  retval = setup_irq(irq, action);
  if (retval)
    kfree(action);
  return retval;
}

/* this was setup_x86_irq but it seems pretty generic */
int setup_irq(unsigned int irq, struct irqaction * new)
{
  int shared = 0;
  unsigned long flags;
  struct irqaction *old, **p;
  irq_desc_t *desc = irq_desc + irq;

  /*
   * Some drivers like serial.c use request_irq() heavily,
   * so we have to be careful not to interfere with a
   * running system.
   */
  if (new->flags & SA_SAMPLE_RANDOM) {
    /*
     * This function might sleep, we want to call it first,
     * outside of the atomic block.
     * Yes, this might clear the entropy pool if the wrong
     * driver is attempted to be loaded, without actually
     * installing a new handler, but is this really a problem,
     * only the sysadmin is able to do this.
     */
    rand_initialize_irq(irq);
  }

  /*
   * The following block of code has to be executed atomically
   */
  spin_lock_irqsave(&desc->lock,flags);
  p = &desc->action;
  if ((old = *p) != NULL) {
    /* Can't share interrupts unless both agree to */
    if (!(old->flags & new->flags & SA_SHIRQ)) {
      spin_unlock_irqrestore(&desc->lock,flags);
      return -EBUSY;
    }

    /* add new interrupt at end of irq queue */
    do {
      p = &old->next;
      old = *p;
    } while (old);
    shared = 1;
  }

  *p = new;

  if (!shared) {
    desc->depth = 0;
    desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
    desc->handler->startup(irq);
  }
  spin_unlock_irqrestore(&desc->lock,flags);

  register_irq_proc(irq);
  return 0;
}