"Current" dans le code du noyau Linux

Comme je l'ai été en passant par le dessous de la partie de Linux char code de pilote, j'ai trouvé le pointeur de structure current dans printk.

Je veux savoir ce que la structure de la current est de pointage et de ses éléments complets.

Quoi sert cette structure?

ssize_t sleepy_read (struct file *filp, char __user *buf, size_t count, loff_t *pos)
{
    printk(KERN_DEBUG "process %i (%s) going to sleep\n",
    current->pid, current->comm);
    wait_event_interruptible(wq, flag != 0);
    flag = 0;
    printk(KERN_DEBUG "awoken %i (%s)\n", current->pid, current->comm);
    return 0;
}

source d'informationauteur Sagar Jain

  1. 18

    Il est un pointeur vers le processus actuel c'est à dire, le processus qui a émis l'appel système.

    De la docs:

    Le Processus Actuel

    Bien que les modules du noyau ne pas exécuter de façon séquentielle comme les applications ne,
    la plupart des actions réalisées par le noyau sont liées à une
    processus. Code du noyau peut connaître les processus en cours conduite par
    accéder au mondial de l'élément courant, un pointeur vers une struct task_struct,
    qui à partir de la version 2.4 du noyau est déclaré dans
    <asm/current.h>inclus par <linux/sched.h>. Le pointeur courant
    fait référence à l'utilisateur processus en cours d'exécution. Au cours de l'exécution
    d'un appel système, telles que l'ouverture ou de la lecture, le processus actuel est l'un
    qui a appelé à l'appel.     Code du noyau pouvez utiliser des processus spécifiques
    informations à l'aide de courant, si il a besoin de le faire. Un exemple de ce
    la technique est présentée dans "Contrôle d'Accès sur un Fichier de Périphérique", dans
    Le Chapitre 5, "Renforcée Char Des Opérations De Pilote".

    En fait, le courant n'est pas correctement une variable globale plus, comme il
    a été dans les premiers noyaux de Linux. Les développeurs accès optimisé à l'
    structure décrivant le processus actuel en la cachant dans la pile
    page. Vous pouvez consulter les détails de courant dans <asm/current.h>. Alors que
    le code que vous regardez peut sembler poilu, nous devons garder à l'esprit que
    Linux est un SMP-système conforme à l', et une variable globale n'est tout simplement pas
    lorsque vous traitez avec plusieurs Processeurs. Les détails de l'
    mise en œuvre restent cachés à d'autres sous-systèmes du noyau si et un
    pilote de périphérique pouvez simplement inclure et reportez-vous à la
    processus actuel.

    À partir d'un module de point de vue, le courant est tout comme à l'externe
    référence printk. Un module peut se référer à courant partout où il juge à propos.
    Par exemple, l'instruction suivante imprime l'ID de processus et de la
    le nom de la commande du processus en cours par accès à certains champs
    struct task_struct:

     printk("The process is \"%s\" (pid %i)\n",
  current->comm, current->pid);

    Le nom de la commande stockées dans actuel->comm est le nom de base de la
    fichier de programme qui est exécuté par le processus courant.

  2. 4

    Voici la structure complète le "courant" est pointant vers

    task_struct
Each task_struct data structure describes a process or task in the system.

struct task_struct {
/* these are hardcoded - don't touch */
  volatile long        state;          /* -1 unrunnable, 0 runnable, >0 stopped */
  long                 counter;
  long                 priority;
  unsigned             long signal;
  unsigned             long blocked;   /* bitmap of masked signals */
  unsigned             long flags;     /* per process flags, defined below */
  int errno;
  long                 debugreg[8];    /* Hardware debugging registers */
  struct exec_domain   *exec_domain;
/* various fields */
  struct linux_binfmt  *binfmt;
  struct task_struct   *next_task, *prev_task;
  struct task_struct   *next_run,  *prev_run;
  unsigned long        saved_kernel_stack;
  unsigned long        kernel_stack_page;
  int                  exit_code, exit_signal;
  /* ??? */
  unsigned long        personality;
  int                  dumpable:1;
  int                  did_exec:1;
  int                  pid;
  int                  pgrp;
  int                  tty_old_pgrp;
  int                  session;
  /* boolean value for session group leader */
  int                  leader;
  int                  groups[NGROUPS];
  /* 
   * pointers to (original) parent process, youngest child, younger sibling,
   * older sibling, respectively.  (p->father can be replaced with 
   * p->p_pptr->pid)
   */
  struct task_struct   *p_opptr, *p_pptr, *p_cptr, 
                       *p_ysptr, *p_osptr;
  struct wait_queue    *wait_chldexit;  
  unsigned short       uid,euid,suid,fsuid;
  unsigned short       gid,egid,sgid,fsgid;
  unsigned long        timeout, policy, rt_priority;
  unsigned long        it_real_value, it_prof_value, it_virt_value;
  unsigned long        it_real_incr, it_prof_incr, it_virt_incr;
  struct timer_list    real_timer;
  long                 utime, stime, cutime, cstime, start_time;
/* mm fault and swap info: this can arguably be seen as either
   mm-specific or thread-specific */
  unsigned long        min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
  int swappable:1;
  unsigned long        swap_address;
  unsigned long        old_maj_flt;    /* old value of maj_flt */
  unsigned long        dec_flt;        /* page fault count of the last time */
  unsigned long        swap_cnt;       /* number of pages to swap on next pass */
/* limits */
  struct rlimit        rlim[RLIM_NLIMITS];
  unsigned short       used_math;
  char                 comm[16];
/* file system info */
  int                  link_count;
  struct tty_struct    *tty;           /* NULL if no tty */
/* ipc stuff */
  struct sem_undo      *semundo;
  struct sem_queue     *semsleeping;
/* ldt for this task - used by Wine.  If NULL, default_ldt is used */
  struct desc_struct *ldt;
/* tss for this task */
  struct thread_struct tss;
/* filesystem information */
  struct fs_struct     *fs;
/* open file information */
  struct files_struct  *files;
/* memory management info */
  struct mm_struct     *mm;
/* signal handlers */
  struct signal_struct *sig;
#ifdef __SMP__
  int                  processor;
  int                  last_processor;
  int                  lock_depth;     /* Lock depth. 
                                          We can context switch in and out
                                          of holding a syscall kernel lock... */ 
#endif   
};