Entrada e Saída (I/O) em Sistemas Operacionais

A entrada e saída (I/O) é um conceito fundamental em sistemas operacionais, responsável pela comunicação entre o computador e o mundo exterior, incluindo dispositivos, arquivos e outros sistemas. Esta disciplina explora como os sistemas gerenciam operações de I/O de forma eficiente.

Neste material, exploramos os conceitos de I/O através de exemplos práticos em três contextos diferentes:

• Comandos Linux (Terminal) - Demonstrando manipulação de I/O diretamente no shell
• Shell Script - Automatizando tarefas de I/O usando scripts
• Python - Implementando operações de I/O de forma programática

Ao final deste módulo, você compreenderá como os sistemas operacionais gerenciam operações de entrada e saída e será capaz de implementar soluções eficientes de I/O em diferentes contextos.

Os comandos no Linux são úteis para demonstrar como o sistema gerencia I/O em arquivos, dispositivos e processos.

Leitura de arquivos (entrada)

cat arquivo.txt

Escrita em arquivos (saída)

echo "Texto de exemplo" > arquivo.txt

Redirecionamento de entrada

sort < arquivo.txt

Pipes (conexão de I/O entre processos)

ls -l | grep ".txt"

Leitura de dispositivos de I/O

dd if=/dev/zero of=saida.bin bs=1M count=10

Monitoramento de I/O

iostat

Scripts em shell podem combinar comandos Linux para automatizar tarefas de I/O, como leitura, escrita e manipulação de dados.

Script que lê um arquivo, processa e escreve em outro

#!/bin/bash
input_file="entrada.txt"
output_file="saida.txt"

# Lê o arquivo de entrada e filtra linhas com a palavra "teste"
grep "teste" $input_file > $output_file

# Conta o número de linhas processadas
echo "Linhas processadas: $(wc -l < $output_file)"

Monitoramento de escrita em disco

#!/bin/bash
echo "Escrevendo 100 MB em um arquivo..."
dd if=/dev/zero of=teste.bin bs=1M count=100
echo "Tamanho do arquivo criado: $(ls -lh teste.bin | awk '{print $5}')"

Python é ideal para ilustrar I/O de forma programática, manipulando arquivos, dispositivos e até sockets para comunicação.

Leitura e escrita de arquivos

# Leitura de um arquivo
with open('entrada.txt', 'r') as arquivo_entrada:
    conteudo = arquivo_entrada.read()
    print("Conteúdo lido:", conteudo)

# Escrita em um arquivo
with open('saida.txt', 'w') as arquivo_saida:
    arquivo_saida.write("Texto escrito via Python\n")

Processamento linha a linha (I/O eficiente)

with open('entrada.txt', 'r') as entrada:
    with open('saida.txt', 'w') as saida:
        for linha in entrada:
            if 'teste' in linha:
                saida.write(linha)

Leitura de dispositivo (exemplo com /dev/urandom)

with open('/dev/urandom', 'rb') as dispositivo:
    dados = dispositivo.read(1024)  # Lê 1 KB de dados aleatórios
    print("Bytes lidos:", len(dados))

Em sistemas operacionais, os conceitos de buffer, drivers, chamadas de sistema e escalonamento de I/O são fundamentais para entender como os dispositivos interagem com o kernel.

• Buffers: Memória intermediária para melhorar a eficiência de I/O.
• Drivers: Interface entre o SO e o hardware de I/O.
• Chamadas de sistema: Solicitações feitas por programas ao kernel para realizar I/O.
• Escalonamento de I/O: Técnicas como FCFS, SSTF e SCAN otimizam a ordem de acesso aos discos.

1. Comandos Linux para operações de E/S

# Criar um arquivo e escrever nele
echo "Conteúdo de exemplo" > arquivo.txt

# Ler o conteúdo de um arquivo
cat arquivo.txt

# Copiar um arquivo (E/S de disco)
cp arquivo.txt arquivo_copia.txt

# Monitorar operações de E/S em tempo real
sudo iotop -o

# Redirecionar saída para um arquivo
ls -l > lista_arquivos.txt

# Redirecionar erro para um arquivo
comando_inexistente 2> erro.log

# Usar pipe para redirecionar entre processos
cat arquivo.txt | grep "exemplo"

# Listar discos e partições
lsblk

# Monitorar estatísticas de E/S
iostat -d 1

2. Shell Script para operações de E/S

#!/bin/bash
arquivo_entrada="dados.txt"
arquivo_saida="resultado.txt"

if [ -f "$arquivo_entrada" ]; then
    echo "Processando $arquivo_entrada..."
    grep "sucesso" "$arquivo_entrada" > "$arquivo_saida"
    echo "Resultado salvo em $arquivo_saida"
else
    echo "Erro: $arquivo_entrada não encontrado!" >&2
    exit 1
fi

3. Python para operações de E/S

# Escrever em um arquivo
with open("exemplo.txt", "w") as arquivo:
    arquivo.write("Dados de exemplo\n")

# Ler de um arquivo
with open("exemplo.txt", "r") as arquivo:
    conteudo = arquivo.read()
    print(conteudo)

import serial

# Comunicação serial
ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)
ser.write(b'Hello, UART!\n')
resposta = ser.readline()
print(resposta.decode())
ser.close()

import psutil

disk_io = psutil.disk_io_counters()
print(f"Leitura: {disk_io.read_bytes / 1024:.2f} KB")
print(f"Escrita: {disk_io.write_bytes / 1024:.2f} KB")

Conceitos relacionados ilustrados:

• Chamadas de sistema: open(), read(), write()
• Buffering: Redirecionamento (>, |) e arquivos temporários
• Dispositivos de bloco/caractere: lsblk e serial
• Sincronização de E/S: flush() ou sync
• Monitoramento: iotop, iostat, psutil

1. Execute os comandos Linux apresentados e redirecione entradas e saídas entre arquivos.
2. Crie um script shell para filtrar arquivos com extensão específica em um diretório.
3. Desenvolva um programa Python que leia um arquivo grande e conte palavras específicas.
4. Utilize o comando iostat para monitorar o desempenho de I/O em diferentes cenários.