Outline: Linux Implementation

• struct device
• device interface
• locking and unlocking

device structure

• to know where to dispatch an interrupt, i.e. to know which interrupt handler to call, Linux keeps an array of interrupt handlers, see arch/i386/kernel/irq.c for details
• Linux also keeps a list of network devices: struct device *dev_base, defined in drivers/net/Space.c
• as far as I can tell, this list does not include disk or other devices
• as far as I can tell, this list is used mainly for writing to the device and for decoding incoming messages
• the list is built at configuration time by providing appropriate #define definitions to the compiler

device structure

• name
• device addresses
• device IRQ (interrupt number)
• pointer to next device (linked list)
• int (*init)(struct device *dev) -- the device initialization function. Called only once.
• device addresses
• ARP information
• buffers

device structure, continued

• int (*open)(struct device *dev);
• int (*stop)(struct device *dev);

• int (*hard_start_xmit)
          (struct sk_buff *skb,
           struct device *dev);
  

• int (*hard_header)
        (struct sk_buff *skb,
         struct device *dev,
         unsigned short type,
         void *daddr,
         void *saddr,
         unsigned len);
  

device structure, continued

• int (*rebuild_header)
       (void *eth,
        struct device *dev,
        unsigned long raddr,
        struct sk_buff *skb);
  

  Rebuild the Ethernet MAC header. Called after an ARP has completed on this sk_buff. ARP fills in the other fields.

• int (*set_mac_address)
       (struct device *dev,
        void *addr);
  

• int (*do_ioctl)
       (struct device *dev,
        struct ifreq *ifr, int cmd);
  

• int (*change_mtu) (struct device *dev,
                     int new_mtu);
  

Locking and Unlocking

/* These two don't currently need to be
 * interrupt-safe but they may soon.
 * Do it properly anyway. */
extern __inline__
void  dev_lock_list(void)
{ unsigned long flags;
  save_flags(flags);
  cli();
  dev_lockct++;
  restore_flags(flags);
}
extern __inline__
void  dev_unlock_list(void)
{ unsigned long flags;
  save_flags(flags);
  cli();
  dev_lockct--;
  restore_flags(flags);
}

In-Class Exercise: test-and-set

Linux scheduler

• kernel/sched.c
• scheduling primitives:
  • sleep_on (put a process onto a wait queue)
  • wake_up_process(struct task_struct * p)
  • clock and timer functions
  • system calls such as getpid
  • load computation
  • asmlinkage void schedule(void): the main scheduler

schedule

• schedule has a set of processes in the runnable queue
• schedule uses a goodness function to determine which thread to run
• goodness gives priority to real-time processes,
• then to processes that have the highest value of counter
• counter is decremented every clcok tick that a process is executing
• when counter reaches zero, the process is placed back into the queue, will not execute again until all runnable processes reach zero counter.
• when all counters have reached zero, all counters are reset to the process priority.

In-Class Exercise: spin lock