Sistemi Operativi - User contributions [en]

Lezioni Anno Accademico 2015/16

2015-11-11T19:40:29Z

Edux: /* Lezione del 18 novembre 2015 */

''scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.''

== Lezione del 22 settembre 2015 ==

Introduzione al corso di Sistemi Operativi.

=== concetti ===
* Hardware vs. Software
* Informatica
* Scienza vs. Tecnologia
* Informazione (vs. Dato)
* Linguaggio
* Elaborazione-Memorizzazione-Comunicazione
* Algoritmo vs. Programma
* Hacker/Hacking (vs. Cracker)
* Maker
* Analogico-Digitale

== Lezione del 23 settembre 2015 ==

Storia dei Sistemi.... anche operativi.

=== concetti ===
* Architettura a livelli (Layer)
* SO come livello di astrazione (semplificazione, portabilita')
* SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
* Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
* I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
* Multitasking (perche' e' possibile? perche' e quando e' necessario?)
* Interattivita'
* TIme sharing
* Multiuser (multiutente)
* UNIX
* Personal Computer (e i sistemi operativi)

== Lezione del 30 settembre 2015 ==

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è [http://www.cs.unibo.it/~renzo/so/tools/portability3.tgz qui].

[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:
* il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.
il comando per kvm è:
kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio
* chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:47, 3 October 2015 (CEST)

=== concetti ===
* Conoscenze a breve, medio e lungo termine dell'informatica
* Linguaggio dell'Hardware
* X ''Virtuale'' (dove X rappresenta qualsiasi cosa)
* Emulazione/Simulazione
* virtualizzazione senza emulazione
* Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
* macchine virtuali
* Distribuzione e Ambiente Operativo
* [http://www.gnu.org/philosophy/open-source-misses-the-point.it.html Licenze: differenza fra Software Libero e Open Source]

== Lezione del 07 ottobre 2015 ==

Ricordo che è in sospeso una domanda: [["l'arduino ha un sistema operativo?"]]

=== Concetti: ripasso linguaggio C ===
* Compilatori vs. Interpreti
* Programmi vs. Script
* Le classi di linguaggi di programmazione
* Il "livello" dei linguaggi di programmazione
* Cosa e', cosa non e' il Linguaggio C
* [[Genesi del linguaggio C: intenzioni degli autori]]
* Le '''vere''' novita' del linguaggio C

=== concetti: ripasso architettura ===
* Modelli architetturali: von Neumann vs. Harvard
* Gerarchia di Memoria
* Cache
* Indirizzi Logici, Indirizzi Fisici
* Rilocazione

=== strumenti utilizzati durante la lezione ===
* Arduino, hardware e sistema di sviluppo. Nelle distribuzioni debian-like c'e' il pacchetto denominato "Arduino"
apt-get install arduino
* Una scheda con il solo microcontrollore atmega (nella scheda in aula era un atmega168). Ho tratto ispirazione da [http://www.tuxgraphics.org/electronics/200411/article352.shtml questo articolo di tuxgraphics]. Non e' necessario fare tutte le fasi iniziali di "software installation" perche' sono tutti software pacchettizzati debian. Se avete installato il pacchetto arduino tutti i cross compiler e lo strumento per caricare il firmware li trovate gia' disponibili.
* Il programma C senza librerie e' il seguente:
<source lang=C>
typedef unsigned char uint8_t;
typedef unsigned long uint32_t;
typedef unsigned short uint16_t;

int main(void)
{
*((volatile uint8_t *) 0x2B) = 0x00;
*((volatile uint8_t *) 0x2A) = 0xFF;

while (1) {
volatile uint16_t t;
for (t=0; t<10000; t++)
;
*((volatile uint8_t *) 0x2B) += 1;
}
return(0);
}
</source>
per vedere il led lampeggiare occorre collegarlo (con la resistenza di limitazione della corrente) al pin 2 (porta D0) poi al pin 3 (porta D1) etc... (spostate il circuito disegnato alla porta 28 nella pagina sopra citata di tuxgraphics ai pin 2, 3 etc). NB: se volete collegare le porte GPIO o i2c di arduino o di un atmega ad un raspberry PI controllate che la tensione di lavoro dell'arduino/atmega sia 3.3v e NON 5v.

== Lezione del 14 ottobre 2015 ==

Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:43, 10 October 2015 (CEST)

=== temi trattati: ripasso Linguaggio C ===
* Preprocessori: inclusione, compilazione condizionale macro
* Macro vs. funzioni inline
* Static vs. Extern
* Static vs. Auto
* Register

=== temi trattati: ripasso Architettura degli Elaboratori ===
* Bus Indirizzi, Bus Dati, Gerarchie di Bus
* Interrupt (e Trap)
* Mascheramento degli Interrupt
* Gestione nidificata degli interrupt
* DMA (Direct Memory Access)

=== temi accennati: ===
* [http://mellotanica.github.io/uARM/ uarm]: l'emulatore per il progetto

== Lezione del 21 ottobre 2015 ==

(Correzione) Compiti a casa:
* Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. Sono da provare e commentare. E' possibile proporne di nuovi.
* Provare a installare [http://mellotanica.github.io/uARM/ uarm: l'emulatore per il progetto] nei propri sistemi.

=== argomenti trattati ===
* vettori, strutture e puntatori in C
* il debugging: gdb
* la funzione _start nei sistemi UNIX like.

Ecco l'esempio di funzione start minimale:

<source lang=asm>
.text
.global _start

_start:
xor %rbp, %rbp
popq %rdi
movq %rsp, %rsi
andq $~15, %rsp
call main
//nuova interfaccia syscall
mov %rax, %rdi
mov $231, %rax
syscall
//vecchia interfaccia syscall
//mov %eax, %ebx
//mov $252, %eax
//int $0x80
</source>

E il sorgente C usato nell'esperimento di debugging:
<source lang=C>
struct test {
int a[16];
};

struct test x={{42,73,51}};

int f(struct test t) {
return t.a[0]+t.a[1]+t.a[2];
}

int main(int argc, char *argv[]) {
volatile int sum=f(x);
return argc;
}
</source>

== Lezione del 28 ottobre 2015 ==

=== argomenti trattati ===
* uARM interfaccia
* uARM esecuzione di programmi e debug
* cross-compilazione per uARM
* la libreria libuarm
* analisi della funzione tprint (polling di output)
* debug tramite variabili e funzioni dummy

* _start per ARM:
<source lang=asm>
.global _start
_start:
sub lr, lr, lr
ldr r0, [sp]
add r1, sp, #4
bl main
mov R7, #1
swi 0
</source>

=== ripasso di architettura ===
* la pipeline del processore
* Struttura del processore: Control Path, Data Path
* CISC vs RISC

== Lezione del 4 novembre 2015 ==

=== argomenti da trattare/rivedere ===
* Sistemi Real Time
* I sistemi operativi per sistemi multiprocessore (SMP e non SMP)
* gestione nidificata degli Interrupt nidificati
* gli stack del kernel
* programmed I/O (polling) vs interrupt
* dispositivi "memory mapped" e non (come si interfacciano i dispositivi)
* componenti del SO: gestore processi, gestore memoria primaria, gestione memoria secondaria, file system, I/O, protezione, networking
* compilazione del kernel

== Lezione del 11 novembre 2015 ==
* Awsome Lecture by Prof. Goldweber and Prof. Davoli!

== Lezione del 18 novembre 2015 ==
* Scheduling / Schedulers
* Memory Management / Virtual Memory / Swapping Area
* Replacement Algorithm's
* uARM further examination
* threads in C and how to use them...

== Lezione del 25 novembre 2015 ==

== Lezione del 2 dicembre 2015 ==

== Lezione del 16 dicembre 2015 ==

== CAPITOLI del corso da svolgere ==
* Sruttura del SO
* Scheduler
* Gestione risorse (deadlock)
* Gestione memoria centrale (paginazione, segmentazione, memoria virtuale)
* Gestione memoria secondaria
* File system
* Sicurezza

* Strumenti per lo sviluppo, la portabilita' e la collaborazione (make, autotool, versioning)
* System Call POSIX
* Principali librerie (LibC, Pthreads, Socket...)
* Bash (uso avanzato e scripting)
* Python

* uMPS
* progetto prima fase
* progetto seconda fase

== Argomenti proposti dagli studenti ==
* System Call's e/o esempi di uso
* Instruction Set & Assembly
* Memoria Centrale, Indirizzamento, Memoria Virtuale, Swapping, Traduzione Indirizzi logici in indirizzi fisici (metodi e circuiteria usata)
* Scheduling dei processi e tipi di Scheduler
* Linguaggi nuovi (esempio: Python)
* Scripting
* Tool di programmazione (make, automake ecc)
* Differenze Linker, Loader ecc
* Crittografia e uso nei sistemi operativi
* Extreme C (esempi di uso (DIsuso) del linguaggio C.

Lezioni Anno Accademico 2015/16

2015-11-11T19:40:16Z

Edux: /* Lezione del 11 novembre 2015 */

''scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.''

== Lezione del 22 settembre 2015 ==

Introduzione al corso di Sistemi Operativi.

=== concetti ===
* Hardware vs. Software
* Informatica
* Scienza vs. Tecnologia
* Informazione (vs. Dato)
* Linguaggio
* Elaborazione-Memorizzazione-Comunicazione
* Algoritmo vs. Programma
* Hacker/Hacking (vs. Cracker)
* Maker
* Analogico-Digitale

== Lezione del 23 settembre 2015 ==

Storia dei Sistemi.... anche operativi.

=== concetti ===
* Architettura a livelli (Layer)
* SO come livello di astrazione (semplificazione, portabilita')
* SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
* Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
* I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
* Multitasking (perche' e' possibile? perche' e quando e' necessario?)
* Interattivita'
* TIme sharing
* Multiuser (multiutente)
* UNIX
* Personal Computer (e i sistemi operativi)

== Lezione del 30 settembre 2015 ==

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è [http://www.cs.unibo.it/~renzo/so/tools/portability3.tgz qui].

[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:
* il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.
il comando per kvm è:
kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio
* chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:47, 3 October 2015 (CEST)

=== concetti ===
* Conoscenze a breve, medio e lungo termine dell'informatica
* Linguaggio dell'Hardware
* X ''Virtuale'' (dove X rappresenta qualsiasi cosa)
* Emulazione/Simulazione
* virtualizzazione senza emulazione
* Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
* macchine virtuali
* Distribuzione e Ambiente Operativo
* [http://www.gnu.org/philosophy/open-source-misses-the-point.it.html Licenze: differenza fra Software Libero e Open Source]

== Lezione del 07 ottobre 2015 ==

Ricordo che è in sospeso una domanda: [["l'arduino ha un sistema operativo?"]]

=== Concetti: ripasso linguaggio C ===
* Compilatori vs. Interpreti
* Programmi vs. Script
* Le classi di linguaggi di programmazione
* Il "livello" dei linguaggi di programmazione
* Cosa e', cosa non e' il Linguaggio C
* [[Genesi del linguaggio C: intenzioni degli autori]]
* Le '''vere''' novita' del linguaggio C

=== concetti: ripasso architettura ===
* Modelli architetturali: von Neumann vs. Harvard
* Gerarchia di Memoria
* Cache
* Indirizzi Logici, Indirizzi Fisici
* Rilocazione

=== strumenti utilizzati durante la lezione ===
* Arduino, hardware e sistema di sviluppo. Nelle distribuzioni debian-like c'e' il pacchetto denominato "Arduino"
apt-get install arduino
* Una scheda con il solo microcontrollore atmega (nella scheda in aula era un atmega168). Ho tratto ispirazione da [http://www.tuxgraphics.org/electronics/200411/article352.shtml questo articolo di tuxgraphics]. Non e' necessario fare tutte le fasi iniziali di "software installation" perche' sono tutti software pacchettizzati debian. Se avete installato il pacchetto arduino tutti i cross compiler e lo strumento per caricare il firmware li trovate gia' disponibili.
* Il programma C senza librerie e' il seguente:
<source lang=C>
typedef unsigned char uint8_t;
typedef unsigned long uint32_t;
typedef unsigned short uint16_t;

int main(void)
{
*((volatile uint8_t *) 0x2B) = 0x00;
*((volatile uint8_t *) 0x2A) = 0xFF;

while (1) {
volatile uint16_t t;
for (t=0; t<10000; t++)
;
*((volatile uint8_t *) 0x2B) += 1;
}
return(0);
}
</source>
per vedere il led lampeggiare occorre collegarlo (con la resistenza di limitazione della corrente) al pin 2 (porta D0) poi al pin 3 (porta D1) etc... (spostate il circuito disegnato alla porta 28 nella pagina sopra citata di tuxgraphics ai pin 2, 3 etc). NB: se volete collegare le porte GPIO o i2c di arduino o di un atmega ad un raspberry PI controllate che la tensione di lavoro dell'arduino/atmega sia 3.3v e NON 5v.

== Lezione del 14 ottobre 2015 ==

Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:43, 10 October 2015 (CEST)

=== temi trattati: ripasso Linguaggio C ===
* Preprocessori: inclusione, compilazione condizionale macro
* Macro vs. funzioni inline
* Static vs. Extern
* Static vs. Auto
* Register

=== temi trattati: ripasso Architettura degli Elaboratori ===
* Bus Indirizzi, Bus Dati, Gerarchie di Bus
* Interrupt (e Trap)
* Mascheramento degli Interrupt
* Gestione nidificata degli interrupt
* DMA (Direct Memory Access)

=== temi accennati: ===
* [http://mellotanica.github.io/uARM/ uarm]: l'emulatore per il progetto

== Lezione del 21 ottobre 2015 ==

(Correzione) Compiti a casa:
* Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. Sono da provare e commentare. E' possibile proporne di nuovi.
* Provare a installare [http://mellotanica.github.io/uARM/ uarm: l'emulatore per il progetto] nei propri sistemi.

=== argomenti trattati ===
* vettori, strutture e puntatori in C
* il debugging: gdb
* la funzione _start nei sistemi UNIX like.

Ecco l'esempio di funzione start minimale:

<source lang=asm>
.text
.global _start

_start:
xor %rbp, %rbp
popq %rdi
movq %rsp, %rsi
andq $~15, %rsp
call main
//nuova interfaccia syscall
mov %rax, %rdi
mov $231, %rax
syscall
//vecchia interfaccia syscall
//mov %eax, %ebx
//mov $252, %eax
//int $0x80
</source>

E il sorgente C usato nell'esperimento di debugging:
<source lang=C>
struct test {
int a[16];
};

struct test x={{42,73,51}};

int f(struct test t) {
return t.a[0]+t.a[1]+t.a[2];
}

int main(int argc, char *argv[]) {
volatile int sum=f(x);
return argc;
}
</source>

== Lezione del 28 ottobre 2015 ==

=== argomenti trattati ===
* uARM interfaccia
* uARM esecuzione di programmi e debug
* cross-compilazione per uARM
* la libreria libuarm
* analisi della funzione tprint (polling di output)
* debug tramite variabili e funzioni dummy

* _start per ARM:
<source lang=asm>
.global _start
_start:
sub lr, lr, lr
ldr r0, [sp]
add r1, sp, #4
bl main
mov R7, #1
swi 0
</source>

=== ripasso di architettura ===
* la pipeline del processore
* Struttura del processore: Control Path, Data Path
* CISC vs RISC

== Lezione del 4 novembre 2015 ==

=== argomenti da trattare/rivedere ===
* Sistemi Real Time
* I sistemi operativi per sistemi multiprocessore (SMP e non SMP)
* gestione nidificata degli Interrupt nidificati
* gli stack del kernel
* programmed I/O (polling) vs interrupt
* dispositivi "memory mapped" e non (come si interfacciano i dispositivi)
* componenti del SO: gestore processi, gestore memoria primaria, gestione memoria secondaria, file system, I/O, protezione, networking
* compilazione del kernel

== Lezione del 11 novembre 2015 ==
* Awsome Lecture by Prof. Goldweber and Prof. Davoli!

== Lezione del 18 novembre 2015 ==

== Lezione del 25 novembre 2015 ==

== Lezione del 2 dicembre 2015 ==

== Lezione del 16 dicembre 2015 ==

== CAPITOLI del corso da svolgere ==
* Sruttura del SO
* Scheduler
* Gestione risorse (deadlock)
* Gestione memoria centrale (paginazione, segmentazione, memoria virtuale)
* Gestione memoria secondaria
* File system
* Sicurezza

* Strumenti per lo sviluppo, la portabilita' e la collaborazione (make, autotool, versioning)
* System Call POSIX
* Principali librerie (LibC, Pthreads, Socket...)
* Bash (uso avanzato e scripting)
* Python

* uMPS
* progetto prima fase
* progetto seconda fase

== Argomenti proposti dagli studenti ==
* System Call's e/o esempi di uso
* Instruction Set & Assembly
* Memoria Centrale, Indirizzamento, Memoria Virtuale, Swapping, Traduzione Indirizzi logici in indirizzi fisici (metodi e circuiteria usata)
* Scheduling dei processi e tipi di Scheduler
* Linguaggi nuovi (esempio: Python)
* Scripting
* Tool di programmazione (make, automake ecc)
* Differenze Linker, Loader ecc
* Crittografia e uso nei sistemi operativi
* Extreme C (esempi di uso (DIsuso) del linguaggio C.

Lezioni Anno Accademico 2015/16

2015-11-11T19:39:20Z

Edux: /* Lezione del 11 novembre 2015 */

''scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.''

== Lezione del 22 settembre 2015 ==

Introduzione al corso di Sistemi Operativi.

=== concetti ===
* Hardware vs. Software
* Informatica
* Scienza vs. Tecnologia
* Informazione (vs. Dato)
* Linguaggio
* Elaborazione-Memorizzazione-Comunicazione
* Algoritmo vs. Programma
* Hacker/Hacking (vs. Cracker)
* Maker
* Analogico-Digitale

== Lezione del 23 settembre 2015 ==

Storia dei Sistemi.... anche operativi.

=== concetti ===
* Architettura a livelli (Layer)
* SO come livello di astrazione (semplificazione, portabilita')
* SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
* Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
* I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
* Multitasking (perche' e' possibile? perche' e quando e' necessario?)
* Interattivita'
* TIme sharing
* Multiuser (multiutente)
* UNIX
* Personal Computer (e i sistemi operativi)

== Lezione del 30 settembre 2015 ==

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è [http://www.cs.unibo.it/~renzo/so/tools/portability3.tgz qui].

[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:
* il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.
il comando per kvm è:
kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio
* chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:47, 3 October 2015 (CEST)

=== concetti ===
* Conoscenze a breve, medio e lungo termine dell'informatica
* Linguaggio dell'Hardware
* X ''Virtuale'' (dove X rappresenta qualsiasi cosa)
* Emulazione/Simulazione
* virtualizzazione senza emulazione
* Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
* macchine virtuali
* Distribuzione e Ambiente Operativo
* [http://www.gnu.org/philosophy/open-source-misses-the-point.it.html Licenze: differenza fra Software Libero e Open Source]

== Lezione del 07 ottobre 2015 ==

Ricordo che è in sospeso una domanda: [["l'arduino ha un sistema operativo?"]]

=== Concetti: ripasso linguaggio C ===
* Compilatori vs. Interpreti
* Programmi vs. Script
* Le classi di linguaggi di programmazione
* Il "livello" dei linguaggi di programmazione
* Cosa e', cosa non e' il Linguaggio C
* [[Genesi del linguaggio C: intenzioni degli autori]]
* Le '''vere''' novita' del linguaggio C

=== concetti: ripasso architettura ===
* Modelli architetturali: von Neumann vs. Harvard
* Gerarchia di Memoria
* Cache
* Indirizzi Logici, Indirizzi Fisici
* Rilocazione

=== strumenti utilizzati durante la lezione ===
* Arduino, hardware e sistema di sviluppo. Nelle distribuzioni debian-like c'e' il pacchetto denominato "Arduino"
apt-get install arduino
* Una scheda con il solo microcontrollore atmega (nella scheda in aula era un atmega168). Ho tratto ispirazione da [http://www.tuxgraphics.org/electronics/200411/article352.shtml questo articolo di tuxgraphics]. Non e' necessario fare tutte le fasi iniziali di "software installation" perche' sono tutti software pacchettizzati debian. Se avete installato il pacchetto arduino tutti i cross compiler e lo strumento per caricare il firmware li trovate gia' disponibili.
* Il programma C senza librerie e' il seguente:
<source lang=C>
typedef unsigned char uint8_t;
typedef unsigned long uint32_t;
typedef unsigned short uint16_t;

int main(void)
{
*((volatile uint8_t *) 0x2B) = 0x00;
*((volatile uint8_t *) 0x2A) = 0xFF;

while (1) {
volatile uint16_t t;
for (t=0; t<10000; t++)
;
*((volatile uint8_t *) 0x2B) += 1;
}
return(0);
}
</source>
per vedere il led lampeggiare occorre collegarlo (con la resistenza di limitazione della corrente) al pin 2 (porta D0) poi al pin 3 (porta D1) etc... (spostate il circuito disegnato alla porta 28 nella pagina sopra citata di tuxgraphics ai pin 2, 3 etc). NB: se volete collegare le porte GPIO o i2c di arduino o di un atmega ad un raspberry PI controllate che la tensione di lavoro dell'arduino/atmega sia 3.3v e NON 5v.

== Lezione del 14 ottobre 2015 ==

Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:43, 10 October 2015 (CEST)

=== temi trattati: ripasso Linguaggio C ===
* Preprocessori: inclusione, compilazione condizionale macro
* Macro vs. funzioni inline
* Static vs. Extern
* Static vs. Auto
* Register

=== temi trattati: ripasso Architettura degli Elaboratori ===
* Bus Indirizzi, Bus Dati, Gerarchie di Bus
* Interrupt (e Trap)
* Mascheramento degli Interrupt
* Gestione nidificata degli interrupt
* DMA (Direct Memory Access)

=== temi accennati: ===
* [http://mellotanica.github.io/uARM/ uarm]: l'emulatore per il progetto

== Lezione del 21 ottobre 2015 ==

(Correzione) Compiti a casa:
* Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. Sono da provare e commentare. E' possibile proporne di nuovi.
* Provare a installare [http://mellotanica.github.io/uARM/ uarm: l'emulatore per il progetto] nei propri sistemi.

=== argomenti trattati ===
* vettori, strutture e puntatori in C
* il debugging: gdb
* la funzione _start nei sistemi UNIX like.

Ecco l'esempio di funzione start minimale:

<source lang=asm>
.text
.global _start

_start:
xor %rbp, %rbp
popq %rdi
movq %rsp, %rsi
andq $~15, %rsp
call main
//nuova interfaccia syscall
mov %rax, %rdi
mov $231, %rax
syscall
//vecchia interfaccia syscall
//mov %eax, %ebx
//mov $252, %eax
//int $0x80
</source>

E il sorgente C usato nell'esperimento di debugging:
<source lang=C>
struct test {
int a[16];
};

struct test x={{42,73,51}};

int f(struct test t) {
return t.a[0]+t.a[1]+t.a[2];
}

int main(int argc, char *argv[]) {
volatile int sum=f(x);
return argc;
}
</source>

== Lezione del 28 ottobre 2015 ==

=== argomenti trattati ===
* uARM interfaccia
* uARM esecuzione di programmi e debug
* cross-compilazione per uARM
* la libreria libuarm
* analisi della funzione tprint (polling di output)
* debug tramite variabili e funzioni dummy

* _start per ARM:
<source lang=asm>
.global _start
_start:
sub lr, lr, lr
ldr r0, [sp]
add r1, sp, #4
bl main
mov R7, #1
swi 0
</source>

=== ripasso di architettura ===
* la pipeline del processore
* Struttura del processore: Control Path, Data Path
* CISC vs RISC

== Lezione del 4 novembre 2015 ==

=== argomenti da trattare/rivedere ===
* Sistemi Real Time
* I sistemi operativi per sistemi multiprocessore (SMP e non SMP)
* gestione nidificata degli Interrupt nidificati
* gli stack del kernel
* programmed I/O (polling) vs interrupt
* dispositivi "memory mapped" e non (come si interfacciano i dispositivi)
* componenti del SO: gestore processi, gestore memoria primaria, gestione memoria secondaria, file system, I/O, protezione, networking
* compilazione del kernel

== Lezione del 11 novembre 2015 ==
* Scheduling / Schedulers
* Memory Management / Virtual Memory / Swapping Area
* Replacement Algorithm's
* uARM further examination
* threads in C and how to use them...

== Lezione del 18 novembre 2015 ==

== Lezione del 25 novembre 2015 ==

== Lezione del 2 dicembre 2015 ==

== Lezione del 16 dicembre 2015 ==

== CAPITOLI del corso da svolgere ==
* Sruttura del SO
* Scheduler
* Gestione risorse (deadlock)
* Gestione memoria centrale (paginazione, segmentazione, memoria virtuale)
* Gestione memoria secondaria
* File system
* Sicurezza

* Strumenti per lo sviluppo, la portabilita' e la collaborazione (make, autotool, versioning)
* System Call POSIX
* Principali librerie (LibC, Pthreads, Socket...)
* Bash (uso avanzato e scripting)
* Python

* uMPS
* progetto prima fase
* progetto seconda fase

== Argomenti proposti dagli studenti ==
* System Call's e/o esempi di uso
* Instruction Set & Assembly
* Memoria Centrale, Indirizzamento, Memoria Virtuale, Swapping, Traduzione Indirizzi logici in indirizzi fisici (metodi e circuiteria usata)
* Scheduling dei processi e tipi di Scheduler
* Linguaggi nuovi (esempio: Python)
* Scripting
* Tool di programmazione (make, automake ecc)
* Differenze Linker, Loader ecc
* Crittografia e uso nei sistemi operativi
* Extreme C (esempi di uso (DIsuso) del linguaggio C.

Lezioni Anno Accademico 2015/16

2015-10-15T10:01:04Z

Edux: /* argomenti da trattare: ripasso Architettura degli Elaboratori */

''scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.''

== Lezione del 22 settembre 2015 ==

Introduzione al corso di Sistemi Operativi.

=== concetti ===
* Hardware vs. Software
* Informatica
* Scienza vs. Tecnologia
* Informazione (vs. Dato)
* Linguaggio
* Elaborazione-Memorizzazione-Comunicazione
* Algoritmo vs. Programma
* Hacker/Hacking (vs. Cracker)
* Maker
* Analogico-Digitale

== Lezione del 23 settembre 2015 ==

Storia dei Sistemi.... anche operativi.

=== concetti ===
* Architettura a livelli (Layer)
* SO come livello di astrazione (semplificazione, portabilita')
* SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
* Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
* I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
* Multitasking (perche' e' possibile? perche' e quando e' necessario?)
* Interattivita'
* TIme sharing
* Multiuser (multiutente)
* UNIX
* Personal Computer (e i sistemi operativi)

== Lezione del 30 settembre 2015 ==

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è [http://www.cs.unibo.it/~renzo/so/tools/portability3.tgz qui].

[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:
* il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.
il comando per kvm è:
kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio
* chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:47, 3 October 2015 (CEST)

=== concetti ===
* Conoscenze a breve, medio e lungo termine dell'informatica
* Linguaggio dell'Hardware
* X ''Virtuale'' (dove X rappresenta qualsiasi cosa)
* Emulazione/Simulazione
* virtualizzazione senza emulazione
* Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
* macchine virtuali
* Distribuzione e Ambiente Operativo
* [http://www.gnu.org/philosophy/open-source-misses-the-point.it.html Licenze: differenza fra Software Libero e Open Source]

== Lezione del 07 ottobre 2015 ==

Ricordo che è in sospeso una domanda: [["l'arduino ha un sistema operativo?"]]

=== Concetti: ripasso linguaggio C ===
* Compilatori vs. Interpreti
* Programmi vs. Script
* Le classi di linguaggi di programmazione
* Il "livello" dei linguaggi di programmazione
* Cosa e', cosa non e' il Linguaggio C
* [[Genesi del linguaggio C: intenzioni degli autori]]
* Le '''vere''' novita' del linguaggio C

=== concetti: ripasso architettura ===
* Modelli architetturali: von Neumann vs. Harvard
* Gerarchia di Memoria
* Cache
* Indirizzi Logici, Indirizzi Fisici
* Rilocazione

=== strumenti utilizzati durante la lezione ===
* Arduino, hardware e sistema di sviluppo. Nelle distribuzioni debian-like c'e' il pacchetto denominato "Arduino"
apt-get install arduino
* Una scheda con il solo microcontrollore atmega (nella scheda in aula era un atmega168). Ho tratto ispirazione da [http://www.tuxgraphics.org/electronics/200411/article352.shtml questo articolo di tuxgraphics]. Non e' necessario fare tutte le fasi iniziali di "software installation" perche' sono tutti software pacchettizzati debian. Se avete installato il pacchetto arduino tutti i cross compiler e lo strumento per caricare il firmware li trovate gia' disponibili.
* Il programma C senza librerie e' il seguente:
<source lang=C>
typedef unsigned char uint8_t;
typedef unsigned long uint32_t;
typedef unsigned short uint16_t;

int main(void)
{
*((volatile uint8_t *) 0x2B) = 0x00;
*((volatile uint8_t *) 0x2A) = 0xFF;

while (1) {
volatile uint16_t t;
for (t=0; t<10000; t++)
;
*((volatile uint8_t *) 0x2B) += 1;
}
return(0);
}
</source>
per vedere il led lampeggiare occorre collegarlo (con la resistenza di limitazione della corrente) al pin 2 (porta D0) poi al pin 3 (porta D1) etc... (spostate il circuito disegnato alla porta 28 nella pagina sopra citata di tuxgraphics ai pin 2, 3 etc). NB: se volete collegare le porte GPIO o i2c di arduino o di un atmega ad un raspberry PI controllate che la tensione di lavoro dell'arduino/atmega sia 3.3v e NON 5v.

== Lezione del 14 ottobre 2015 ==

Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:43, 10 October 2015 (CEST)

=== temi trattati: ripasso Linguaggio C ===
* Preprocessori: inclusione, compilazione condizionale macro
* Macro vs. funzioni inline
* Static vs. Extern
* Static vs. Auto
* Register

=== temi trattati: ripasso Architettura degli Elaboratori ===
* Bus Indirizzi, Bus Dati, Gerarchie di Bus
* Interrupt (e Trap)
* Mascheramento degli Interrupt
* Gestione nidificata degli interrupt
* DMA (Direct Memory Access)

=== temi accennati: ===
* [http://mellotanica.github.io/uARM/ uarm]: l'emulatore per il progetto

== Lezione del 21 ottobre 2015 ==

Compiti a casa:
* Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. Sono da provare e commentare. E' possibile proporne di nuovi.
* Provare a installare [http://mellotanica.github.io/uARM/ uarm: l'emulatore per il progetto] nei propri sistemi.

=== argomenti da trattare: ripasso Architettura degli Elaboratori ===
* Struttura del processore: Control Path, Data Path
* CISC vs RISC

=== altri argomenti da trattare ===

==
* System Call's e/o esempi di uso
* Instruction Set & Assembly
* Memoria Centrale, Indirizzamento, Memoria Virtuale, Swapping, Traduzione Indirizzi logici in indirizzi fisici (metodi e circuiteria usata)
* Scheduling dei processi e tipi di Scheduler
* Linguaggi nuovi (esempio: Python)
* Scripting
* Tool di programmazione (make, automake ecc)
* Differenze Linker, Loader ecc
* Crittografia e uso nei sistemi operativi
* Extreme C (esempi di uso (DIsuso) del linguaggio C. ==

== Lezione del 28 ottobre 2015 ==

Lezioni Anno Accademico 2015/16

2015-10-15T09:55:24Z

Edux: /* altri argomenti da trattare */

''scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.''

== Lezione del 22 settembre 2015 ==

Introduzione al corso di Sistemi Operativi.

=== concetti ===
* Hardware vs. Software
* Informatica
* Scienza vs. Tecnologia
* Informazione (vs. Dato)
* Linguaggio
* Elaborazione-Memorizzazione-Comunicazione
* Algoritmo vs. Programma
* Hacker/Hacking (vs. Cracker)
* Maker
* Analogico-Digitale

== Lezione del 23 settembre 2015 ==

Storia dei Sistemi.... anche operativi.

=== concetti ===
* Architettura a livelli (Layer)
* SO come livello di astrazione (semplificazione, portabilita')
* SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
* Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
* I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
* Multitasking (perche' e' possibile? perche' e quando e' necessario?)
* Interattivita'
* TIme sharing
* Multiuser (multiutente)
* UNIX
* Personal Computer (e i sistemi operativi)

== Lezione del 30 settembre 2015 ==

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è [http://www.cs.unibo.it/~renzo/so/tools/portability3.tgz qui].

[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:
* il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.
il comando per kvm è:
kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio
* chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).
[[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 09:47, 3 October 2015 (CEST)

=== concetti ===
* Conoscenze a breve, medio e lungo termine dell'informatica
* Linguaggio dell'Hardware
* X ''Virtuale'' (dove X rappresenta qualsiasi cosa)
* Emulazione/Simulazione
* virtualizzazione senza emulazione
* Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
* macchine virtuali
* Distribuzione e Ambiente Operativo
* [http://www.gnu.org/philosophy/open-source-misses-the-point.it.html Licenze: differenza fra Software Libero e Open Source]

== Lezione del 07 ottobre 2015 ==

Ricordo che è in sospeso una domanda: [["l'arduino ha un sistema operativo?"]]

=== Concetti: ripasso linguaggio C ===
* Compilatori vs. Interpreti
* Programmi vs. Script
* Le classi di linguaggi di programmazione
* Il "livello" dei linguaggi di programmazione
* Cosa e', cosa non e' il Linguaggio C
* [[Genesi del linguaggio C: intenzioni degli autori]]
* Le '''vere''' novita' del linguaggio C

=== concetti: ripasso architettura ===
* Modelli architetturali: von Neumann vs. Harvard
* Gerarchia di Memoria
* Cache
* Indirizzi Logici, Indirizzi Fisici
* Rilocazione

=== strumenti utilizzati durante la lezione ===
* Arduino, hardware e sistema di sviluppo. Nelle distribuzioni debian-like c'e' il pacchetto denominato "Arduino"
apt-get install arduino
* Una scheda con il solo microcontrollore atmega (nella scheda in aula era un atmega168). Ho tratto ispirazione da [http://www.tuxgraphics.org/electronics/200411/article352.shtml questo articolo di tuxgraphics]. Non e' necessario fare tutte le fasi iniziali di "software installation" perche' sono tutti software pacchettizzati debian. Se avete installato il pacchetto arduino tutti i cross compiler e lo strumento per caricare il firmware li trovate gia' disponibili.
* Il programma C senza librerie e' il seguente:
<source lang=C>
typedef unsigned char uint8_t;
typedef unsigned long uint32_t;
typedef unsigned short uint16_t;

int main(void)
{
*((volatile uint8_t *) 0x2B) = 0x00;
*((volatile uint8_t *) 0x2A) = 0xFF;

while (1) {
volatile uint16_t t;
for (t=0; t<10000; t++)
;
*((volatile uint8_t *) 0x2B) += 1;
}
return(0);
}
</source>
per vedere il led lampeggiare occorre collegarlo (con la resistenza di limitazione della corrente) al pin 2 (porta D0) poi al pin 3 (porta D1) etc... (spostate il circuito disegnato alla porta 28 nella pagina sopra citata di tuxgraphics ai pin 2, 3 etc). NB: se volete collegare le porte GPIO o i2c di arduino o di un atmega ad un raspberry PI controllate che la tensione di lavoro dell'arduino/atmega sia 3.3v e NON 5v.

== Lezione del 14 ottobre 2015 ==

Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 15:43, 10 October 2015 (CEST)

=== temi trattati: ripasso Linguaggio C ===
* Preprocessori: inclusione, compilazione condizionale macro
* Macro vs. funzioni inline
* Static vs. Extern
* Static vs. Auto
* Register

=== temi trattati: ripasso Architettura degli Elaboratori ===
* Bus Indirizzi, Bus Dati, Gerarchie di Bus
* Interrupt (e Trap)
* Mascheramento degli Interrupt
* Gestione nidificata degli interrupt
* DMA (Direct Memory Access)

=== temi accennati: ===
* [http://mellotanica.github.io/uARM/ uarm]: l'emulatore per il progetto

== Lezione del 21 ottobre 2015 ==

Compiti a casa:
* Nella pagina "esercizi ed esperimenti" ho proposto degli [[Esercizi di lettura di codice C]]. Sono da provare e commentare. E' possibile proporne di nuovi.
* Provare a installare [http://mellotanica.github.io/uARM/ uarm: l'emulatore per il progetto] nei propri sistemi.

=== argomenti da trattare: ripasso Architettura degli Elaboratori ===
* Struttura del processore: Control Path, Data Path
* CISC vs RISC

<nowiki><nowiki>Insert non-formatted text here</nowiki></nowiki>=== altri argomenti da trattare ===

0. System Call's e/o esempi di uso
1. Instruction Set & Assembly
2. Memoria Centrale, Indirizzamento, Memoria Virtuale, Swapping, Traduzione Indirizzi logici in indirizzi fisici (metodi e circuiteria usata)
3. Scheduling dei processi e tipi di Scheduler
4. Linguaggi nuovi (esempio: Python)
5. Scripting
6. Tool di programmazione (make, automake ecc)
7. Differenze Linker, Loader ecc
8. Crittografia e uso nei sistemi operativi
9. Extreme C (esempi di uso (DIsuso) del linguaggio C.

== Lezione del 28 ottobre 2015 ==