AOS - 26 - KERNEL TASK MANAGEMENT V

La struttura della vm_area_struct è la seguente

struct vm_area_struct
{
  // address space we belong to
  struct mm_struct *vm_mm;

  // start address within vm_mm
  unsigned long vm_start;

  // first byte after end address within vm_mm
  unsigned long vm_end;

  // next item in the list
  struct vm_area_struct *vm_next; 

  // access permission of this vma.  
  pgprot_t vm_page_prot;

  // ...

  // function pointers to deal with this struct. Anytime we have to do
  // something regarding this memory segment, we use one of these
  // functions. 
  //
  // For example, during a page fault, the page fault handler will use
  // one of these function to deal with this memory segment.
  struct vm_operations_struct *vm_ops;

  // ...  
};

Graficamente abbiamo il seguente schema

Il namespace basico viene utilizzato per settare il valore di current->pid durante la creazione del thread. Quando creiamo un thread però possiamo anche specificare di muovere il thread creato in un'altro PID namespace, che diventa il PID namespace figlio rispetto al PID namespace in cui il thread è stato inizialmente creato.

Linux offre al più 32 livelli di namespaces.

Ai thread che vengono creati in nuovi namespaces associamo quindi due identificativi:

• un thread_id tradizionale

• un virtual thread_id all'interno del nuovo namespace in cui il thread si andrà a muovere.

Per la creazione di un nuovo namespace necessitiamo di privilegi root.

Molti servizi del kernel, come ad esempio le sleep/wait queues, lavorano utilizzando l'indirizzo di memoria del TCB di un dato thread. Per poter utilizzare questi servizi in modo semplice dobbiamo quindi introdurre dei mappings tra i PIDs e gli indirizzi dei TCB.

In Linux questi mappings sono basati su strutture di hashing, che ci permettono di risalire velocemente all'indirizzo del TCB di un dato thread, dato il PID del thread. In particolare si ha una struttura di hashing per gestire il namespace ancestrale, e poi per ogni nuovo namespace che viene creato esiste una associata struttura di hashing che permette di gestire gli identificatori che vivono in quel namespace.

La libreria glibc offre il seguente prototipo

 int clone(int (*fn)(void *), void *child_stack,
                int flags, void *arg, ...
                /* pid_t *pid,  void *newtls, pid_t *ctid */);

Che in x86-64 diventa

long clone(unsigned long flags, void *child_stack,
           int *ptid, int *ctid,
           unsigned long newtls);

Mentre in x86-32 diventa

long clone(unsigned long flas, void *child_stack,
           int *ptid, unsigned long newtls,
           int *ctid);

I flags principali necessari per la creazione di un nuovo processo/threads sono i seguenti

• CLONE_VM: VM shared between processes.

• CLONE_NEWPID: Create process/thread in a new PID namespace.

• CLONE_THREAD: Child is placed in same thread group as calling process.

La do_fork() farà quindi lavoro differenziato a seconda dei parametri passati. Questi parametri devono specificare le operazioni necessarie per settare il nuovo processo o il nuovo thread. Ad esempio la pthread_create() dovrà dire alla do_fork() che l'address space non deve essere clonato, ma deve essere condiviso con il processo chiamante.

In particolare la funzione do_fork() effettua le seguenti operazioni:

1. Alloca il TCB per il nuovo thread;

2. Alloca la stack area per il nuovo thread;

3. Ottiene il proper PID (real/virtual) per il nuovo thread.

4. Collega alla parent memory map (optional)

5. Collega alla parent FS view (optional)

6. Collega alla parent files view (optional)

7. Condividi una frazione dei ticks del parent.

Notiamo che se dovessimo assegnare ad un child una quantità di tick indipendente da quella del parent, ci sarebbe la possibilità per una applicazione di prendere il controllo della CPU semplicemente continuando a creare nuovi threads.

In questo running example andiamo a risolvere il problema trovato in sleep-wakeup-queue introducendo un ulteriore campo per verificare se un elemento della lista è già stato visto da un altro thread oppure no. Così facendo risolviamo il problema della perdità dei risvegli.

