Для чего нужен System.map ?

Можно вычислить сообщения в System.map по дате. Команда ps l использует System.map для определения WCHAN. Сам System.map может быть размещен как в /boot/System.map,так и в /usr/src/linux/System.map.

likely() и unlikely()

Для чего они нужны ?

В коде ядра часто можно встретить вызовы likely() и unlikely(), типа :

bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx);
 if (unlikely(!bvl)) {
   mempool_free(bio, bio_pool);
   bio = NULL;
   goto out;
 }
 

Фактически,это наводка компилятору для оптимизации. Определение этих макросов можно найти в include/linux/compiler.h :

#define likely(x)       __builtin_expect(!!(x), 1)
 #define unlikely(x)     __builtin_expect(!!(x), 0)
 

В документации так описана роль __builtin_expect() :

 -- Built-in Function: long __builtin_expect (long EXP, long C)
      You may use `__builtin_expect' to provide the compiler with branch
      prediction information.  In general, you should prefer to use
      actual profile feedback for this (`-fprofile-arcs'), as
      programmers are notoriously bad at predicting how their programs
      actually perform.  However, there are applications in which this
      data is hard to collect.
 
      The return value is the value of EXP, which should be an integral
      expression.  The value of C must be a compile-time constant.  The
      semantics of the built-in are that it is expected that EXP == C.
      For example:
 
           if (__builtin_expect (x, 0))
             foo ();
 
      would indicate that we do not expect to call `foo', since we
      expect `x' to be zero.  Since you are limited to integral
      expressions for EXP, you should use constructions such as
 
           if (__builtin_expect (ptr != NULL, 1))
             error ();
 
      when testing pointer or floating-point values.
 

Что это за оптимизация такая ?

Оптимизация проходит на уровне генерации ассемблерного кода. Например,будут удалены все инструкции типа jmp.

Давайте откомпилируем следующий кусок C-кода пользовательской программы с опцией компилятора gcc -O2 :

#define likely(x)    __builtin_expect(!!(x), 1)
 #define unlikely(x)  __builtin_expect(!!(x), 0)
 
 int main(char *argv[], int argc)
 {
    int a;
 
    /* Get the value from somewhere GCC can't optimize */
    a = atoi (argv[1]);
 
    if (unlikely (a == 2))
       a++;
    else
       a--;
 
    printf ("%d\n", a);
 
    return 0;
 }
 

Теперь сделаем дизассемблинг с помощью objdump -S (комменты мои) :

080483b0 <main>:
  // Prologue
  80483b0:       55                      push   %ebp
  80483b1:       89 e5                   mov    %esp,%ebp
  80483b3:       50                      push   %eax
  80483b4:       50                      push   %eax
  80483b5:       83 e4 f0                and    $0xfffffff0,%esp
  //             Call atoi()
  80483b8:       8b 45 08                mov    0x8(%ebp),%eax
  80483bb:       83 ec 1c                sub    $0x1c,%esp
  80483be:       8b 48 04                mov    0x4(%eax),%ecx
  80483c1:       51                      push   %ecx
  80483c2:       e8 1d ff ff ff          call   80482e4 <atoi@plt>
  80483c7:       83 c4 10                add    $0x10,%esp
  //             Test the value
  80483ca:       83 f8 02                cmp    $0x2,%eax
  //             --------------------------------------------------------
  //             If 'a' equal to 2 (which is unlikely), then jump,
  //             otherwise continue directly, without jump, so that it
  //             doesn't flush the pipeline.
  //             --------------------------------------------------------
  80483cd:       74 12                   je     80483e1 <main+0x31>
  80483cf:       48                      dec    %eax
  //             Call printf
  80483d0:       52                      push   %edx
  80483d1:       52                      push   %edx
  80483d2:       50                      push   %eax
  80483d3:       68 c8 84 04 08          push   $0x80484c8
  80483d8:       e8 f7 fe ff ff          call   80482d4 <printf@plt>
  //             Return 0 and go out.
  80483dd:       31 c0                   xor    %eax,%eax
  80483df:       c9                      leave
  80483e0:       c3                      ret
 

Теперь заменим unlikely() на likely(), откомпилируем по новой, и дизассемблируем опять :

