Entradas e Saídas: Sumário

(1)

Entradas e Sa´ıdas: Sum ´ario

• Dispositivos de E/S e seus Controladores.

• Modos de E/S.

– Programada.

– Por interrupc¸ ˜ao.

– Com DMA.

• Camadas do Subsistema de E/S.

1

Dispositivos de Entrada/Sa´ıda

• Grande variedade de dispositivos de E/S:

Dispositivo Taxa de transmiss ˜ao

Teclado 10 byte/s

Rato 100 byte/s

Modem 56 kbit/s

Linha ISDN 128 kbit/s

Impressora Laser 100 kbyte/s

Ethernet 10 Mbit/s

USB 12 Mbit/s

40

×

CD-ROM 6 Mbyte/s

Fast Ethernet 100 Mbit/s

EIDE (ATA-2) 16.7 Mbyte/s

XGA Monitor 60 Mbyte/s

Gigabit Ethernet 1 Gbit/s

PCI bus 528 Mbyte/s

Sun Gigaplane XB backplane 20 Gbyte/s

2

(2)

Classes de Dispositivos de E/S (1/2)

block devices: armazenam a informac¸ ˜ao em blocos de tamanho fixo (tpiciamente, entre 512B e 32 KB)

• Cada bloco tem o seu enderec¸o

• E poss´ıvel ler/escrever um bloco independentemente dos ´ restantes

• Exemplo: Disco.

character devices: aceitam ou entregam uma sequ ˆencia de car ´acteres:

• N ão s ão endereç áveis individualmente: n ão suportam operaç ão seek

• Exemplo: impressora, rato, teclado, porta s ´erie, interface de rede

3

Classes de Dispositivos de E/S (2/2)

• A diferenc¸a entre um block device e um character device nem sempre ´e clara. P.ex.:

– Uma fita magn ´etica (tape) a que classe pertence?

• Alguns perif ´ericos n ˜ao se encaixam bem nesta taxonomia.

P. ex.

– Rel ´ogio (clock )

– Cartas gr ´aficas: tipicamente usam mem ´oria-mapeada

• Mas ´e especialmente ´util para conceber SW independente do dispositivo:

– E.g. o sistema de ficheiros usa apenas block devices abstractos.

4

(3)

Controladores de Dispositivos de E/S (1/3)

• Componente electr ´onico que:

– controla as operac¸ ˜oes do dispositivo;

– faz a interface com o computador.

• Exemplos:

– controlador da porta-s ´erie (UART);

– controlador do disco;

– NIC (Network Interface Controller);

– VGA (Video Graphics Adapter).

5

Controladores de Dispositivos de E/S (2/3)

Monitor

Keyboard Floppy disk drive

Hard disk drive

Hard disk controller Floppy

disk controller Keyboard

controller Video

controller Memory

CPU

Bus

• Controladores t ˆem 2 conjuntos de registos para comunicar com o CPU:

registos de controlo usados para configurar, dar comandos ou l ˆer o estado do dispositivo;

registos de dados (data buffers) usados para transferir dados.

6

(4)

Controladores de Dispositivos de E/S (3/3)

• O acesso a estes registos pode ser feito via:

memory-mapped I/O: caching das posic¸ ˜oes correspondentes deve ser inibida;

instruç ˜ oes IN/OUT: a mem ória e os dispositivos de E/S usam espaços de endereçamento distintos.

Two address One address space Two address spaces

Memory

I/O ports 0xFFFF…

0

(a) (b) (c)

7

Barramentos de E/S (1/2)

