"aktuell" in den Linux-kernel-code

Als ich ging durch die unten chunk von Linux-char-Treiber-code, fand ich die Struktur Zeiger current im printk.

Möchte ich wissen, welche Struktur die current verweist und seine komplette Elemente.

Welchen Sinn hat diese Struktur?

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;
}
Wie es aussieht ist es eine Struktur, die bezieht sich auf den Prozess, der aus dem system aufrufen.
Versuchen Sie googeln für annotated linux kernel sollten Sie finden einige hilfreiche Ressourcen.
kernelnewbies.org/FAQ/current

InformationsquelleAutor Sagar Jain | 2014-03-12

  1. 19

    Es ist ein Zeiger auf den aktuellen Prozess, dh, der Prozess, die hat das system nennen.

    Aus der docs:

    Den Aktuellen Prozess

    Obwohl die kernel-Module nicht sequenziell ausführen als Anwendungen,
    die meisten Aktionen durchgeführt werden, durch die die im kernel sind mit einer bestimmten
    Prozess. Kernel-code kann wissen, den aktuellen Prozess fahren Sie durch
    der Zugriff auf die Globale Position aktuelle, einen Zeiger auf struct task_struct,
    die version 2.4 des Kernels wird erklärt in
    <asm/current.h> enthalten, die von <linux/sched.h>. Den aktuellen Zeiger
    bezieht sich auf die Benutzer-Prozess zurzeit ausgeführt wird. Während der Ausführung
    von einem system-call, wie dem öffnen oder zu Lesen, der aktuelle Prozess den man
    aufgerufen der Aufruf.     Kernel-code verwenden können Prozess-spezifische
    Informationen mit Hilfe aktuellen, wenn es braucht, um so zu tun. Ein Beispiel dafür
    die Technik präsentiert sich in "Access Control auf eine Geräte-Datei", in
    Kapitel 5, "Erweiterte Char Driver Operations".

    Eigentlich, Strom ist nicht richtig eine Globale variable mehr, wie es
    war in den ersten Linux-Kernel. Die Entwickler optimierten Zugriff auf die
    Struktur beschreibt den aktuellen Prozess, indem es versteckt in den stack
    Seite. Sie können sich die details der aktuellen in <asm/current.h>. Während
    der code, den Sie sehen könnte scheinen, haarig, wir müssen im Hinterkopf behalten, dass
    Linux ist ein SMP-kompatiblen system, und eine Globale variable einfach nicht
    Arbeit, wenn man es mit mehreren CPUs. Die details der
    Implementierung verborgen bleiben andere kernel-Subsysteme obwohl, und ein
    device-Treiber können Sie einfach und beziehen sich auf die
    aktuellen Prozess.

    Aus einem Modul der Sicht Aktueller ist wie die externe
    Referenz printk. Ein Modul kann beziehen sich auf aktuelle, wo immer es gerade passt.
    Zum Beispiel die folgende Anweisung druckt die Prozess-ID und
    Befehl name des aktuellen Prozesses durch Zugriff auf bestimmte Felder in
    struct task_struct:

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

    Namen des Befehls, gespeichert im current->comm, ist der Basis-name der
    Programm-Datei, die ausgeführt wird, indem Sie den aktuellen Prozess.

    InformationsquelleAutor Rahul Tripathi

  2. 4

    Hier ist die komplette Struktur der "aktuellen" verweist auf

    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   
};
    Aus der Frage oben: What purpose does this structure serve ?

    InformationsquelleAutor Sagar Jain

Schreibe einen Kommentar