080483b0 <main>:
  //             Prologue
  80483b0:       55                      push   %ebp
  80483b1:       89 e5                   mov    %esp,%ebp
  80483b3:       50                      push   %eax
  80483b4:       50                      push   %eax
  80483b5:       83 e4 f0                and    $0xfffffff0,%esp
  //             Call atoi()
  80483b8:       8b 45 08                mov    0x8(%ebp),%eax
  80483bb:       83 ec 1c                sub    $0x1c,%esp
  80483be:       8b 48 04                mov    0x4(%eax),%ecx
  80483c1:       51                      push   %ecx
  80483c2:       e8 1d ff ff ff          call   80482e4 <atoi@plt>
  80483c7:       83 c4 10                add    $0x10,%esp
  //             --------------------------------------------------
  //             If 'a' equal 2 (which is likely), we will continue
  //             without branching, so without flusing the pipeline. The
  //             jump only occurs when a != 2, which is unlikely.
  //             ---------------------------------------------------
  80483ca:       83 f8 02                cmp    $0x2,%eax
  80483cd:       75 13                   jne    80483e2 <main+0x32>
  //             Here the a++ incrementation has been optimized by gcc
  80483cf:       b0 03                   mov    $0x3,%al
  //             Call printf()
  80483d1:       52                      push   %edx
  80483d2:       52                      push   %edx
  80483d3:       50                      push   %eax
  80483d4:       68 c8 84 04 08          push   $0x80484c8
  80483d9:       e8 f6 fe ff ff          call   80482d4 <printf@plt>
  //             Return 0 and go out.
  80483de:       31 c0                   xor    %eax,%eax
  80483e0:       c9                      leave
  80483e1:       c3                      ret
 

Preemption

Что такое preemption ?

preemption - способность операционной системы выгрузить или остановить текущую задачу в пользу другой более приоритетной задачи. При этом возможны ограничения со стороны I/O

Linux ?

В линуксе любая пользовательская программа вытесняема: ядро обязательно остановит и переключит ее на другую задачу, используя clock tick. Никакой бесконечный цикл в программе пользователя не способен заблокировать ресурсы процессора полностью.

До версии 2.6 ядро не было preemtible, и это вызывало определенные проблемы при масштабировании. kernel preemption появилось в 2.6 kernels. В опциях конфига теперь появилось CONFIG_PREEMPT. Если CONFIG_PREEMPT enabled, ядро может тормозить все что угодно. Если CONFIG_PREEMPT disabled, возвращается поведение версии 2.4.

Spinlocks и preemption

В версии 2.4 kernels, для одно-процессорных машин, спинлоки были запрещены. Защита от совместного доступа была нужна для мульти-процессорных систем. В версии 2.6, спинлоки разрешены даже для одно-процессорной машины.

Код,который работает под 2.4,может потерпеть фиаско в 2.6, если проблемы совместного доступа к ресурсам решены некорректно.

SyscallTrace

// base modules inclusions 
 #include <linux/init.h>
 #include <linux/module.h>
 
 // for getpid() 
 #include <linux/unistd.h>
 #include <asm/arch/unistd.h>
 
 
 MODULE_LICENSE("GPL"); 
 
 
 extern void* sys_call_table[];
 

int (*original_fork)(struct pt_regs);
 // we define original_fork as a pointer on function w/ the same prototype 
 // as the fork system call. It is meant to store the address of the original 
 // fork function in the kernel while we replace it w/ our own 
 
 int edu_fork(struct pt_regs regs)
 {
   pid_t pid;
   
   // loging the syscall
   printk(KERN_ALERT "[edu]   fork syscall intercepted from %d\n", current->pid); 
 

  // making the call to the original fork syscall
   pid = (*original_fork)(regs);
     
   return pid;
 }
 

static int edu_init(void)
 {
   printk( KERN_ALERT "[edu]   Module successfully loaded\n"); 
   printk( KERN_ALERT "[edu]   Intercepting fork() syscall... "); 
 
   original_fork = sys_call_table[__NR_fork];
   sys_call_table[__NR_fork] = edu_fork;  
 

  printk( KERN_ALERT "done/n"); 
   printk( KERN_ALERT "[edu]   Starting Loging system calls\n"); 
   return 0; 
 }
 
 static void edu_exit(void)
 {
   sys_call_table[__NR_fork] = original_fork;
   printk(KERN_ALERT "[edu]   Stopping loging system calls\n"); 
 }
 

module_init(edu_init); 
 module_exit(edu_exit); 
 

asmlinkage int sys_execve(struct pt_regs regs)
 

struct mystruct { 
     int data ; 
 } ; 
 

struct mystruct { 
     int data ; 
     struct list_head mylist ; 
 } ; 
 