• Em qualquer caso, pode usar-se barramentos distintos para aceder `a mem ´oria e aos dispositivos de E/S:

CPU Memory I/O

All addresses (memory Bus and I/O) go here

CPU Memory I/O

CPU reads and writes of memory go over this high-bandwidth bus

This memory port is to allow I/O devices access to memory

(a) (b)

• No caso de se usar memory-mapped I/O, h á que passar os endereços tamb ém para o barramento de E/S

8

(5)

Barramentos de E/S (2/2)

• No caso do PC, h ´a tipicamente 3 barramentos:

ISA bridge

Modem Mouse

PCI bridge

CPU Main

memory

SCSI USB

Local bus

Sound

card Printer Available

ISA slot ISA bus

IDE disk

Available PCI slot

Key- board

Mon- itor Graphics

adaptor Level 2

cache

Cache bus Memory bus

PCI bus

• As pontes PCI (bridges) filtram os enderec¸os.

9

E/S Programada

• O SO transfere os dados entre a mem ´oria e o dispositivo de E/S:

String to be printed User

space

Kernel space

ABCD EFGH

Printed page

(a)

ABCD EFGH

ABCD EFGH Printed

page

(b) Next A

(c) Next AB

copy_from_user(buffer, p, count); /* copy data to kernel */

for( i = 0; i < count; i++ ) { /* for all characters */

while(*printer_status_reg != READY); /* wait for printer */

*printer_data_reg = p[i]; /* output next character */

}

• Busy waiting do CPU pelo dispositivo de E/S.

10

(6)

E/S baseada em Interrupc¸ ˜ oes (1/4)

CPU Interrupt controller

Disk controller Disk drive

Current instruction Next instruction

1. Interrupt

3. Return

2. Dispatch to handler Interrupt handler

(b) (a)

1

3

4 2

• Usa o mecanismo de interrupc¸ ˜oes em HW

• Quando o dispositivo completa o comando, gera uma interrupc¸ ˜ao.

11

E/S baseada em Interrupc¸ ˜ oes (2/4)

CPU

Interrupt controller 3. CPU acks

interrupt

2. Controller issues interrupt

1. Device is finished Disk

Keyboard

Printer Clock

Bus

12

6

9 3

4 8

5 7

1 11

2 10

• Com interrupç ões vectorizadas, o CPU e o controlador de interrupç ões executam um protocolo de handshake em HW :

CPU invoca depois o interrupt handler apropriado.

12

(7)

E/S baseada em Interrupc¸ ˜ oes (3/4)

• Antes de iniciar a execuc¸ ˜ao do interrupt handler, o CPU pode guardar automaticamente algum do seu estado na stack.

Qual stack ? A do utilizador?

– O SP pode ter um valor que n ão é v álido.

– Pode apontar para o fim duma p ´agina, originando uma page-fault.

• Outro problema diz respeito à precis ão das interrupç ões:

Nas arquitecturas actuais n ão h á uma mas v árias instruç ões em execuç ão simultaneamente.

Fetch unit

Fetch unit Fetch

unit

Decode unit

Execute unit

Execute unit Execute

unit

Decode unit

Holding buffer

(a) (b)

13

E/S baseada em Interrupc¸ ˜ oes (4/4)

• O processador programa o dispositivo de E/S para executar uma operac¸ ˜ao:

copy_from_user(buffer, p, count); /* copy data to kernel */

while(*printer_status_reg != READY); /* wait for printer */

*printer_data_reg = p[0]; /* output first character */

scheduler(); /* wait for I/O */

• O dispositivo de E/S gera uma interrupç ão quando terminar a operaç ão.

• O interrupt handler processa esse pedido de interrupc¸ ˜ao:

if( count == 0 ) { unblock_process();

} else {

*printer_data_register = p[i];

count--;

i++;

}

acknowledge_interrupt();

return_from_interrupt();

14

(8)

E/S com Direct Memory Acess (DMA) (1/3)

• Para evitar a intervenç ão do CPU em cada transfer ência entre um dispositivo de E/S e a mem ória pode usar-se o mecanismo de DMA.

• Essencialmente, E/S com DMA é E/S programada excepto a transfer ência dos dados entre os dispositivos e a mem ória é realizada sob controlo do DMA e n ão do CPU.

• Alguns controladores de E/S podem solicitar ao controlador de DMA a transfer ˆencia dos dados:

Neste caso, DMA assemelha-se a E/S baseada em interrupç ões, mas . . . sem interrupç ões.

15

E/S com Direct Memory Acess (DMA) (2/3)

CPU

DMA controller

Disk controller

Main memory Buffer

1. CPU programs the DMA controller

Interrupt when done

2. DMA requests

transfer to memory 3. Data transferred

Bus 4. Ack

Address Count Control

Drive

• O CPU tem que programar o controlador de DMA com:

– O enderec¸o da mem ´oria com o buffer de dados.

– O enderec¸o do dispositivo de E/S.

– O n ´umero de bytes/palavras as transferir.

– Outros par ˆametros para controlar a transfer ˆencia, p.ex.:

∗ o sentido da transfer ˆencia;

∗ cycle stealing vs. burst mode;

16

(9)

E/S com Direct Memory Acess (DMA) (3/3)

• O c ódigo a executar para iniciar uma operaç ão de DMA, vem:

copy_from_user(buffer, p, count); /* copy data to kernel*/

set_up_DMA_io(); /* set up for DMA operation */

scheduler(); /* wait for I/O */

• O controlador de DMA gera uma interrupç ão quando a transfer ência terminar – para evitar busy-waiting.

• O interrupt handler processa esse pedido de interrupc¸ ˜ao:

acknowledge_interrupt();

unblock_process();

return_from_interrupt();

17

Camadas de SW de E/S

User-level I/O SW Device-independent OS SW

Device drivers

Interrupt handlers HW

18

(10)

Camadas Dependentes do Dispositivo de E/S

• Device driver

– SW contendo todo o conhecimento sobre o dispositivo de E/S;

– Realiza o grosso da interacc¸ ˜ao com o controlador do dispositivo.

• Interrupt handler :

– executa hand-shaking exigido pelo HW (interrupt acknowledgement);

– “desbloqueia ” o driver na origem da interrupc¸ ˜ao.

• Ver Secc¸ ˜ao 2.9, Network Adaptors, do livro:

Larry L. Peterson and Bruce S. Davie, Computer Networks: A System’s Approach, 2nd. Edition, Morgan Kaufmann Publishers (2000)

19

Device Drivers

• Parte do SO que comunica com os controladores dos dispositivos de E/S.

• Diferentes tipos de dispositivos usam diferentes

controladores e consequentemente os seus drivers s ˜ao muito diferentes:

– cada device driver processa um ´unico tipo de dispositivo, quando muito uma classe de dispositivos.

• Com as arquitecturas actuais, os device drivers t ˆem que fazer parte do kernel.

• Tipicamente os device drivers s ˜ao fornecidos pelos pr ´oprios fabricantes de dispositivos de E/S:

– device drivers s ˜ao ligados dinamicamente ao kernel;

– SOs incluem um conjunto de func¸ ˜oes que podem ser invocadas por device drivers

20

(11)

Interrupt Handler: Passos T´ıpicos

• Guardar registos que n ˜ao tenham sido guardados pelo HW.

• Inicializar um contexto para execuç ão da subrotina de processamento da interrupç ão (pode envolver, MMU).

• ACK controlador de interrupc¸ ˜oes.

• Executar a subrotina de processamento de interrupc¸ ˜ao propriamente dita:

Dever ´a ser t ˜ao curta quanto poss´ıvel.

• Desbloquear o driver (processo) que originou a interrupc¸ ˜ao:

Solicitar execuç ão do escalonador (o qual poder á desencadear uma comutaç ão de processos).

• Permitir interrupc¸ ˜oes.

A liç ão é: o processamento de interrupç ões pode ter um custo elevado (dependendo da arquitectura do sistema).

21

Camada Independente do Dispositivo de E/S

•

Garante uniformidade nos nomes:

–

Em Unix/Linux, a maioria dos dispositivos de E/S podem ser designados por uma string, nome dum ficheiro de /dev

•

Func¸ ˜oes:

–

protege o acesso aos dispositivos;

–

fornece uma interface uniforme para acesso aos device

drivers;

–

realiza buffering;

–

processa e reporta erros;

–

arbitra o acesso a dispositivos que exigem acesso em exclus ˜ao m ´utua.

Obs.- Estas s ão funç ões t´ıpicas. Por vezes, os device drivers

realizam algumas destas func¸ ˜oes.

22

(12)

Uniformidade na Interface

• Facilita a adic¸ ˜ao de drivers para novos dispositivos:

– as funç ões que devem ser suportadas s ão bem definidas;

– as funç ões do kernel que podem usar tamb ém.

Operating system Operating system

Disk driver Printer driver Keyboard driver Disk driver Printer driver Keyboard driver

(a) (b)

• Em Unix, a generalidade dos dispositivos pode ser acedida atrav ´es dum ficheiro no direct ´orio /dev:

O SO usa os mesmos mecanismos de controlo de acesso para ficheiros e para dispositivos de E/S.

23

Buffering

User process

User space

Kernel space

2 2

1 1 3

Modem Modem Modem Modem

(a) (b) (c) (d)

• Permite o desacoplamento entre a execuç ão do processo que solicita a operaç ão de E/S e a execuç ão desta.

• O SO pode suportar um conjunto de buffers, buffer pool:

– um dispositivo pode usar mais do que um buffer ; – diferentes dispositivos podem partilhar o buffer pool;

– evita-se o lock excessivo de p ´aginas.

• O uso de double buffering permite a recepç ão de dados ao mesmo tempo que outros s ão passados à aplicaç ão.

24

(13)

Buffering e SW de Rede

• Na transmiss ˜ao, buffering permite que uma chamada ao sistema retorne assim que os dados tiverem sido copiados para o kernel.

• Na recepç ão, o uso de buffers permite que o processo funcione de modo ass´ıncrono à comunicaç ão.

2

1 5

4

3

User process

Network Network

controller User

space

Kernel space

• O SW de rede pode envolver v ´arias c ´opias:

– no processamento de cada protocolo de rede, h ´a que acrescentar/remover os respectivos headers e/ou trailers.

25

User-Space SW para E/S

• Func¸ ˜oes de bibliotecas:

– que invocam chamadas ao sistema, p.ex. read();

– que formatam a sa´ıda, p.ex. printf().

• Spooling:

– Processo (daemon) que tem acesso exclusivo ao

“dispositivo” de E/S;

– Direct ´orio de spooling.

Exemplos:

– impress ˜ao;

– email.

• Protocolos de comunicaç ão (n ão muito comum).

26

(14)

Resumo do Processamento de E/S

I/O request

Layer

I/O

reply I/O functions Make I/O call; format I/O; spooling

Naming, protection, blocking, buffering, allocation Set up device registers; check status

Wake up driver when I/O completed Perform I/O operation

User processes Device-independent

software Device drivers Interrupt handlers

Hardware

27

Sincronizaç ão nas Operaç ˜ oes de E/S

• As chamadas ao sistema envolvendo operaç ões de E/S podem oferecer 3 mod êlos de sincronizaç ão:

Com bloqueio o processo bloqueia at é a operaç ão de E/S terminar:

– Para certas operaç ões de escrita, o SO apenas copia os dados de user-level para kernel-level e escalona a operaç ão.

– F ´acil de usar.

Sem bloqueio o processo n ˜ao bloqueia:

– o SO passa a informaç ão de que disp õe;

Ass´ıncrona a chamada ao sistema inicia a operaç ão, e o processo continua a sua execuç ão:

– O SO notifica o processo, usando sinais em Unix, posteriormente quando a operac¸ ˜ao terminar.

– Dif´ıcil de usar.

• Threads permitem usar apenas chamadas ao sistema com possibilidade de bloqueio.

28

(15)

E/S Ass´ıncrona em POSIX

• POSIX define v árias funç ões para E/S ass´ıncrona:

int aio_read(struct aiocb *racbp);

int aio_write(struct aiocb *racbp);

int aio_cancel(int fd, struct aiocb *acbp);

ssize_t aio_return(const struct aiocb *acbp);

int aio_error(const struct aiocb *acbp);

• struct aiocb ´e a estrutura de dados essencial:

struct aiocb {

int aio_fildes;

off_t aio_offset; /* no file position */

volatile void *aio_buf;

size_t aio_nbytes;

struct sigevent aio_sigevent; /* on completion */

int aio_lio_opcode;

int aio_reqprio; /* AIO priority */

}

29

E/S Ass´ıncrona em POSIX

• Como é que se sabe que a operaç ão terminou?

Via polling o processo pode usar aio error() para interrogar o SO sobre o resultado da operaç ão (retorna EINPROGRESS se a operaç ão ainda n ão tiver terminado).

Atrav és de notificaç ão de eventos ass´ıncronos – Sinais

– Funç ões a executar por um thread, o qual pode ser criado para processar uma única notificaç ão quando ocorre ou para processar todas as notificaç ões.

• Sinais podem ser usados para comunicac¸ ˜ao:

– quer entre processos;

– quer entre o kernel e processos.

30

(16)

E/S Ass´ıncrona em POSIX

union sigval { /* Data passed with notification */

int sival_int; /* Integer value */

void *sival_ptr; /* Pointer value */

};

struct sigevent {

int sigev_notify; /* Notification method */

int sigev_signo; /* Notification signal */

union sigval sigev_value; /* Data passed with notification */

void (*sigev_notify_function) (union sigval);

/* Function used for thread

notification (SIGEV_THREAD) */

void *sigev_notify_attributes;

/* Attributes for notification thread (SIGEV_THREAD) */

pid_t sigev_notify_thread_id;

/* ID of thread to signal (SIGEV_THREAD_ID) */

};

31

Sinais POSIX

22222222222222222222222222222222222222222222222222222222222222222

Signal Cause

22222222222222222222222222222222222222222222222222222222222222222 SIGABRT Sent to abort a process and force a core dump

22222222222222222222222222222222222222222222222222222222222222222 SIGALRM The alarm clock has gone off

22222222222222222222222222222222222222222222222222222222222222222 SIGFPE A floating-point error has occurred (e.g., division by 0) 22222222222222222222222222222222222222222222222222222222222222222

SIGHUP The phone line the process was using has been hung up 22222222222222222222222222222222222222222222222222222222222222222

SIGILL The user has hit the DEL key to interrupt the process 22222222222222222222222222222222222222222222222222222222222222222

SIGQUIT The user has hit the key requesting a core dump

22222222222222222222222222222222222222222222222222222222222222222 SIGKILL Sent to kill a process (cannot be caught or ignored)

22222222222222222222222222222222222222222222222222222222222222222 SIGPIPE The process has written to a pipe which has no readers 22222222222222222222222222222222222222222222222222222222222222222

SIGSEGV The process has referenced an invalid memory address 22222222222222222222222222222222222222222222222222222222222222222

SIGTERM Used to request that a process terminate gracefully

22222222222222222222222222222222222222222222222222222222222222222 SIGUSR1 Available for application-defined purposes

22222222222222222222222222222222222222222222222222222222222222222 SIGUSR2 Available for application-defined purposes

22222222222222222222222222222222222222222222222222222222222222222 11 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

32

(17)

Sinais

• Um processo pode indicar ao SO o que deve acontecer quando da ocorr ˆencia dum sinal:

– ignorar, nem todos os sinais podem ser ignorados;

– process á-lo, n ão é v álido para todos os sinais;

– usar processamento por omiss ˜ao, normalmente terminar o processo.

• Unix oferece 2 chamadas ao sistema:

**sigfunc signal(int signo, sigfunc handler)** para instalar signal handlers:

typedef void sigfunc(int);

int kill(pid t pid, int signo) para sinalizar um evento a um processo.

• POSIX especifica func¸ ˜oes diferentes:

O processamento de sinais é complicado porque os eventos s ão ass´ıncronos à execuç ão dos processos.

33