Struttura di timekeeping. Francesco Famulari

Transcript

1 Struttura di timekeeping Francesco Famulari

2 Argomenti Tutto il codice esaminato si riferisce al kernel vanilla Linux Gli argomenti presentati sono: Passaggio alla nuova architettura del time system Building blocks fondamentali dell'architettura del time system Architettura di time keeping Device che tengono traccia del passare del tempo Alcune strutture e funzioni dell'architettura di time keeping Preferenza di un device rispetto agli altri Modulo la13_module_time

3 Passaggio alla nuova architettura del time system Vecchio sistema del tempo

4 Passaggio alla nuova architettura del time system Infrastruttura base degli hrtimer incorporata nel kernel

5 Passaggio alla nuova architettura del time system John Stultz's GTOD (generic time of day) patch incorporata nel kernel

6 Passaggio alla nuova architettura del time system Clock event management

7 Passaggio alla nuova architettura del time system High resolution timer functionality

8 Building blocks fondamentali dell'architettura del time system hrtimer base infrastructure timeofday and clock source management clock event management high resolution timer functionality dynamic ticks

9 Architettura di time keeping L'architettura di timekeeping di Linux è l'insime delle strutture dati e funzioni del kernel relative al flusso del tempo. Attività periodiche del kernel: aggiornamento del tempo dall'avvio del sistema aggiornamento del tempo e della data determinare il tempo di esecuzione del processo corrente per ogni cpu e interromperlo se ha superato il tempo assegnatogli aggiornamento delle statistiche di uso delle risorse controllo se il tempo associato a ogni timer software è trascorso

10 Architettura di time keeping In Linux possiamo definire 2 concetti di tempo: Wall time (o time of day o real time): è un valore che rappresenta il tempo umano del giorno, proprio come quello osservabile su un orologio a muro o un orologio da polso. Tempo di sistema: è un valore monotonicamente crescente che rappresenta la quantità di tempo durante il quale il sistema sta funzionando.

11 Architettura di time keeping Un sistema Linux attualmente ha 2 clock che si riferiscono ai 2 tipi di tempo appena visti: uno è quello che riceve energia dalla batteria ed è chiamato "Real Time Clock" o "RTC" o "CMOS clock" o "Hardware clock" o "persistent clock"; esso tiene traccia del tempo quando il sistema è spento ma non viene usato quando il sistema è in funzione. L'altro è il "System clock", anche detto "Kernel clock" o "Software clock"; esso è un contatore software basato su timer interrupt. Esso non esiste quando il sistema non sta funzionando e così deve essere inizializzato dall'rtc quando il sistema viene avviato. Può anche essere inizializzato da qualche altra sorgente di tempo ad esempio tramite NTP.

12 Device che tengono traccia del passare del tempo 1) Real Time Clock (RTC) 2) Time Stamp Counter (TSC) 3) Programmable Interval Timer (PIT) 4) CPU Local Timer (local APIC) 5) High Precision Event Timer (HPET) 6) ACPI Power Management Timer (ACPI PMT)

13 Real Time Clock (RTC) Motorola chip Hz Acceduto dal kernel tramite le porte 0x70, 0x71 Programmabile grazie a /dev/rtc

14 Time Stamp Counter (TSC) La cpu aggiorna un suo registro detto TSC alla ricezione del segnale di clock tramite uno dei suoi pin da parte di un oscillatore esterno. Misure più accurate del PIT

15 PIT Il "vecchio" PIT è un chip da sempre presente sui PC IBM CMOS chip porte di I/O 0x40 0x Hz adjustable Emette un timer interrupt allo scadere di uno o più timer. Oggi non costituisce più un chip a sè stante incluso nel PC, ma la sua funzionalità è stata integrata nel southbridge chipset.

16 CPU Local Timer local APIC Ha un contatore a 32 bit versus 16 bit del PIT L'interrupt è mandato dal local APIC solo al suo processore Decrementa un contatore ogni 1, 2, 4, 8, 16, 32, 64, 128 segnali di clock del bus