struct mystruct first ; 
 
 first.data = 10 ; 
 first.mylist = LIST_HEAD_INIT(first.mylist) ; 
 

 31 
  32 #define LIST_HEAD_INIT(name) { &(name), &(name) }
  33 
 

struct mystruct second ; 
 
 second.data = 20 ; 
 INIT_LIST_HEAD( & second.mylist ) ; 
 

 37 static inline void INIT_LIST_HEAD(struct list_head *list)
  38 {
  39         list->next = list;
  40         list->prev = list;
  41 }
  42 
 

LIST_HEAD(mylinkedlist) ;
 

 34 #define LIST_HEAD(name) \
  35         struct list_head name = LIST_HEAD_INIT(name)
  36 
 

list_add ( &first , &mylinkedlist ) ; 
 list_add ( &second , &mylinkedlist ) ; 
 

 59 /**
  60  * list_add - add a new entry
  61  * @new: new entry to be added
  62  * @head: list head to add it after
  63  *
  64  * Insert a new entry after the specified head.
  65  * This is good for implementing stacks.
  66  */
  67 static inline void list_add(struct list_head *new, struct list_head *head)
  68 {
  69         __list_add(new, head, head->next);
  70 }
  71 
 

 43 /*
  44  * Insert a new entry between two known consecutive entries.
  45  *
  46  * This is only for internal list manipulation where we know
  47  * the prev/next entries already!
  48  */
  49 static inline void __list_add(struct list_head *new,
  50                               struct list_head *prev,
  51                               struct list_head *next)
  52 {
  53         next->prev = new;
  54         new->next = next;
  55         new->prev = prev;
  56         prev->next = new;
  57 }
  58 
 

328 /**
 329  * list_for_each        -       iterate over a list
 330  * @pos:        the &struct list_head to use as a loop counter.
 331  * @head:       the head for your list.
 332  */
 333 #define list_for_each(pos, head) \
 334         for (pos = (head)->next; prefetch(pos->next), pos != (head); \
 335                 pos = pos->next)
 

struct head_list* position ; 
 list_for_each ( position , & mylinkedlist )  
     { 
          printk ("surfing the linked list next = %p and prev = %p\n" , 
              position->next, 
              position->prev ); 
     } 
 

319 /**
 320  * list_entry - get the struct for this entry
 321  * @ptr:        the &struct list_head pointer.
 322  * @type:       the type of the struct this is embedded in.
 323  * @member:     the name of the list_struct within the struct.
 324  */
 325 #define list_entry(ptr, type, member) \
 326         container_of(ptr, type, member)
 

275 /**
 276  * container_of - cast a member of a structure out to the containing structure
 277  * @ptr:        the pointer to the member.
 278  * @type:       the type of the container struct this is embedded in.
 279  * @member:     the name of the member within the struct.
 280  *
 281  */
 282 #define container_of(ptr, type, member) ({                      \
 283         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
 284         (type *)( (char *)__mptr - offsetof(type,member) );})
 285 
 

17 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 

struct head_list *position = NULL ; 
 struct mystruct  *datastructureptr  = NULL ;  
 list_for_each ( position , & mylinkedlist )  
     { 
          datastructureprt = list_entry ( position, struct mystruct , mylist );
          printk ("data  =  %d\n" , datastructureptr->data ); 
     } 
 

369 /**
 370  * list_for_each_entry  -       iterate over list of given type
 371  * @pos:        the type * to use as a loop counter.
 372  * @head:       the head for your list.
 373  * @member:     the name of the list_struct within the struct.
 374  */
 375 #define list_for_each_entry(pos, head, member)                          \
 376         for (pos = list_entry((head)->next, typeof(*pos), member);      \
 377              prefetch(pos->member.next), &pos->member != (head);        \
 378              pos = list_entry(pos->member.next, typeof(*pos), member))
 379 
 

struct mystruct  *datastructureptr = NULL ;  
 list_for_each_entry ( ptr , & mylinkedlist, )  
     { 
          list_entry ( item , struct mystruct , mylist );
          printk ("data  =  %d\n" , datastructureptr->data ); 
     } 
 

static inline struct task_struct * get_current(void)
 {
         struct task_struct *current;
         __asm__("andl %%esp,%0; ":"=r" (current) : "0" (~8191UL));
         return current;
 }
 

        __asm__(
 

        "andl %%esp,%0
 

        ; "
 

        :"=r" (current)
 

        : "0" (~8191UL));