Andiamo poi ad utilizzare il campo tail per mantenere informazioni sia sulla head che sulla tail. Questo ci permette di avere una inserzione alla fine di O(1) e una rimozione dalla lista ammortizzata di O(*1) .

TODO.

Questo running example inserisce una sys call che scorre la vm_area list per vedere se un dato indirizzo logico è valido. Se un indirizzo logico valido viene trovato, la sys call ci dice anche quali sono le permissioni sul blocco di memoria in cui si trova quell'indirizzo.

Da questo running example è possibile notare come x86 non ci permette di distinguere se una zona di memoria è read-only o read/write. Possiamo solo verificare se una zona di memoria è accessibile in modalità read or write, e in modalità exec.

int sys_mm_inspect(unsigned long vaddr, int mode)
{
  struct vm_area_struct *map;
  pgprot_t prot;
  int ret = 0;
  unsigned long mask;

  map = current->mm->mmap;

  while(map != NULL) {
    if((map->vm_start <= vaddr) && ((map->vm_end -1) >= vaddr)) {
      // Found correct block of memory

      printk("%s: target address found in entry for zone [%d, %d]\n", MODNAME, map->vm_start, map->vm_end);

      prot = map->vm_page_prot;
      mask = (unsigned long)pgprot_val(prot);

      switch(mode) {
      case 0:
        printk("%s: read only query\n", MODNAME);
        if( !(mask & 0x2)) ret = 1;
        break;

      case 1:
        printk("%s: read/write query\n", MODNAME);
        if( !(mask & 0x2)) ret = 1;
        break;

      case 2:
        printk("%s: exec query\n", MODNAME);
        // NOTE: 64-th bit of mask is 0 when the memory region is
        // executable.
        if (!mask & 0x8000000000000000) ret = 1;
        break;
      }

      return ret;
    }
    map = map->vm_next;
  }

  return -1;
}

Questo running example installa una nuova system call che prende in input un intero. Se l'intero in input è \(0\), allora la sys call ritorna il pid "reale", ovvero quello che vive nel namespace ancestrale. Altrimenti se l'input è \(1\), la sys call ritorna il pid "virtuale".

char *pr = "REAL";
char *pv = "VIRTUAL";

// NOTE: This example shows that when we run in kernel mode we can do
// anything we want with the namespace architecture. We can even see
// informations that we shoulnd't have access to.
unsigned ing get_pid_service(int type)
{
  char *p;
  unsigned int the_pid;

  p = type? pv : pr;

  printk("%s: get_pid_service asked to deliver PID type %s\n", MODNAME, p);

  if(type) {
    // get real pid
    //
    // IMPORTANT: moved to pid_allocated in latest kernel versions
    the_pid = current->nspoxy->pid_ns_for_children->last_pid;
  } else {
    // get virtual pid
    the_pid = current->pid;
  }

  // If the calling thread lives in a child namespace, and the
  // function is called with type = 0, then then the pid_task() will
  // return -1.
  printk("%s: adderss checking - current is %p - find task by (v)PID is %p\n",
         MODNAME, current_pid, pid_task(find_vpid(the_pid), PIDTYPE_PID));

  return the_pid;
}

In questo running example abbiamo due esempi di codici applicativi lato user. Il codice new-namespace.c genera un thread in un nuovo namespace. Possiamo utilizzare questo codice in combinazione con il precedente running example (virtual-pids).

#define PAGE_SIZE 4096
#define STACK_SIZE 256 * PAGE_SIZE

static char child_stack[STACK_SIZE];

// Prints PID and spawn a bash shell inside a new namespace.
static int child_fn()
{
  printf("PID: %ld\n", (long)getpid());
  exelp("/bin/bash", "/bin/bash/",  NULL);
  return 0;
}

int main()
{
  // Clone thread/process into new namespace 
  pid_t child_pid = clone(child_fn, child_stack + STACK_SIZE, CLONE_NEWPID | SIGCHLD, NULL);
  printf("clone returned %ld\n", (long) child_pid);

  // Wait for the thread with PID child_pid to exit.
  waitpid(child_pid,  NULL, 0);

  return 0;
}