17 High Precision Event Timer (HPET) Fornisce diversi (max 8) contatori monotoni crescenti a 64 bit (o a 32 bit). Fornisce diversi timer hardware sfruttabili dal kernel. Ogni contatore ha fino a 32 timer. timer := comparator + match register Il comparator compara il valore nel counter con quello nel match register. Programmabile attraverso registri mappati nello spazio di memoria. Ogni contatore ha un proprio segnale di clock di almeno 10 MHz

18 ACPI Power Management Timer (ACPI PMT) L'ACPI PMT ha un segnale di clock di circa 3.58 MHz. Accessibile tramite I/O port E' indipendente dalla regolazione dinamica del voltaggio e della frequenza da parte del BIOS o del sistema operativo e per questo è preferibile in tali situazioni al TSC che comunque ha una maggiore frequenza

19 Alcune strutture e funzioni dell'architettura di time keeping Nel file: include/linux/timekeeper_internal.h troviamo la definizione della struttura: struct timekeeper alcuni dei cui campi sono: struct clocksource *clock; u64 xtime_sec; u64 xtime_nsec; seqlock_t lock;

20 Alcune strutture e funzioni dell'architettura di time keeping Nel file: include/linux/clocksource.h troviamo: struct clocksource alcuni campi della quale sono: const char *name; struct list_head list; int rating; cycle_t (*read)(struct clocksource *cs); void (*suspend)(struct clocksource *cs); void (*resume)(struct clocksource *cs); cycle_t cycle_last; cycle_t mask; La struct clocksource è usata per il tempo di sistema, ad es.: static inline s64 clocksource_cyc2ns(cycle_t cycles, u32 mult, u32 shift)

21 Alcune strutture e funzioni dell'architettura di time keeping Nel file: /usr/src/linux x.y.z/kernel/time/clocksource.c troviamo: static struct clocksource *curr_clocksource; static LIST_HEAD(clocksource_list); static DEFINE_MUTEX(clocksource_mutex); static char override_name[32]; e troviamo inoltre funzioni varie per lavorare con i timecounter e i clocksource.

22 Chiamate di sistema relative al tempo Le chiamate di sistema relative al tempo sono: time stime gettimeofday settimeofday adjtimex

23 sys_gettimeofday La sys_gettimeofday in kernel/time.c rimanda alla getnstimeofday in kernel/time/timekeeping.c; questa restituisce il time of day in una timespec passata come parametro. struct timespec { kernel_time_t tv_sec; /* seconds */ long tv_nsec; /* nanoseconds */ }; kernel_time_t è kernel_long_t che attualmente è un long Nelle prossime slide vengono riportati i pezzi di codice che si ottengono seguendo tramite i tags la sys_gettimeofday fino alla getnstimeofday.

24 sys_gettimeofday SYSCALL_DEFINE2(gettimeofday, struct timeval user *, tv, struct timezone user *, tz) { if (likely(tv!= NULL)) { struct timeval ktv; do_gettimeofday(&ktv); if (copy_to_user(tv, &ktv, sizeof(ktv))) return EFAULT; } if (unlikely(tz!= NULL)) { if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) return EFAULT; } return 0; }

25 sys_gettimeofday void do_gettimeofday(struct timeval *tv) { struct timespec now; getnstimeofday(&now); tv >tv_sec = now.tv_sec; tv >tv_usec = now.tv_nsec/1000; } EXPORT_SYMBOL(do_gettimeofday); dove si ha che la struct timeval è: struct timeval { kernel_time_t tv_sec; /* seconds */ kernel_suseconds_t tv_usec; /* microseconds */ };

26 sys_gettimeofday void getnstimeofday(struct timespec *ts) { WARN_ON( getnstimeofday(ts)); } EXPORT_SYMBOL(getnstimeofday); int getnstimeofday(struct timespec *ts) { struct timekeeper *tk = &timekeeper; unsigned long seq; s64 nsecs = 0;

27 sys_gettimeofday do { seq = read_seqbegin(&tk >lock); ts >tv_sec = tk >xtime_sec; nsecs = timekeeping_get_ns(tk); } while (read_seqretry(&tk >lock, seq)); ts >tv_nsec = 0; timespec_add_ns(ts, nsecs);

28 sys_gettimeofday /* * Do not bail out early, in case there were callers still using * the value, even in the face of the WARN_ON. */ if (unlikely(timekeeping_suspended)) return EAGAIN; return 0; } EXPORT_SYMBOL( getnstimeofday); EAGAIN è un errore che può capitare quando si fanno operazioni di I/O non bloccanti e significa che ora non ci sono dati disponibili e quindi bisogna riprovare in seguito.

29 Scelta del miglior device In arch/x86/kernel/hpet.c si trova: static struct clocksource clocksource_hpet = {.name = "hpet",.rating = 250,.read = read_hpet,.mask = HPET_MASK,.flags = CLOCK_SOURCE_IS_CONTINUOUS,.resume = hpet_resume_counter, #ifdef CONFIG_X86_64.archdata = {.vclock_mode = VCLOCK_HPET }, #endif }; In questo esempio vediamo come un rating di 250 è "hardwired" per l'hpet.

30 Scelta del miglior device Seguiamo i vari passi dalla registrazione di un nuovo device alla scelta del miglior device per il sistema. In arch/x86/kernel/time/clocksource.c si trova la funzione: int clocksource_register(struct clocksource *cs) Serve a registrare un clocksource, cosa indispensabile prima che il clock source possa essere usato. Le ultime 3 istruzioni della funzione invocano in sequenza: clocksource_enqueue(cs); clocksource_enqueue_watchdog(cs); clocksource_select(); Esaminiamo la clocksource_enqueue() e poi vediamo la clocksource_select:

31 Scelta del miglior device static void clocksource_enqueue(struct clocksource *cs) { struct list_head *entry = &clocksource_list; struct clocksource *tmp; } list_for_each_entry(tmp, &clocksource_list, list) /* Keep track of the place, where to insert */ if (tmp >rating >= cs >rating) entry = &tmp >list; list_add(&cs >list, entry);

32 Scelta del miglior device In arch/x86/kernel/time/clocksource.c si trova: static void clocksource_select(void) Tale funzione deve essere invocata possedendo il clocksource_mutex. Come ultima istruzione tale funzione invoca la funzione (che si trova in timekeeping.c): void timekeeping_notify(struct clocksource *clock) che a sua volta invocherà stop_machine(change_clocksource, clock, NULL); a cui passa il puntatore alla funzione static int change_clocksource(void *data)

33 Scelta del miglior device La change clock_clocksource infine, dopo aver eseguito write_seqlock_irqsave(&tk >lock, flags); invocherà le 2 funzioni tk_setup_internals(tk, new); timekeeping_update(tk, true);

34 Clocksource nel sysfs E' possibile avere informazioni sui clocksource del sistema leggendo i seguenti file in /sys/ cat /sys/devices/system/clocksource/clocksource0/current_clock source cat /sys/devices/system/clocksource/clocksource0/available_clo cksource

35 Modulo per reperire alcune informazioni di timekeeping Il modulo la13_module_time stampa alcune informazioni di timekeeping. Per reperire le informazioni necessarie sui clocksource si è pensato inizialmente di usare la funzione clocksource_get_next() ma si è scoperto che è stata rimossa; tuttavia nel kernel ne rimane una sola traccia, nello specifico una dichiarazione extern nel file: include/linux/clocksource.h extern struct clocksource* clocksource_get_next(void); Allora si è aggiunta una riga al codice del kernel per esportare la variabile "timekeeper"; il file per effettuare la modifica e la modifica stessa sono: kernel/time/timekeeping.c EXPORT_SYMBOL_GPL(timekeeper); In questa maniera si ha accesso alla variabile del kernel: struct timekeeper timekeeper;