enric morancho - studies.ac.upc.edu

Xxxxxxxxxx

XXxxxxxxx

116

UN

IX: C

rid

es a

l sis

tem

a i c

om

and

es. P

ract

ique

s am

b E

INA

ME

nric

Mo

ranc

ho

9 xxxxxxxxxxxxxxxxxx

EDICIONS UPC

COMPTE¡¡¡ AQUESTA COBERTA NO ES REAL, ES UN LLIBRE QUE NOMES S’HA PENJAT A VIRTUALSES FA UNA COBERTA JA QUE TE ASSIGNAT UN NUMERO DE COL.LECCIÓ, I SERVEIX PER PER FER LES PORTADETES, PERO LA COBERTA NO ES FA FISICAMENT, JA QUE REPETEIXO, EL LLIBRE NOMES ES PENJARA A VIRTUALS, PERO NO TE VERSIO PAPER

AULA POLITÈCNICA/ INFORMÀTICA

Enric Morancho

UNIX: Crides al sistema i comandesPractiques amb EINAM

AULA POLITÈCNICA 116


EDICIONS UPC

AULA POLITÈCNICA/ INFORMÀTICA

Enric Morancho


Primera edició: març 2006

Disseny de la coberta: Jordi Calvet

© Enric Morancho, 2006

© Edicions UPC, 2006 Edicions de la Universitat Politècnica de Catalunya, SL Jordi Girona Salgado 31, 08034 Barcelona Tel.: 934 016 883 Fax: 934 015 885 Edicions Virtuals: www.edicionsupc.es E-mail: [email protected]

ISBN: 84-8301-857-8

Són rigorosament prohibides, sense l'autorització escrita dels titulars del copyright, sota les sancions establertes a la llei, la reproducció total o parcial d'aquesta obra per qualsevol procediment, inclosos la reprografia i el tractament informàtic, i la distribució d'exemplars mitjançant lloguer o préstec públics.

Índex i

Índex

Introducció ................................................................................................................1

1 Einam .....................................................................................................................31.1 Què és Einam? ............................................................................................................. 31.2 Posada en funcionament d’Einam des del CD ............................................................. 41.3 Instal·lació d’Einam al disc dur ..................................................................................... 51.4 Algunes consideracions sobre el treball amb Einam .................................................... 7

1.4.1 Usuaris ............................................................................................................................... 71.4.2 Cònsoles virtuals ................................................................................................................ 71.4.3 Persistència de les dades ................................................................................................... 71.4.4 Aturar Einam ....................................................................................................................... 8

1.5 Més informació ............................................................................................................. 9

2 Unix des de l'intèrpret de comandes .................................................................112.1 Introducció .................................................................................................................. 11

2.1.1 Intèrpret de comandes (shell) ........................................................................................... 112.1.2 Manual del sistema ........................................................................................................... 11

2.2 Sistema de fitxers ....................................................................................................... 122.2.1 Característiques del sistema de fitxers d’Unix .................................................................. 122.2.2 Navegació al sistema de fitxers ........................................................................................ 132.2.3 Creació/Destrucció de directoris ....................................................................................... 132.2.4 Visualització del contingut d'un directori ........................................................................... 132.2.5 Noms relatius i absoluts ................................................................................................... 152.2.6 Comandes bàsiques relacionades amb fitxers ................................................................. 152.2.7 Proteccions ....................................................................................................................... 162.2.8 Directoris habituals ........................................................................................................... 172.2.9 Metacaràcters per enumerar fitxers .................................................................................. 172.2.10 Edició de textos .............................................................................................................. 18

2.3 Gestió de processos ................................................................................................... 182.3.1 Noció de procés ................................................................................................................ 182.3.2 Informació sobre processos: comandes ps i top ........................................................... 182.3.3 Eliminació de processos: comanda kill ........................................................................ 192.3.4 Modalitats d'execució de comandes ................................................................................. 202.3.5 Canvi de modalitat d'execució d'una comanda ................................................................ 202.3.6 Redirecció d'entrada/sortida ............................................................................................. 212.3.7 Comunicació de processos mitjançant pipes ................................................................... 21

2.4 Variables d'entorn ....................................................................................................... 222.5 Algunes comandes usuals .......................................................................................... 23

2.5.1 Filtres ................................................................................................................................ 232.5.2 D’altres comandes ............................................................................................................ 26

2.6 Més informació ........................................................................................................... 27

ii Índex

3 Programació de shellscripts ..............................................................................293.1 Introducció .................................................................................................................. 293.2 Comandes que acostumen a estar presents als shellscripts ..................................... 293.3 Cometes ..................................................................................................................... 313.4 Variables ..................................................................................................................... 323.5 Control de flux ............................................................................................................ 323.6 Pas d’arguments als shellscripts ................................................................................ 353.7 D’altres característiques ............................................................................................. 35

3.7.1 Gestió de senyals (signals) .............................................................................................. 353.7.2 Funcions ........................................................................................................................... 363.7.3 Depuració dels shellscripts ............................................................................................... 36

3.8 Alguns consells per programar shellscripts ................................................................ 363.9 Més informació ........................................................................................................... 37

4 Entorn de desenvolupament d'aplicacions ......................................................394.1 Edició de programes ................................................................................................... 394.2 Compilació/Muntatge .................................................................................................. 41

4.2.1 Aplicacions amb un únic fitxer font ................................................................................... 414.2.2 Aplicacions amb diversos fitxers font ............................................................................... 414.2.3 Eina make ......................................................................................................................... 41

4.3 Biblioteques creades per l’usuari ................................................................................ 434.3.1 Biblioteques estàtiques (extensió .a) ............................................................................. 434.3.2 Biblioteques dinàmiques (extensió .so) .......................................................................... 444.3.3 Biblioteques dinàmiques carregades en temps d'execució (run time) .............................. 45

4.4 D’altres eines .............................................................................................................. 464.5 Instal·lació d'aplicacions obtingudes a la xarxa .......................................................... 47

4.5.1 Aplicació instal·lada: indent ........................................................................................... 48

4.6 Més informació ........................................................................................................... 48

5 Gestió de processos a UNIX (1/2) ......................................................................495.1 Des de l’intèrpret de comandes .................................................................................. 49

5.1.1 Comandes ........................................................................................................................ 495.1.2 Explorant el directori /proc ............................................................................................. 51

5.2 Crides al sistema Unix ................................................................................................ 525.2.1 Crida al sistema fork ...................................................................................................... 525.2.2 Crida al sistema wait ...................................................................................................... 535.2.3 Crides al sistema exec (execv, execl,...) ........................................................... 535.2.4 Crida al sistema exit ...................................................................................................... 54

5.3 Més informació ........................................................................................................... 55

Índex iii

6 Gestió de processos a UNIX (2/2) ......................................................................576.1 Descripció general de l'aplicació ................................................................................ 576.2 Biblioteca libuso.a .................................................................................................. 576.3 Exercici de programació ............................................................................................. 58

6.3.1 Pas 1: creació de N jugadors seqüencials ....................................................................... 586.3.2 Pas 2: generació de N jugadors concurrents ................................................................... 596.3.3 Pas 3: generació de resultats per part del procés croupier .............................................. 59

7 Sistema de fitxers Unix .......................................................................................617.1 Obtenció d'informació sobre fitxers ............................................................................ 617.2 Proteccions ................................................................................................................. 617.3 Muntatge de dispositius d'emmagatzemament .......................................................... 647.4 Enllaços (links) ........................................................................................................... 657.5 Ocupació d'espai ........................................................................................................ 667.6 Compactació i compressió de Fitxers ......................................................................... 677.7 Búsqueda de fitxers: comanda find ......................................................................... 687.8 Més informació ........................................................................................................... 70

8 Entrada/sortida a UNIX (1/2) ...............................................................................718.1 Crides al sistema Unix ................................................................................................ 71

8.1.1 Crides al sistema read i write ....................................................................................... 718.1.2 Crides al sistema open i close ....................................................................................... 728.1.3 Crida al sistema lseek .................................................................................................... 738.1.4 Consideracions d'eficiència .............................................................................................. 73

8.2 Exercici de programació: compressor/descompressor de fitxers ............................... 738.2.1 Descompressor sense paràmetres ................................................................................... 748.2.2 Descompressor amb paràmetres ..................................................................................... 758.2.3 Descompressor amb seqüències majors de 255 caràcters .............................................. 758.2.4 Compressor ...................................................................................................................... 76

8.3 Des de l’intèrpret de comandes .................................................................................. 768.3.1 Comandes ........................................................................................................................ 768.3.2 Explorant el directori /proc ............................................................................................. 76

8.4 Més informació ........................................................................................................... 77

9 Entrada/sortida a UNIX (2/2) ...............................................................................799.1 Introducció .................................................................................................................. 799.2 Crides al sistema ........................................................................................................ 79

9.2.1 Servidors TCP .................................................................................................................. 809.2.2 Clients TCP ...................................................................................................................... 809.2.3 Disseny de servidors TCP ................................................................................................ 81

iv Índex

9.3 Exercici de programació: Servidor Web ..................................................................... 829.3.1 Servidor iteratiu ................................................................................................................ 829.3.2 Servidor amb suport a pàgines dinàmiques ..................................................................... 839.3.3 Servidor concurrent (sense límit a la concurrència) ......................................................... 839.3.4 Servidor concurrent (limitant la concurrència) .................................................................. 839.3.5 Servidor amb pas de paràmetres a pàgines dinàmiques ................................................. 83

9.4 Comandes .................................................................................................................. 849.5 Més informació ........................................................................................................... 84

10 Memòria .............................................................................................................8510.1 Des de l’intèrpret de comandes ................................................................................ 85

10.1.1 Comandes ...................................................................................................................... 8510.1.2 Explorant el directori /proc ........................................................................................... 85

10.2 Accessos invàlids a memòria ................................................................................... 8610.2.1 Des de mode d’execució sistema ................................................................................... 8610.2.2 Des de mode d’execució usuari ..................................................................................... 8710.2.3 Anàlisi de fitxers core amb el debugger gdb .................................................................. 87

10.3 Modificació dinàmica de l’espai lògic ........................................................................ 8810.3.1 Regió de codi .................................................................................................................. 8810.3.2 Regió de pila ................................................................................................................... 8810.3.3 Regió de dades .............................................................................................................. 89

10.4 Accessos erronis a memòria .................................................................................... 9010.5 Més informació ......................................................................................................... 91

Introducció 1

Introducció

Des d’uns anys ençà, l’UPC ofereix a tots els seus membres un CD amb una distribució delsistema operatiu GNU/Linux. Aquesta distribució s’anomena Einam i es realitzada per uncol·lectiu de membres de l’UPC relacionats amb la Càtedra de programari lliure de l’UPC.

Una de les principals característiques d’aquesta distribució de GNU/Linux és ser Live-CD, ésa dir, el CD proporcionat és capaç de posar en funcionament el sistema operatiu GNU/Linuxsense necessitat d’instal·lar cap tipus de software al disc dur de l’ordinador.

Aquesta iniciativa possibilita que GNU/Linux arribi a tota la comunitat de l’UPC, en especial apersones que treballen en entorns on GNU/Linux no està excessivament estès i a personesgens interessades en haver de formatejar i/o particionar el disc dur del seu PC per podertreballar amb GNU/Linux.

Aquest llibre pretén facilitar que els usuaris d’Einam (o de qualsevol altra distribució Linux oversió d’UNIX) sàpiguen interaccionar a baix nivell amb el sistema operatiu GNU/Linux.Concretament, s’explicarà el nivell de crides al sistema i el nivell de comandes.

Com que aquest llibre té un enfocament eminentment pràctic, es proporcionaran al lector unseguit de programes d’exemple i suggeriran al lector les modificacions que haurà de realitzarals programes d’exemple. Per facilitar aquesta tasca, tots aquests exemples seranaccessibles via web a http://personals.ac.upc.edu/enricm/ucsc.

Tots els exemples presentants en aquest document han estat provats en la distribució Einamdel curs 2005-06. Els resultats dels exemples a d’altres distribucions Einam han de ser moltsimilars, tot i que poden existir petites diferències.

En grans línies, aquest llibre està dirigit als següents col·lectius:

Estudiants de sistemes operatius (cursos introductoris a nivell d’usuari on estreballi al nivell de crides al sistema i/o d’intèrpret de comandes)

Persones interessades a conèixer les comandes que ens permeten obtenir mésinformació sobre quin és l’estat del sistema operatiu Linux i dels seus recursos(processador, disc, ...)

Persones amb coneixements de programació en algun llenguatge d’alt nivell (perexemple C) i que estiguin interessades a saber com interaccionar amb el sistemaoperatiu Linux des dels seus programes

2 Pràctiques d’Unix amb Einam

Per finalitzar aquesta introducció, presentem un petit resum dels capítols del llibre:

El capítol 1 explica les característiques principals de la distribució Einam, composar-la en marxa i, en cas que el lector hi estigui interessat, com instal·lar aquestadistribució al disc dur.

El capítol 2 descriu les comandes més importants típiques de totes les distribucionsGNU/Linux.

El capítol 3 presenta el llenguatge de programació que s’utilitza als shellscripts.

El capítol 4 presenta les eines més típiques per al desenvolupament d’aplicacionsen un llenguatge de programació d’alt nivell (per exemple, llenguatge C).

El capítol 5 aprofundeix en les comandes de Linux relacionades amb la gestió deprocessos i introdueix les crides al sistema relacionades amb la gestió deprocessos.

El capítol 6 planteja la realització d’una aplicació que utilitza les crides al sistemarelacionades amb la gestió de processos.

El capítol 7 aprofundeix en les comandes Linux relacionades amb el sistema defitxers.

El capítol 8 aprofundeix en les comandes Linux relacionades amb l’entrada/sortidai introdueix les crides al sistema relacionades amb l’entrada/sortida.

El capítol 9 planteja la realització d’una aplicació que utilitza les crides al sistemarelacionades amb comunicació de processos executant-se a màquines diferents.

El capítol 10 ens presenta les comandes Linux que ens poden donar informaciósobre l’ocupació de la memòria i les crides al sistema relacionades amb la gestióde memòria. També es veuran alguns possibles efectes d’executar programes querealitzen accessos incorrectes a memòria.

1 Einam 3

1 Einam

Aquest capítol descriu què és l’Einam, com posar-lo en funcionament, com instal·lar-lo al discdur d'un ordinador i algunes consideracions que heu de tenir en compte al treballar sobreEinam (o qualsevol altra distribució de Linux).

1.1 QUÈ ÉS EINAM?

Einam és una distribució Live-CD del sistema operatiu GNU/Linux que ha estatdesenvolupada a la UPC.

En línies generals, el sistema operatiu és el software encarregat de gestionar elhardware del nostre ordinador (processador, teclat, pantalla, disc dur, ...) i d’oferirals usuaris una sèrie de funcionalitats que amaguen les característiques de mésbaix nivell del hardware. Per tant, el sistema operatiu actuarà com un intermediarientre els usuaris i el hardware. Sistemes operatius diferents (per exempleWindows-XP i GNU/Linux) es diferencien, entre altres coses, en les funcionalitatsque ofereixen als seus usuaris.

GNU/Linux és un sistema operatiu lliure (el seu codi font és disponible i els usuaristenen la llibertat d’executar-lo, estudiar-lo, modificar-lo i redistribuir-lo). Inicialment,GNU/Linux va ser desenvolupat per disposar d’un sistema operatiu de la famíliad’Unix per a ordinadors amb processadors Intel (386, 486, Pentium,...), però aratambé pot executar-se sobre altres tipus de processadors.Dues característiques importants d’Unix són que és un sistema operatiumultiprograma (permet l’execució simultània de diversos programesconcurrentment) i multiusuari (el sistema identifica els usuaris que l’utilitzen i limitales accions que pot realitzar cada usuari).

Una distribució Live-CD permet posar en marxa un sistema operatiu sense haverd’instal·lar cap tipus de software al disc dur de l’ordinador. Això permetfamiliaritzar-se amb un sistema operatiu sense haver de fer operacionspotencialment compromeses sobre el disc dur de l’ordinador. La distribucióLive-CD més popular és Knoppix, de la qual deriva actualment Einam.

Per tant, la principal diferència entre Einam i altres distribucions GNU/Linux que no sónLive-CD (Red Hat, Fedora, Suse ...) és que Einam no necessita ser instal·lada al disc dur percomençar a treballar amb ella. L’inconvenient que presenten les distribucions Live-CD és queprecisen tractar de forma especial tota aquella informació que vulgueu emmagatzemar deforma permanent.


1.2 POSADA EN FUNCIONAMENT D’EINAM DES DEL CD

Com que Einam és una distribució Live-CD, la seva posada en funcionament (arrencada) ésmolt senzilla. Únicament cal posar el CD d’Einam al reproductor de CD’s del PC/portàtil ireiniciar el vostre ordinador.

En aquest punt podeu tenir un petit problema. Tot i que heu introduït el CD d’Einam, el vostreordinador pot arrencar el sistema operatiu que ja teníeu instal·lat al disc dur. Aquest fet ésdegut a la seqüència d’inici (boot sequence) que teniu definida. Com que els ordinadorspoden buscar el sistema operatiu a diversos tipus de dispositius diferents (disc dur, CD, USB,xarxa, disquet), els ordinadors tenen definida una ordenació d’aquests dispositius. En posaren marxa l’ordinador, aquest intenta arrencar des d’aquests dispositius seguint l’ordreestablert. Si el primer dispositiu no respon, passa a intentar-ho amb el segon, i aixísuccessivament; en el moment que aconsegueix arrencar des d’un dispositiu, deixad’intentar-ho amb la resta de dispositius. Si a l’ordenació de dispositius que fa servir el vostreordinador el disc dur és en una posició anterior que el CD, el vostre ordinador arrencarà ambel sistema operatiu instal·lat al disc dur i no arrencarà amb el CD. Podeu solucionar aquestproblema de dues formes:

Fixeu-vos en els missatges que apareixen per pantalla en posar en marxal’ordinador. Típicament, apareix un missatge del tipus "Prémer F1 per configurar"(és a dir, Press F1 to enter setup); de totes formes, és possible que la tecla aprémer sigui una altra (per exemple Del). Prement aquest tecla podreu entrar en unmenú de configuració on haureu de buscar on està definida la seqüència d’inici(Boot Sequence) i modificar-la de forma que es consulti el CD abans que el discdur.

A molts ordinadors, si premeu F12 poc després d’encendre el PC, aquest usmostrarà un menú des del qual podeu seleccionar el dispositiu que voleu fer servirper arrencar l’ordinador.

Si el vostre ordinador pot arrencar des del CD, veureu que apareixerà un gràfic amb unmissatge del tipus "EINAM, knoppix per a l’UPC" i, a la línia inferior de la pantalla, boot: Sino premeu cap tecla, en uns segons es posarà en marxa l’arrencada d’Einam. Si premeuENTER, l’arrencada s’iniciarà immediatament. Ara bé, si premeu F2 ò F3 podreu modificar laforma com es carregarà Einam; de totes formes, a no ser que tingueu algun problema amb lacàrrega d’Einam o vulgueu explorar d’altres opcions d’arrencada, no us hauria de fer faltamodificar l’arrencada d’Einam.

L’arranc d’Einam intenta reconèixer tot el vostre hardware i posa en execució el sistemaoperatiu GNU/Linux i l’entorn gràfic. En condicions normals, ja tindreu en marxa Einam ipodreu començar a treballar-hi.

La següent figura mostra l’entorn gràfic de la distribució Einam del curs 2005-06. A l’entorngràfic podreu trobar un seguit d’icones així com una barra d’eines on, quan cliqueu amb elmouse, apareix un seguit de menús. Aquests menus us permetran executar alguns

1 Einam 5

programes i realitzar algunes operacions sobre el sistema. És convenient que feu un cop d’ulla aquests menús per familiaritzar-vos amb les opcions disponibles. Altres distribucions deGNU/Linux poden variar la distribució d’aquests elements gràfics (per exemple, la barrad’eines es pot trobar a la part superior de la pantalla) i contingut dels menus.

Tot i que Einam pot reconèixer molts tipus de hardware, és possible que no pugui reconèixertot el vostre hardware correctament. En aquest cas, sí que necessitareu modificar la formacom es carrega Einam. Per exemple, si teniu problemes amb la identificació de la tarja devídeo (es pot donar aquest cas a alguns portàtils), podeu intentar modificar la mida del bufferde pantalla (framebuffer). De totes formes, el millor que podeu fer és dirigir-vos a la direccióde web de suport d’Einam (acostuma a estar indicada al propi CD d’Einam) i deixar unmissatge indicant quin és el vostre hardware concret i descrivint el vostre problema.

1.3 INSTAL·LACIÓ D’EINAM AL DISC DUR

Tot i que Einam és una distribució Live-CD, si esteu interessats podeu instal·lar-la al vostredisc dur; d’aquesta forma podreu arrencar-la sense necessitar el CD. Instal·lar Einam al discdur millorarà el temps de resposta d’Einam (el disc dur és un dispositiu més ràpid que el CD ino cal emmagatzemar-hi els fitxers en un format comprimit) i us permetrà treballar de formamés natural amb el sistema.

EscriptoriBarra d’einesMenús Icones


Com que instal·lar Einam al disc dur pot requerir crear/destruir particions al vostre disc dur,abans d’iniciar la instal·lació és aconsellable que actualitzeu les vostres còpies de seguretatde les dades importants del disc dur.

Com a requisits per instal·lar Einam al disc dur, el més important és disposar de,aproximadament, 2.7 Gigabytes lliures (i que no pertanyin a cap altra partició1 del disc dur). Sidisposeu d’espai lliure però està ja assignat a alguna partició, al llarg de la instal·lació podreudeassignar aquest espai lliure.

Per instal·lar Einam al disc dur cal arrencar el PC and el CD Einam. Un cop posat en marxa,heu d’executar el programa d'instal·lació mitjançant el menú "UPC→Instal·lantEinam→Instal·lació" (a "UPC→Instal·lant Einam→Ajuda" podeu trobar una ajuda al procésd’instal·lació).

El programa d’instal·lació realitza un seguit de passos:

Creació de les particions necessàries (per instal·lar Einam cal disposar de duesparticions lliures, una per als fitxers -d’uns 2.2 Gigabytes- i una altra per al swap-entre 0.2 i 0.5 Gigabytes). Si és necessari, podreu reduir de mida particions jaexistents i fins i tot moure particions per aconseguir compactar l’espai lliure.

Inicialització dels password que voleu assignar a l'usuari knoppix (usuari senseprivilegis) i a l’usuari root (usuari privilegiat, administrador del sistema). Ésimportant que no els oblideu (especialment el de l’usuari root).

Instal·lació d’un gestor d’arrencada (els més típics són LILO i GRUB). Aquest tipusde programes és molt útil quan a un mateix disc dur hi ha instal·lats diversossistemes operatius. En arrencar des del disc dur apareixerà un menú amb tots elssistemes operatius instal·lats al disc dur i podreu triar amb quin d’ells voleu botar.

Còpia dels fitxers des del CD al disc dur (trigarà uns 20 minuts).

Preguntes diverses (seleccioneu les opcions per defecte).

Finalment, és aconsellable que permeteu la creació d’un disquet d'arrencada.Aquest disquet un permetrà posar en marxa Einam en cas que hi hagi algunproblema amb el gestor d’arrencada del vostre ordinador.

El proper cop que poseu en marxa la màquina (havent tret el CD) hauria d’aparèixer el menúdel gestor d’arrencada i podríeu triar arrencar l’Einam que heu instal·lat al disc dur. Adiferència de quan arrenqueu des de CD, per poder començar a treballar amb el sistema

1.L’espai d’emmagatzemament dels discos durs es divideix en particions. L’usuari pot decidir elnombre i la mida de les particions. Les particions permeten organitzar millor la informació (perexemple, dedicar una partició al sistema operatiu, i una altra a fitxers d’usuari) i instal·lar varis sistemesoperatius al mateix disc dur (cada sistema operatiu a una partició diferent).

1 Einam 7

haureu d’introduir el nom d’usuari amb el qual vulgueu treballar i el password que li heuassignat.

1.4 ALGUNES CONSIDERACIONS SOBRE EL TREBALL AMB EINAM

1.4.1 Usuaris

Per omissió, Einam té dos usuaris: root és l'usuari administrador i que disposa de tots elsprivilegis mentre que knoppix és un usuari no privilegiat.

Si arrenqueu Einam des del CD, l’entorn gràfic correspon a l’usuari knoppix. Pertreballar com a usuari root podeu buscar als menús de la barra d’eines una opcióanomenada Cònsola de root.

Si arrenqueu Einam des del disc dur, a l’entrar al sistema haureu d’especificar coma quin usuari voleu entrar al sistema i autentificar la vostra identitat amb elcorresponent password. Si ho considereu oportú, l’usuari root pot crear noususuaris utilitzant la comanda adduser parametritzant-la amb el nom d'usuari acrear.

És molt important que treballeu com a usuari root únicament quan sigui imprescindiblefer-ho ja que, com que és un usuari privilegiat, està autoritzat a esborrar qualsevol fitxer,modificar la configuració de la màquina,... De forma involuntària podeu perdre informació.

1.4.2 Cònsoles virtuals

En arrencar Einam es posa en marxa l’entorn gràfic. Si voleu, podeu treballar en mode texteutilitzant les cònsoles virtuals. Per accedir-hi heu de prémer simultàniament les tres teclessegüents: Ctrl, Alt i F1 (o F2, F3,...)

Si heu arrencat Einam des de CD, en aquestes cònsoles podreu treballar com al’usuari root.

Si heu arrencat Einam des del disc dur, per poder treballar en aquestes cònsoleshaureu d’identificar-vos indicant el nom d’usuari i el seu password.

En aquestes cònsoles podreu teclejar els programes que voleu executar. Per tornar al modegràfic heu de prèmer Ctrl-Alt-F5 (si heu arrencat des del CD) o Ctrl-Alt-F7 (si heu arrencat desdel disc dur).

1.4.3 Persistència de les dades

Si arrenqueu Einam des de CD, tots els fitxers que es creïn mentre treballeu amb Einam sónvolàtils. És a dir, quan sortiu del sistema es perdran.


Si voleu conservar algun dels fitxers creats haureu d’utilitzar algun dels dispositiusd’emmagatzemament del vostre ordinador (disc dur, disquet, USB ...) . Per poder utilitzar-loscaldrà que realitzeu una operació anomenada muntatge (mount). El muntatge també serànecessari si us interessa llegir fitxers que teniu emmagatzemats a algun d’aquests dispositiusd’emmagatzemament des d’Einam.

Per muntar un dispositiu és precís identificar el dispositiu a muntar.

Respecte al disc dur, el més normal és que s’identifiqui com a /dev/hda; si enteniu dos, el segon disc dur s’anomena /dev/hdb,... Com que els discos durss’organitzen en particions, haureu d’especificar la partició que voleu muntar. Lesparticions existents dins d’un disc dur (per exemple el /dev/hda) s’identifiquemcom a /dev/hda1, /dev/hda2 ... Per veure les particions que existeixen al vostre disc dur, podeu executar lacomanda fdisk -l /dev/hda (per executar-la haureu d’accedir a una cònsolavirtual com s’ha explicat al capítol 1.4.2 o crear un terminal com s’explicarà alcapítol 2.1.1, teclejar la comanda i prémer ENTER). Veureu la llista de particionsdel disc dur així com la seva mida i quin format tenen (formats windows2 - FAT,NTFS-, format linux -ext2, ext3- ...).

Típicament, el lector de disquets s’identifica amb el nom /dev/fd0, el lector decdroms amb /dev/cdrom, els dispositius USB /dev/sda1, /dev/sda2 ...

Per muntar el dispositiu heu d’executar la comanda mount seguida de l’identificador deldispositiu; per exemple mount /dev/hda1 Això farà que aparegui una icona a l’escriptorique us permetrà navegar pels fitxers que teniu a la partició. Si voleu fer referència a aquestsfitxers des de les aplicacions instal·lades a Einam, típicament haurem de situar-vos aldirectori /mnt i buscar el directori relatiu al dispositiu muntat.

Per desmuntar el dispositiu heu d’executar la comanda umount seguida de l’identificador dedispositiu.

Al capítol 7.3 es tornarà a tractar la qüestió del muntatge de dispositius.

Si heu optat per instal·lar Einam al disc dur, Einam crearà una partició al disc dur peremmagatzemar fitxers de forma permanent. De totes formes, si necessiteu accedir a algunaaltra partició del disc dur o a dispositius extraïbles, haureu de fer el muntatge del dispositiu dela mateixa forma que s’ha explicat anteriorment.

1.4.4 Aturar Einam

Per aturar Einam (shutdown) ordenadament heu de buscar als menús de la barra l’opcióSortir (Exit). També podeu fer-ho fent que l’usuari root executi la comanda

2.Sobre particions FAT podreu fer operacions de lectura i d’escriptura de fitxers. En canvi, sobreparticions NTFS només podreu fer operacions de lectura.

1 Einam 9

/sbin/shutdhown -h now Algunes distribucions GNU/Linux també es poden aturarprement simultàniament les tres tecles Ctrl, Alt i Del.

Aturar ordenadament Einam és importantíssim en el cas que hagueu modificat fitxersresidents a particions del disc dur, disquets, dispositius USB,... que no hagin estatdesmuntats.

Això és degut al fet que, per motius d’eficiència, GNU/Linux no actualitza les escripturesimmediatament al dispositiu. Per tant, apagar l’ordinador directament utilitzant l’interruptor potprovocar que algunes escriptures no hagin tingut temps d’actualitzar-se al dispositiud’emmagatzemament, i això provocarà que els fitxers no tinguin el contingut esperat.

Si atureu ordenament Einam, de forma implícita, aquest desmuntarà tots els dispositiusd’emmagatzemament que tingueu muntats. D’aquesta forma, totes les escriptures pendentss’actualitzaran al dispositiu.

Finalment, si heu instal·lat Einam al disc dur i no sortiu de forma ordenada, el proper cop queel poseu en marxa Einam des del disc dur detectarà aquesta situació. Això provocarà ques’inicïi una comprovació de la integritat de les dades de la partició de disc. Aquestacomprovació pot retardar molt sensiblement la posada en marxa d’Einam.

1.5 MÉS INFORMACIÓ

A http://einam.lafarga.cpl.upc.edu/index.php podeu posar-vos en contacte amb elscreadors de la distribució Einam i amb altres usuaris de la distribució. Disposeud’un fòrum on plantejar els vostres problemes; per exemple, reconeixement de latarja de vídeo, configuració de l’accés a la xarxa,...

Si al vostre disc dur coexisteixen Windows i Einam, és possible que quan estigueutreballant amb Windows us interessi accedir a dades emmagatzemades a lapartició de disc creada per Einam. Windows no incorpora cap utilitat per poder feraquest accés, però per poder realitzar l’accés podeu instal·lar-vos una aplicacióWindows anomenada LTOOLS (http://www.it.fht-esslingen.de/~zimmerma/software/ltools.html).

A la wikipèdia (http://www.wikipedia.org/) podeu obtenir informació respecte a lahistòria de Linux i de Knoppix.

Podeu trobar informació respecte altres distribucions Live-CD de Linux com araKnoppix (http://knoppix.org), Ubuntu (http://www.ubuntulinux.org), Slax(http://slax.linux-live.org) ...

Per obtenir més informació sobre què és el codi lliure (free sofware) i noconfondre´l amb codi gratuït, podeu consultar http://www.fsf.org .

2 Unix des de l'intèrpret de comandes 11

2 Unix des de l'intèrpret de comandes

Aquest capítol presenta els coneixements necessaris per començar a treballar sobre unintèrpret de comandes típic d’Unix. De totes formes, algunes de les comandes explicades enaquest capítol es veuran amb més detall a capítols posteriors d’aquest document. S’assumeixque heu botat l'ordinador des del CD Einam.

2.1 INTRODUCCIÓ

2.1.1 Intèrpret de comandes (shell)

L’intèrpret de comandes (shell) és una aplicació que llegeix les comandes teclejades perl’usuari, les analitza, i invoca els serveis pertinents del sistema operatiu per a l’execució deles comandes.

Si esteu en mode gràfic, per iniciar l’execució de l’intèrpret de comandes cal obrir una cònsolade shell. Per fer-ho, situeu l’indicador del mouse en alguna zona lliure de la pantalla, premeuel botó dret i busqueu alguna opció semblant a Obrir terminal; de totes formes, normalment hihaurà alguna icona a l’escriptori o a la barra d’eines que us el permetrà iniciar directament).Una altra forma seria accedint a alguna cònsola virtual (capítol 1.4.2).

Als sistemes Unix hi ha diversos intèrprets de comandes disponibles: sh (Bourne shell), csh(Cshell), zsh (Zshell), bash (Bourne again shell) ... S’assumeix que utilitzeu bash, l’intèrpretde comandes configurat per omissió a Einam.

L'intèrpret de comandes mostra un indicador (prompt) quan està preparat per rebre les ordresde l'usuari. A la distribució Einam el prompt és semblant a knoppix@ttyp0[knoppix]$, onel primer knoppix indica l’identificador d’usuari, ttyp0 identifica la finestra on s’executal’intèrpret de comandes i el segon knoppix indica el directori de treball. En aquest documents’assumeix que el prompt és prompt$.

2.1.2 Manual del sistema

Els sistemes Unix disposen d’una versió del manual del sistema en format electrònic. Elmanual conté informació sobre les comandes, crides al sistema, rutines de biblioteca, etc. Peraccedir-hi, executeu la comanda man parametrizant-la amb el nom de comanda, crida alsistema,... de la qual vulgueu informació (exemple3: man write o man fprintf). Pernavegar dins de la informació mostrada utilitzeu les tecles especials AvPg, RePg, Ini i Fi.Per buscar una paraula dins de la informació premeu /, escriviu la paraula a buscar i torneu aprémer return. Per finalitzar la visualització del manual cal prémer la tecla q.

El manual s’estructura en vuit seccions. La secció 1 informa sobre les comandes, la 2 sobrecrides al sistema i la 3 sobre rutines de biblioteca. A l’exemple anterior (man fprintf),

3.Per provar els exemples, heu d’escriure el text mostrat en negreta i acabar-lo amb un salt de línia.


observeu que a la primera línia apareix printf(3); això indica que fprintf és una rutinade biblioteca. Si la informació sol·licitada existeix a diverses seccions (per exemple write éscomanda i crida al sistema), per omissió la comanda man només mostra la informació trobadaa la primera de les seccions relacionades (en aquest cas, la secció 1); per consultar l’altrasecció cal indicar el número de secció que volem consultar (en aquest cas, man 2 write).

Quan accediu al manual d’alguna comanda, us mostrarà quins paràmetres té la comanda. Siel manual mostra alguns paràmetres de les comandes entre claudàtors ([]), això indica queaquests paràmetres són opcionals.

2.2 SISTEMA DE FITXERS

Podem considerar que un fitxer no és més que un conjunt de bytes que té associat un nom.Aquest nom permet que els usuaris puguin fer referència al fitxer i accedir-hi sense haver depreocupar-se de com s’emmagatzema el fitxer al disc dur; els serveis del sistema operatiuseran els responsables de les operacions de baix nivell.

El sistema de fitxers és la part del sistema operatiu encarregada de l’administració de lesdades als dispositius d’emmagatzemament secundari (disc dur). Proporciona mecanismesper emmagatzemar la informació de forma segura i confidencial, tot i que un usuari ha detenir la possibilitat de compartir els seus fitxers amb altres usuaris.

2.2.1 Característiques del sistema de fitxers d’Unix

A continuació s'indiquen algunes de les característiques del sistema de fitxers Unix:

Els fitxers estan organitzats en directoris. Un directori és un fitxer gestionat pelsistema operatiu que permet localitzar els fitxers que són al directori. A més, undirectori pot contenir fitxers de tipus directori.

El sistema de fitxers Unix té una estructura jeràrquica. Existeix un directori arrel(root directory) representat amb el símbol / que representa el punt d’inici del’estructura.

Cada fitxer de tipus directori conté dos fitxers especials (. i ..). El primer (.) fareferència al propi directori i el segon (..) fa referència al directori superior dins dela jerarquia de directoris.

Dins d’aquesta estructura, cada usuari del sistema té assignat un directori on potguardar els seus fitxers. Aquest directori és coneix com a directori d’usuari (homedirectory) i a la distribució que feu servir és /home/knoppix.

Cada usuari pot associar proteccions als seus fitxers i directoris.


El nom d’un fitxer pot tenir fins a 255 caràcters. Els fitxers on el nom comenci per .(punt) són ocults. Tot i que tots els caràcters són vàlids dins del nom d’un fitxer, ésaconsellable que no apareguin metacaràcters4 del shell com *, ?, &, $.

A la distribució Einam, el primer nivell del sistema de fitxers té aquesta estructura:

El sistema de fitxers d’Unix us resultarà familiar ja que el d’MsDOS i el de Windows estaninspirats en el d’Unix. Una de les diferències més visibles és que el caràcter separador dedirectoris és diferent: a Unix és / mentre que a MsDOS i Windows és \.

2.2.2 Navegació al sistema de fitxers

Tot intèrpret de comandes té associat un directori de treball (també anomenat directori actualo current/working directory) dins del sistema de fitxers. Quan inicieu un intèrpret decomandes, el seu directori de treball, per omissió, coincideix amb el directori d’usuari.

Per saber quin és el directori de treball heu d'executar la comanda pwd (print workingdirectory), i es mostrarà el camí que hi ha des del directori arrel fins el directori de treball.

Per modificar el directori de treball associat a un intèrpret de comandes cal utilitzar lacomanda cd (change directory). Per exemple, la comanda cd .. ens permet pujar un nivelldintre de l'estructura (a diferència de MsDOS, a Unix és precís separar la comanda cd i eldirectori .. amb un espai en blanc); també permet anar directament a un directori (perexemple, cd / o cd /etc). Per tornar al directori d'usuari podeu executar la comanda cdsense paràmetres (executeu a continuació pwd per comprovar-ho).

2.2.3 Creació/Destrucció de directoris

Les comandes que permeten crear i eliminar directoris són mkdir i rmdir. Totes duesesperen com a paràmetre el nom del directori a crear o a eliminar respectivament.

2.2.4 Visualització del contingut d'un directori

La comanda ls mostra quins fitxers estan emmagatzemants a un directori. Per exemple,situeu-vos al directori arrel i executeu ls: es mostrarà la llista de fitxers del directori.

4.Els metacaràcters són caràcters que el shell interpreta de forma especial.

/

bin boot cdrom dev etc home KNOPPIX lib mnt opt proc ramdisk root sbin tmp usr varnone sys


La comanda ls admet paràmetres, com ara -l, que permeten obtenir més informació sobreels fitxers. Un resultat possible de la comanda ls -l podria ser:

Observeu que cada línia està associada a un fitxer, i la seva interpretació és la següent:

El primer caràcter indica el tipus del fitxer: ordinari (-), directori (d), un enllaç (l),...Un enllaç (link) permet que un mateix fitxer tingui dos (o més) noms diferents, peròsense replicar el contingut del fitxer. Al vostre cas, fer cd /bin és equivalent a fercd /KNOPPIX/bin ja que /bin és un link a /KNOPPIX/bin.El color de la línia indica el tipus de fitxer: el blanc representa un fitxer ordinari, blaufosc un fitxer de tipus directori, blau clar un link, verd un executable ...

Els següents 9 caràcters indiquen les proteccions del fitxer (s’explicarà al capítol2.2.7).

El següent nombre està relacionat amb el nombre de links al fitxer.

A continuació hi ha dos identificadors. Respectivament, indiquen qui és l'usuaripropietari del fitxer i a quin grup d'usuaris (s’explicarà al capítol 2.2.7) pertany.

El següent nombre representa la mida (en bytes) del fitxer.

Posteriorment trobem la data de darrera modificació del fitxer.

Finalment figura el nom del fitxer (i si es tracta d’un enllaç -link-, la sevaequivalència).

Per omissió, la comanda ls no mostra informació sobre els fitxers ocults. Perquè la comandals llisti els fitxers ocults (els seu nom comença per .) cal passar-li el paràmetre -a.

prompt$ cd /prompt$ lsbin cdrom etc KNOPPIX mnt opt ramdisk sbin tmp varboot dev home lib none proc boot sys usrprompt$

prompt$ ls -llrwxrwxrwx 1 root root 12 2005-05-23 13:07 bin -> /KNOPPIX/binlrwxrwxrwx 1 root root 13 2005-05-23 13:07 boot -> /KNOPPIX/boodr-xr-xr-x 7 root root 2048 2005-05-23 13:07 cdrom...prompt$


2.2.5 Noms relatius i absoluts

Sempre que invoqueu una comanda que necessiti com a paràmetre un nom de fitxer odirectori, podeu escollir entre dues formes d'especificar el nom:

Nom absolut: camí des del directori arrel fins al fitxer (sempre començarà per / i elcaràcter / separarà els directoris).

Nom relatiu: camí des del directori actual fins al fitxer (mai començarà per /).

Exemple: si el vostre directori de treball és /etc/X11 i voleu situar-vos sobre el directori/home/knoppix, podeu fer-ho indicant el nom absolut del fitxer (cd /home/knoppix) oindicant el nom relatiu respecte el directori de treball (cd ../../home/knoppix).

2.2.6 Comandes bàsiques relacionades amb fitxers

Les comandes que realitzen les operacions més comunes sobre fitxers són:

rm : esborra (remove) un fitxer. Té com a paràmetre el nom del fitxer a esborrar. Enfunció de com estigui configurada la vostra distribució, és possible que us demaniconfirmació (prémer y) abans d’esborrar el fitxer.

cp : còpia (copy) un fitxer. Els seus paràmetres són o bé el(s) nom(s) del(s) fitxer(s)a copiar i el directori destí, o bé el nom del fitxer a copiar i el nom que tindrà lacòpia. Amb el paràmetre -r pot copiar una estructura de directoris.

mv: canvia el nom (move) d'un fitxer. Cal indicar el nom antic i el nom nou. Tambépermet moure un fitxer d’un directori a un altre.

cat: mostra el contingut d'un fitxer. Té com a paràmetre el nom del fitxer.

more: mostra el contingut d'un fitxer pàgina a pàgina. Cal indicar el nom del fitxer.


Exemple:

2.2.7 Proteccions

Tots els usuaris d'un sistema Unix estan treballant sobre el mateix sistema de fitxers. Pergarantir la confidencialitat de les dades apareix el concepte de proteccions dels fitxers. Lesproteccions determinen les operacions que pot fer cada usuari sobre cada fitxer.

Es consideren tres tipus d'usuaris: l’usuari propietari del fitxer5, els usuaris quepertanyen al seu mateix grup d'usuaris6 i la resta d'usuaris de la màquina.

Es consideren tres tipus d’operacions: lectura (r), escriptura (w) i execució (x).

Com ja heu vist, les proteccions d’un fitxer es representen amb nou caràcters. Els tresprimers indiquen les operacions que pot realitzar el propietari del fitxer, els tres següents fanreferència a les operacions realitzables pels usuaris del mateix grup i els tres darrers fanreferència a les operacions realitzables per la resta d'usuaris de la màquina. Per exemple, lesproteccions rwxr----- indiquen que el propietari pot fer totes les operacions sobre el fitxer(rwx), que els membres del seu grup només poden fer lectures (r--) i que la resta d'usuarisno pot fer cap operació sobre el fitxer (---).

Per modificar les proteccions d'un fitxer s'utilitza la comanda chmod, que codifica lesproteccions seguint el codi r=4, w=2 i x=1 i sumant els drets de cada tipus d'usuari7. És a dir,

5.Al fitxer /etc/passwd podeu veure tots els usuaris del sistema. La primera paraula de cada línia (ésa dir, fins al caràcter :) és l’identificador d’un usuari del sistema. La resta de la línia conté dades del’usuari com el seu directori d’usuari, el shell que té associat,... Veureu informació dels usuarisknoppix, root,...6.El fitxer /etc/group conté informació sobre els grups d’usuaris definits al sistema.7.També podeu pensar en la codificació en base 2 de les proteccions: r=100, w=010 i x=001. Com aexemple, les proteccions rwxr-x--- es representarien com a 111101000.

prompt$ cd Ens situem al directori d’usuariprompt$ mkdir direc Creació d’un directoriprompt$ cd direc Ens situem al directori creatprompt$ cp /etc/passwd . Copiem /etc/passwd al directori actualprompt$ ls Llistem fitxers directori actualpasswd Apareix la còpia del fitxer /etc/passwdprompt$ mv passwd copia Canviem nom del fitxer passwdprompt$ ls Tornem a llistar fitxerscopiaprompt$ cat copia Ens mostra el contingut del fitxer copiaroot:x:0:0:root:/root:/bin/bash...prompt$ rm copia Esborrem fitxer copiaprompt$ ls Tornem a llistar fitxersprompt$


les proteccions rwxr-x--- es representen com 750 (4+2+1, 4+0+1, 0+0+0). Per exemple,chmod 631 file fa que file passi a tenir proteccions rw--wx--x.

Al capítol 7.2 s’explicarà un altre mecanisme de protecció de fitxers, les ACL (Access ControlLists).

2.2.8 Directoris habituals

Presentem els directoris més habituals de tot sistema de fitxers Unix i el seu contingut:

/bin i /usr/bin: executables de moltes comandes (ls, cp,...) i aplicacions

/dev : fitxers que representen els dispositius del sistema (terminals,...)

/etc : dades de configuració (fitxer de passwords /etc/passwd ...)

/home : directoris d'usuari dels usuaris de la màquina

/proc: informació sobre els programes en execució a la màquina

/tmp : arxius temporals dels processos

/usr/include : fitxers de capçalera (fitxers amb extensió .h) de les crides alsistema

/usr/lib : biblioteques de funcions

2.2.9 Metacaràcters per enumerar fitxers

L'intèrpret de comandes permet utilitzar metacaràcters per fer referència a diversos fitxers decop o a directoris d'ús comú.

* representa qualsevol seqüència de caràcters. ls /bin/l*n mostraria els fitxersdel directori /bin amb nom que comença per l i acaba en n.

? representa un caràcter qualsevol. ls /bin/l???n mostraria els fitxers ambnom que comença per l, acaba en n, i té exactament 5 caràcters.

[ ] permeten representar un caràcter dins d'un rang. ls /bin/[aeiou]*[a-f]mostraria els fitxers amb nom iniciat per vocal, i acabat en un caràcter entre a i f.

~ representa el directori d'usuari8. ls ~ mostraria els fitxers del nostre directorid'usuari independentment de quin és el nostre directori actual.

8.Per escriure el caràcter ~ cal prémer simultàniament AltGr 4.


Sempre que el shell trobi una enumeració de fitxers feta amb metacaràcters, el shell lasubstituirà per la llista de fitxers enumerats. D’aquesta substitució en direm expansió delsmetacaràcters.

2.2.10 Edició de textos

L'editor de textos més característic de Unix és el vi; de totes formes, moltes màquines Unixtambé tenen instal·lats altres editors com ara joe, emacs, nedit, vim, xedit ... Tot i queno és el més potent, el més intuitïu és xedit. Si continueu treballant a Unix, es recomanaque estudieu el funcionament d’editors més potents com vi, vim o emacs. Al capítol 4veureu algunes de les funcionalitats avançades de l’editor vim.

Per editar un fitxer heu d'indicar el nom del editor a utilitzar i el nom del fitxer a editar. Un copfetes les modificacions desitjades, cal actualitzar el contingut del fitxer a disc.

2.3 GESTIÓ DE PROCESSOS

2.3.1 Noció de procés

Un procés és un programa en execució. Cada intèrpret de comandes en execució és unprocés. Normalment, l'intèrpret de comandes crea un nou procés per a cada comanda quellegeix i aquest nou procés executa la comanda indicada; quan aquest nou procés finalitza,l'intèrpret de comandes torna a mostrar el prompt del sistema.

2.3.2 Informació sobre processos: comandes ps i top

La comanda ps informa respecte els processos existents a la màquina. Per omissió, informasobre els processos associats a la finestra des de la qual hem executat ps, però podemparametritzar-la perquè doni més informació sobre els processos (paràmetres -f, -l o u),informació sobre tots els processos d'un usuari (paràmetre -u i el nom de l'usuari) o sobretots els processos de la màquina (paràmetre -e). Per exemple:

Per practicar

2.1 Utilitzant cd i ls, exploreu els directoris habituals del sistema de fitxers Unix.

2.2 Creeu un directori al vostre home directory, copieu-hi el fitxer /bin/ls, i feuque s'anomeni ls2.

2.3 Situeu-vos al directori arrel (cd /). Sense canviar de directori, copieu el fitxer/etc/passwd al directori que heu creat abans.

2.4 Busqueu al manual del sistema la utilitat del paràmetre -r de la comanda rm.

2.5 Consulteu al manual del sistema els paràmetres de la comanda ls.


A continuació es descriu el significat d’algunes d’aquestes columnes:

PID: identificador del procés. És un nombre enter.

TTY: terminal associat al procés. Al directori /dev hi trobareu un fitxer amb aquestnom (en aquest cas /dev/ttyp0) que us permetrà accedir al terminal.

TIME: indica el temps de CPU que porta consumit el procés.

CMD: comanda responsable de la creació del procés.

USER/UID: usuari propietari del procés (pot aparèixer en format numèric).

PPID: identificador del procés pare. Tot procés Unix és fill d'algun altre procés.

SZ/VSZ/RSS : diferents formes de mesurar la memòria ocupada pel procés.

STIME: instant en què es va iniciar l'execució del procés.

Una altra possibilitat per veure els processos que hi ha a la màquina és utilitzar la comandatop. Aquesta comanda mostra periòdicament informació del nombre de processos existents,l'ocupació global de la memòria i quins són els processos que estan fent més ús delprocessador. Per acabar l'execució de top cal prémer la tecla q.

2.3.3 Eliminació de processos: comanda kill

Si voleu eliminar un procés immediatament, podeu utilitzar la comanda kill; calparametrizar-la amb -9 i el pid del procés a matar.

prompt$ ps PID TTY TIME CMD 677 ttyp0 00:00:00 bash Procés corresponent a l’intèrpret de comandes 706 ttyp0 00:00:00 ps El propi procés psprompt$ ps -lF S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD...prompt$ ps -fUID PID PPID C STIME TTY TIME CMD...prompt$ ps uUSER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND...prompt$ ps -ef...


2.3.4 Modalitats d'execució de comandes

Per omissió, un cop llegida una comanda, l'intèrpret de comandes no torna a mostrar elprompt fins que la comanda hagi finalitzat la seva execució. Aquesta forma d'executar lescomandes rep el nom de foreground (en primer pla).

Els intèrprets de comandes també permeten iniciar l'execució d'una comanda de forma que elprompt es mostri abans que la comanda finalitzi la seva execució. Aquesta forma d'executarles comandes rep el nom d'execució en background (en segon pla). A Unix, podeu executarcomandes en background utilitzant el metacaràcter &.

A mode d'exemple, inicialment s'invoca la comanda emacs en foreground. Podeu veure queel shell no està disponible fins que sortim de l’editor. En canvi, després s’invoca emacs enbackground (metacaràcter &), per tant, el shell està disponible inmediatament.

Els nombres que apareixen a l'iniciar l'execució d'una comanda en background representenun identificador de comanda i l'identificador de procés. Quan la comanda en backgroundfinalitza la seva execució, apareix un missatge indicant-ho (Done).

2.3.5 Canvi de modalitat d'execució d'una comanda

El següent diagrama mostra com canviar el mode d'execució d'una comanda. Per aturar unacomanda que s'executi en foreground cal prémer les tecles Ctrl i Z (prement Ctrl i Cprovocaríem la finalització de la comanda, tot i que algunes comandes són immunes alCtrl-C). La resta de transicions s'efectuen mitjançant les comandes indicades.

prompt$ emacsEl shell no està disponible fins que sortim de l’editor

prompt$ emacs &[1] 1665prompt$ ps El shell passa a estar disponible i podem editar...prompt$...[1] Done emacs

Foreground Background

AturatCtrl-Z

bg

fg

kill -9 pidfgDestrucció Ctrl-C Destrucció

(Stopped)


2.3.6 Redirecció d'entrada/sortida

A Unix, els processos no llegeixen directament del teclat ni escriuen directament a pantalla,sinó que ho fan sobre uns dispositius intermitjos anomenats entrada estàndard (stdin) isortida estàndard (stdout). Per omissió, aquests dispositius intermitjos fan referència al teclati a la pantalla respectivament, però des de l'intèrpret de comandes podeu modificar aquestaassociació (redireccionar els canals estàndard).

El metacaràcter < redirecciona l'entrada estàndard a un fitxer; > redirecciona la sortidaestàndard a un fitxer, >> afegeix la sortida estàndard al contingut actual d’un fitxer.

A mode d'exemple, podeu executar la comanda ls redireccionant la seva sortida estàndardal fitxer abc i després executar la comanda wc (compta el nombre de caràcters, paraules ilínies) fent que la seva entrada estàndard sigui el fitxer abc.

Els missatges d’error de les comandes no s’escriuen a la sortida estàndard sinó ques’escriuen a un dispositiu anomenat canal d’error (stderr). Per omissió, aquest dispositiu estàassociat a la pantalla però el podem redireccionar9 al fitxer que vulgueu amb elsmetacaràcters 2>. Per exemple, assumint que el fitxer KKKK no existeix al directori actual, lsKKKK mostra un missatge d’error; ls KKKK 2> err redirecciona el missatge d’error al fitxererr; finalment, ls -l KKKK 2> /dev/null es desfà del missatge d’error ja que/dev/null és un fitxer que actua com una paperera: fa desaparèixer tota la informació quehi enviem.

2.3.7 Comunicació de processos mitjançant pipes

L'intèrpret de comandes permet executar concurrentment dos o més processos i facilitar quees comuniquin mitjançant el model de comunicació productor-consumidor. Per fer-ho calutilitzar el metacaràcter |, que indica que volem comunicar la sortida estàndard d'un procésamb l'entrada estàndard d'un altre; és a dir, tot el que un procés escrigui per la seva sortidaestàndard anirà a parar a l'entrada estàndard de l’altre. Per tant, executant ls /bin | wcobtindreu el mateix resultat que abans.

Aquest metacaràcter permet combinar diverses comandes senzilles i aconseguir resultatscomplexos. Les comandes que acostumen a combinar-se utilitzant pipes són conegudes coma filtres. Posteriorment (capítol 2.5.1) es descriurà el funcionament dels filtres més típics.

9.La forma de redireccionar el canal d’error a intèrprets de comandes que no siguin bash pot serdiferent a l’explicada en aquest document.

prompt$ ls /bin > abcpropmpt% ls... abc ...prompt$ wc < abc

88 88 536prompt$


2.4 VARIABLES D'ENTORN

Els intèrprets de comandes permeten definir un seguit de variables i assignar valors aaquestes variables. Les variables poden prendre valors de tipus alfanumèric.

Els programes poden consultar el valor d'alguna variable i, en funció d'aquest, podenmodificar el seu comportament. Per exemple, la variable TERM indica el tipus de terminal queesteu utilitzant. En funció del valor d'aquesta variable, un programa pot presentar els seusresultats de forma més o menys sofisticada (per exemple, utilitzant colors).

Per veure totes les variables definides actualment podeu utilitzar la comanda set. Si voleuveure el valor d'una única variable podeu utilitzar la comanda echo i el metacaràcter $ (indicaque fem referència a una variable). Per exemple, echo $TERM

Per definir o modificar el valor d’una variable cal fer servir l’operador =. Per exemple:

prompt$ a=hola; echo $a Assigna a la variable a la paraula hola. Fixeu-vosque no hi ha cap espai entre el nom de la variable, el signe = i el valor. Elmetacaràcter ; és un separador de comandes (equivalent a executar la primeracomanda i a continuació la segona comanda).

prompt$ b=(pri seg ter); echo ${b[*]}; echo ${b[1]} Inicialitza lavariable b com un vector. El primer echo mostra el contingut sencer del vector i elsegon mostra el contingut del segon element (la primera posició del vector és la 0).

A continuació es detalla el significat d'algunes de les variables més usuals:

PATH: conté la llista de directoris on el shell busca els fitxers executablescorresponents a les comandes. La cerca es realitza en l’ordre en què els directorisestan emmagatzemats a la variable; la cerca finalitza en el moment en què es trobaun directori que contingui l'executable; si no se’n troba cap, el shell mostra unmissatge d'error com ara Command not found. Per afegir un directori al finald’aquesta llista podeu executar PATH=$PATH:nou_directori

Per practicar

2.6 Llisteu tots els processos que té en execució l'usuari root.

2.7 Interpreteu el significat de la informació mostrada per la comanda top.

2.8 Entreu al manual de la màquina (per exemple, man ps) i premeu les teclesCtlr-Z. Què ha passat? Feu el necessari per continuar la consulta del manual.

2.9 Obriu dues finestres i executeu comandes des d'una d'elles tot redireccionant lasortida cap al fitxer que representa el terminal de l’altra (repasseu el significatdel camp TTY mostrat per ps i el contingut del directori /dev).


TERM: indica el tipus del terminal en ús, per exemple vt100, xterm ...

HOME: conté el directori d'usuari.

LINES i COLUMNS: contenen la mida (en línies i columnes) de la finestra ons’executa l’intèrpret de comandes.

Per acabar, unes consideracions finals sobre variables

És habitual que, a l'entrar al sistema, ens interessi que les variables tinguin unvalor diferent al valor per omissió. Per fer aquests canvis automàticament podemaprofitar el fitxer ~/.bashrc. Les comandes que hi siguin presents s’executaranautomàticament cada cop que inicieu un intèrpret de comandes bash.

Si voleu que les variables siguin heretades pels processos creats des del shell, calutilitzar la comanda export. Consulteu el manual del sistema.

Per esborrar una variable cal utilitzar la comanda unset.

2.5 ALGUNES COMANDES USUALS

Es presentaran algunes de les comandes més usuals d’Unix amb exemples del seu ús.Consulteu el manual per veure més possibilitats de les comandes.

2.5.1 Filtres

Els filtres són comandes que acostumen a rebre dades per l’entrada estàndard, processar-lesi escriure el resultat per la seva sortida estàndard. Els filtres acostumen a estar comunicatsamb altres comandes mitjançant pipes (capítol 2.3.7).

Es presenten exemples d’ús d’aquests filtres. És aconsellable executar-los pas a pas perveure l’efecte de cada filtre; és a dir, si heu de provarls -l /etc | sort -k5 -n -r | more executeu primer ls -l /etc, desprésls -l /etc | sort -k5 -n -r i finalmentls -l /etc | sort -k5 -n -r | more. D’aquesta forma veureu l’efecte de cada filtrequina influència tenen els paràmetres indicats.

Per practicar

2.10 Podria haver-hi alguna diferència entre executar les comandes ps i /bin/ps ?


moreMostra per pàgines les dades rebudes per l’entrada estàndard. Prement la barra d’espaipodeu avançar una pàgina i prement q podeu finalitzar l’execució de more. Exemple:

prompt$ ls -l /bin | more

sortOrdena les línies d’un fitxer d’entrada segons el criteri que indiquem. Podeu ordenaralfabèticament o numèricament, ascendentment o descendentment, definir la part de la líniaque s’ha de considerar per ordenar ... Exemples:

prompt$ sort /etc/passwd Mostra per stdout el resultat d’ordenaralfabèticament el fitxer /etc/passwd considerant el contingut sencer de la línia.

prompt$ sort -t: -k3 -n /etc/passwd Mostra el resultat d’ordenarnumèricament (paràmetre -n) pel tercer camp (paràmetre -k3), considerant que elcaràcter separador de camps és : (paràmetre -t:). Proveu-la també sense el -n.

prompt$ ls -l /etc | sort -k5 -n -r | more Ordena el resultat dels -l /etc pel cinquè camp (la mida del fitxer) descendentment (paràmetre-r). Fem servir el separador de camps per omissió (un o més espais en blanc).

cutSelecciona una porció de totes les línies d’un fitxer d’entrada. Podem especificar la porció dela línia com a un rang de caràcters o com a un rang de camps. Exemples:

prompt$ cut -d: -f3,5 /etc/passwd Mostra el tercer i el cinquè campde totes les línies de /etc/passwd considerant que el separador de camps és :(paràmetre -d). Fixeu-vos que l’especificació del caràcter separador de campsdifereix respecte el filtre sort.

prompt$ ls -l /etc/passwd | cut -c2-10 Mostra únicament lesproteccions del fitxer /etc/passwd (esteu seleccionant el rang de caràcters entrela columna 2 i la 10).

headSelecciona les primeres línies o els primers caràcters d’un fitxer. Exemple:

prompt$ sort /etc/passwd | head -2 | cut -d: -f1 Mostra els dosprimers identificadors d’usuari (alfabèticament parlant) de la màquina.


tail Selecciona les darreres línies o els darrers caràcters d’un fitxer. Exemple:

prompt$ ls -l /etc | sort -k5 -n | tail -2 Mostra els dos fitxersmés grans de /etc.

trFa una traducció caràcter a caràcter de l’entrada estàndard. Exemples:

prompt$ tr aeiou AEIOU </etc/passwd Mostra el resultat de substituir lesvocals minúscules per majúscules de /etc/passwd. El primer paràmetre (aeiou)són els caràcters a substituir; el segon, per quins substituir-los (correspondència ua u).

prompt$ ls -l / | tr -s ' ' Mostra el resultat de ls -l separant elsdiferents camps per un únic espai en blanc (la comanda tr està substituint totesles aparicions consecutives de l’espai en blanc per un únic espai en blanc).

grepMostra les línies que continguin una o diverses cadenes de caràcters a unes posicionsdeterminades. La comanda grep disposa d’un seguit de metacaràcters per a especificar lescadenes de caràcters; cal no confondre’ls amb els del shell. Exemples:

prompt$ grep ro /etc/passwd Mostra les línies de /etc/passwd quecontenen ro a qualsevol posició

prompt$ ls -l /etc | grep ^d Mostra les línies retornades per ls quecomencen per d (metacaràcter ^), és a dir, mostra els directoris de /etc.

prompt$ ls -l /etc | grep ^-......r-x Mostra les línies retornades perls que comencen per -, continuen amb 6 caràcters qualsevol (metacaràcter .) icontinuen amb els caràcters r-x.

prompt$ grep bash$ /etc/passwd Mostra les línies del fitxer /etc/passwdque acaben amb bash (metacaràcter $).

prompt$ grep -v /bin/bash /etc/passwd Mostra les línies del fitxer/etc/passwd que no contenen (paràmetre -v) la paraula /bin/bash.

prompt$ grep ^n[aeiou] /etc/passwd Mostra les línies de /etc/passwdque comencen per na, ne, ni, no o nu (els metacaràcters [] especifiquen rangs).

prompt$ grep -r SIGUSR1 /usr/include Busca en el directori/usr/include i recursivament a tots els seus subdirectoris, fitxers que continguinla paraula SIGUSR1.


wcCompta el nombre de línies, paraules i caràcters d’un fitxer. Exemples:

prompt$ wc -c /etc/passwd Mostra el nombre de caràcters (paràmetre-c) de /etc/passwd.

prompt$ ls -l / | grep ^d | wc -l Mostra el nombre de línies(paràmetre -l) retornades per ls -l /|grep ^d, que ha de coindicir amb elnombre de directoris del directori arrel (/).

uniqCompacta en una línia totes les línies repetides i consecutives. Exemple:

prompt$ ps -e | cut -c25- | sort | uniq -c Per a cada comanda enexecució, mostra el nombre de processos que l’estan executant (assumeix queps -e mostra el nom de la comanda a partir de la columna 25).

D’altres filtres: sed i awkDos dels filtres més potents són sed i awk. Descriure en detall el seu funcionament està foradels objectius d’aquest document.

sed: per cada línia de l’entrada estàndard, pot realitzar manipulacions a nivell decaràcters com ara substitució de caràcters, eliminació de paraules, intercanvi deparaules, eliminació de línies ...

awk: per cada línia de l’entrada estàndard executa un programa subministrat perl’usuari i que està escrit en un llenguatge de programació semblant a C. Aquestprograma pot realitzar, entre d’altres operacions, operacions aritmètiques amb lesdades contingudes a cada línia.

2.5.2 D’altres comandes

dateMostra la data actual del sistema.

which / typeMostren el nom absolut del fitxer executable corresponent a una comanda. Exemples:

prompt$ which top

prompt$ type ls



Podeu trobar més informació de qualsevol comanda utilitzant el manual delsistema (comanda man parametritzada amb el nom de la comanda de la qualvolgueu obtenir més informació).

Tot i que utilitzeu freqüentment alguna comanda, és convenient fer un cop d’ullperiòdicament al manual de la comanda ja que us pot permetre descobrir algunnova funcionalitat de la comanda.

Si usualment invoqueu una comanda amb els mateixos paràmetres, o voleuutilitzar d’altres noms per algunes comandes, podeu utilitzar un mecanismeanomenat alias. Per exemple, si executeu alias list=’ls -l’, a partird’aquest moment, cada cop que indiqueu que voleu executar list, l’intèrpret decomandes realment executarà ls -l.

Per practicar

2.11 Escriviu una comanda que mostri el nom del segon fitxer més gran de /etc.

2.12 Escriviu una comanda que mostri els 5 processos que consumeixen mésmemòria.

2.13 Escriviu una comanda que digui quants processos estan executant un programadeterminat (per exemple, bash, xterm ...)

2.14 Escriviu una comanda que indiqui el nombre de fitxers ocults del directori actual.

2.15 Escriviu una comanda que mostri el nombre d’usuaris que tenen un identificadorque comença per m.

2.16 Utilitzant el camp PPID mostrat per la comanda ps, obtingueu tota la genealogiadel procés que executa el vostre intèrpret de comandes.

3 Programació de shellscripts 29

3 Programació de shellscripts

L’objectiu d’aquest capítol és explicar els fonaments de la programació de shellscripts sobrel’intèrpret de comandes bash. A la pàgina web de suport trobareu els fitxers referenciats aldocument.

3.1 INTRODUCCIÓ

Tots els intèrprets de comandes incorporen un llenguatge de programació amb sentències decontrol de fluxe, assignació de variables, funcions ... Els usuaris poden escriure programes(shellscripts) utilitzant aquest llenguatge i així automatizar l’execució de seqüències decomandes. Els shellscripts seran interpretats pel shell.

Per crear un shellscript invocareu un editor de textos i escriureu el codi del shellscript. Laprimera línia ha de ser #!/bin/bash (indica el shell que interpretarà el programa). Un copgravat, heu d’activar el permís d’execució del shellscript amb la comandachmod 700 nom_script, i ara ja el podeu executar utilitzant el nom10 del shellscript.

Podeu utilitzar el caràcter # per inserir comentaris dins del shellscript. Quan l'intèrpret decomandes troba aquest caràcter, deixa d'interpretar els següents caràcters de la línia.

Per buscar informació al manual del sistema sobre les sentències pròpies del bashrelacionades la programació de shellscripts heu d’executar man bash.

3.2 COMANDES QUE ACOSTUMEN A ESTAR PRESENTS ALS SHELLSCRIPTS

A continuació es descriuen algunes comandes que acostumen a estar presents alsshellscripts, tot i que també poden executar-se fora dels shellscripts.

sleepAtura l’execució del shellscript durant el nombre de segons indicat com a paràmetre.

prompt$ sleep 5 Retorna el control passats 5 segons

echoMostra un missatge per la sortida estàndard. Permet imprimir el valor de les variables:

prompt$ echo Hola Mostra el missatge Hola.

10.Si apareix el missatge d’error Command not found, és perquè el directori actual no està present a lavariable PATH (repasseu el capítol 2.4). Cal que afegiu el directori actual a la variable PATH o queexecuteu el shellscript fent ./nom (d’aquesta forma, forceu que es busqui al directori actual).


prompt$ echo Valor de home: $HOME Mostra el contingut de la variableHOME.

prompt$ echo -n Sense salt de línia No finalitza el missatge amb el saltde línia (paràmetre -n).

prompt$ echo -e "\ta\tb" El paràmetre -e activa la interpretació decaràcters especials (com ara el \t, que representa el tabulador).

printfMostra un missatge per la sortida estàndard. Admet especificar cadenes de format com larutina printf de llenguatge C:

prompt$ printf '%x\n' 15 Escriu l’enter 15 en base 16 (format %x).

prompt$ printf '%10s\n' abc Afegeix espais en blanc a l’esquerra d’abc.

testAvalua condicions respecte un arxiu (si existeix, si és llegible, si és modificable, si és de tipusdirectori,...), respecte a cadenes de caràcters (si són iguals ...) o numèriques (igualtat,desigualtat, major que, major o igual que ...). Consulteu el manual per veure totes les opcions.

test no escriu res per la sortida estàndard, però té un codi d’acabament (accessible amb lavariable del shell ?) que és 0 si la condició és certa i un valor diferent de 0 si la condició ésfalsa (noteu que és el conveni contrari a l'utilitzat pel llenguatge C). Exemples (és necessarirespectar els espais entre els paràmetres, recordeu que el metacaràcter ; és un separador decomandes):

prompt$ test -d /bin; echo $? Escriu 0 perquè /bin és un directori.

prompt$ test -w /bin; echo $? Escriu 1 perquè no podeu escriure a/bin.

prompt$ test hola = adeu; echo $? Escriu 1 perquè les cadenes sóndiferents.

prompt$ test 4 -gt 5; echo $? Escriu 1 perquè 4 no és més gran que 5.

prompt$ test 3 -ne 6; echo $? Escriu 0 perquè 3 no és igual a 6.

prompt$ test 3 -gt 2 -a 5 -lt 7; echo $? Escriu 0 perquè escompleixen ambdues condicions (paràmetre -a indica funció and). El paràmetre -oavaluaria la funció or i el paràmetre ! avaluaria la funció not.


exprAvalua una expressió aritmètica i mostra el resultat per la sortida estàndard. Exemples:

prompt$ expr 3 + 4 Mostra un 7 com a resultat. Observeu que és precís queexisteixi algun espai en blanc entre els operands i l’operador.

prompt$ expr 3 \* 4 Mostra un 12. Observeu que és precís protegirl’operador * amb el metacaràcter \ perquè el shell no substitueixi * pels fitxers deldirectori actual (l’ús del metacaràcter \ s’explicarà més endavant).

readPermet llegir una línia de l’entrada estàndard i guardar-la a una variable. També permetguardar les paraules que composen la línia a variables diferents. Exemples:

prompt$ read lin; echo L: $lin Carrega la línia llegida a la variable lin.

prompt$ read word1 word2; echo L1: $word1; echo L2: $word2Carrega la primera paraula llegida a word1; la segona paraula (i la resta, si és quen´hi ha) és guardaran a word2.

exitFinalitza l’execució del shellscript. Si voleu, podeu especificar un paràmetre de tipusenter; aquest valor representa el codi d’acabament del shellscript i pot ser útil perquè elshellscript informi del seu resultat (de forma anàloga a la comanda test).

true/falseComandes que es fan servir per generar les condicions de control dels bucles infinits.

3.3 COMETES

El shell disposa de tres metacaràcters de tipus cometa:

Cometes simples (' '): indiquen que cal interpretar literalment la cadena que hi haentre les cometes (és a dir, sense expandir metacaràcters, sense interpretar elsespais en blanc com a separadors ...). Per interpretar literalment un caràcter tambées pot utilitzar el metacaràcter \.

Cometes dobles (" "): difereixen de les anteriors en que únicament permeteninterpretar el metacaràcter $ per remplaçar el valor de les variables.

Cometes inverses (` `): indiquen que cal executar la comanda que hi ha entre lescometes i utilitzar el resultat de l’execució com a paràmetre d’una altra comanda.Aquestes cometes permeten interpretar el metacaràcter $.


Exemples:

prompt$ echo $PATH *; echo '$PATH *'; echo "$PATH *" Al primercas mostra el valor de la variable PATH i la llista de fitxers del directori actual. Alsegon mostra la cadena literalment. Al tercer únicament substitueix el valor dePATH.

prompt$ ls -l `which sort` Utilitza el resultat d’executar la comandawhich sort (que reotorna el nom absolut de l’executable sort) com a paràmetredel ls -l.

prompt$ users=`cut -d: -f1 /etc/passwd` Assigna a la variable usersel contingut de la primera columna del fitxer /etc/passwd (que conté elsidentificadors dels usuaris del sistema).

prompt$ echo \*; echo * Mostra com \ també inhibeix l’expansió delmetacaràcter *. El seu efecte es limita a un únic caràcter.

3.4 VARIABLES

Repasseu el que es va explicar sobre les variables al capítol 2.4. Recordeu que a l’intèrpretde comandes bash no ha d'haver cap espai en blanc al voltant de l'operador d'assignació(variable=valor).

3.5 CONTROL DE FLUX

A continuació es descriuen les estructures de control de flux del bash.

ifLa sintaxi d’aquesta sentència és:

if condició1then

sentències1[ elif condicio2

thensentències2 ]

...[ else

sentènciesN ]fi

Aquesta sentència avalua la condició1. Si és certa executa sentències1; si és falsa icondició2 és certa, executa sentències2,...; si totes les condicions són falses, executasentènciesN.


A les condicions podeu posar una o més comandes i, en funció del codi d’acabament de ladarrera d’aquestes comandes, es decidirà si la condició es compleix o no (repasseu lescomandes test i exit al capítol 3.2). Les formes típiques de generar les condicions són:

La comanda test.

La comanda grep (retorna cert si ha trobat la paraula).

La resta de comandes acostumen a retornar cert si han pogut fer correctament laseva tasca i fals en cas d’error. En cas de dubte, consulteu el manual del sistemade la comanda i busqueu on es parli dels codis d’acabament (return codes o exitcodes).

Si indiqueu diverses comandes comunicades mitjançant pipes, es considera el codid’acabament corresponent a la darrera comanda.

A sentència podeu posar qualsevol comanda disponible al sistema. Com a referència,podeu analitzar el shellscript d’exemple if.sh.

while/untilLa sintaxi d’aquestes sentències és:

while condició until condiciódo do

sentències sentènciesdone done

La sentència while avalua la condició. Si el seu resultat és cert, executa les sentències del’interior de bucle i torna a iterar; si és falsa, surt del bucle. La sentència until itera mentre lacondició s’avaluï com a falsa. La condició es genera de la mateixa forma que la condició dela sentència if. Com a referència, podeu analitzar els shellscripts d’exemple while.sh iuntil.sh

forLa sintaxi d’aquesta sentència és:

for variable in llista_valorsdo

sentènciesdone

La sentència for itera sobre cadascun dels elements de llista_valors i executa lessentències existents a l’interior del bucle. A cada iteració, variable pren el valor del’element corresponent de llista_valors. Fixeu-vos que la semàntica de la sentència for abash és força diferent a la de la sentència for del llenguatge C (for(inicialització; condició;sentències)).


llista_valors es pot generar de moltes formes. Algunes de les més típiques són:

Qualsevol enumeració de fitxers ens permet iterar sobre els noms dels fitxersespecificats (per exempe, * per iterar sobre els noms de fitxer del directori actual,../src/*.c per iterar sobre els noms dels fitxers amb extensió .c del directori../src, /proc/*/cmdline ...).

$* per iterar sobre els paràmetres del shellscript (s’explicarà al capítol 3.6).

‘comanda‘ per iterar sobre cada paraula mostrada per l’execució de comandaUna comanda típica que podeu utilitzar és seq, que us permet generar unaseqüència de nombres en progressió aritmètica. Consulteu el manual de lacomanda.

Com a referència, podeu analitzar el shellscript d’exemple for.sh .

caseLa sintaxi d’aquesta sentència és:

case paraula inpatró1) sentències1 ;;patró2) sentències2 ;;...patróN) sentènciesN ;;

esac

La sentència case busca quin és el primer patró corresponent a paraula i executa lessentències associades al patró.

La forma més típica de generar paraula és fent un accés a una variable. Per especificarpatró podem fer servir metacaràcters: per exemple a* és el patró corresponent a paraulesque comencen per a, el patró a*|b* correspon a paraules que comencen per a o per b, elpatró * correspon a totes les paraules (acostuma a posar-se com a darrer patró per tractar elcas que una paraula no coincideixi amb cap dels patrons anteriors). Com a referència, podeuanalitzar el shellscript d’exemple case.sh

Per finalitzar, uns darrers respecte les sentències de control de fluxe:

Dins dels bucles for, while i until es poden utilitzar les sentències break (fasortir del bucle) i continue (fa que es comenci a executar la següent iteració).

És possible redireccionar l’entrada estàndard i/o la sortida estàndard d’unasentència de tipus for, while i until. Aquesta redirecció afecta totes lescomandes executades dins del bucle.

Oblidar alguna de les paraules clau d’una sentència de control de flux (com aradone) o no tancar una cometa pot provocar l’error d’execució Unexpected EOF.


3.6 PAS D’ARGUMENTS ALS SHELLSCRIPTS

Quan invoquem un shellscript podem passar-li arguments. Per accedir-hi cal considerar:

$# permet obtenir el nombre de paràmetres del shellscript.

$* conté la llista de tots els paràmetres del shellscript.

El primer paràmetre és accessible amb $1, el segon amb $2,..., el novè amb $9.

Si el shellscript té més de 9 paràmetres, per accedir als següents cal executar lacomanda shift. Aquesta comanda descarta el valor de $1, mou el valor de $2 a$1, el de $3 a $2,..., el de $9 a $8, i posa el valor del primer paràmetre noaccessible a $9. A més, aquesta comanda actualitza el valor de $# i $*. L’efecte dela comanda shift no pot ser desfet.

La variable $0 sempre conté el nom del shellscript.

Quan un shellscript espera arguments, és aconsellable comprovar que el valor de $# ésl’esperat. Com a referència, podeu analitzar el shellscript d’exemple args.sh

3.7 D’ALTRES CARACTERÍSTIQUES

3.7.1 Gestió de senyals (signals)

Els processos Unix poden rebre senyals (signals) generats pel propi sistema operatiu o peraltres processos. Aquests senyals estan associats a l’ocurrència d’alguns esdeveniments(que l’usuari premi Ctrl-C, un accés a memòria il·legal,...) o a l’execució de la comanda killsobre aquest procés.

Els senyals interrompen l’execució del procés i provoquen que s’executi el codi d’atenció al’esdeveniment. Per omissió, el codi d’atenció provoca l’acabament de l’execució del procés,però podeu modificar aquest comportament.

La sentència trap permet definir les comandes que s’han d’executar quan un shellscript repun senyal. La sintaxi de la sentència és trap 'comandes' senyals. Exemple:

Per practicar

3.1 Escriviu un shellscript que, utilitzant un bucle while, mostri el factorial delnombre enter indicat com a paràmetre (no feu una implementació recursiva).

3.2 Escriviu un shellscript que, utilitzant un bucle for, mostri el factorial del nombreenter indicat com a paràmetre (no feu una implementació recursiva).


trap 'echo Interromput per Ctlr-C; rm $fitxer_temporal; exit' 2 . Unshellscript que hagués executat aquesta línia respondria al Ctrl-C (senyal 2) imprimint unmissatge, esborrant el fitxer temporal i acabant l’execució del shellscript. Com a referència,podeu analitzar el shellscript d’exemple trap.sh

3.7.2 Funcions

Les funcions permeten escriure shellscripts més llegibles i evitar la repetició de codi. Com areferència, podeu analitzar el shellscript d'exemple func.sh. Fixeu-vos que les funcionsadmeten paràmetres: s'accedeixen de la forma explicada al capítol 3.6.

3.7.3 Depuració dels shellscripts

L'única eina que ens proporciona bash per a depurar shellscripts és la possibilitat de veurequina comanda del codi s'executa a cada moment i quin valor tenen les variablesinvolucrades. Podem accedir a aquesta eina utilitzant el paràmetre -x de la comanda bash ipassant el shellscript (i els seus paràmetres, si els té) també com a paràmetres de bash;l'eina imprimira línies que comencen pel símbol + i que contenen les comandes executades.Ex: prompt$ bash -x nom_script paràmetres_script

3.8 ALGUNS CONSELLS PER PROGRAMAR SHELLSCRIPTS

A continuació es mencionen alguns consells que us poden resultar d’utilitat al programarshellscripts:

Abans d’escriure el shellscript, proveu interactivament les comandes que voleuutilitzar. És més senzill comprovar el comportament de les comandes de formainteractiva que des d’un shellscript.

No pretengueu escriure tot el shellscript de cop ja que, en el probable cas que hihagi algun error, la seva correcció pot resultar força complicada. És més raonabledescomposar la realització del shellscript en etapes i no començar a treballar enuna etapa fins que l’anterior funcioni correctament.

Recordeu que la sintaxi de la sentència d’assignació d’un valor a una variableexigeix que no hi hagi espais en blanc als dos costats de l’operador d’assignació(=).

L’ús de "xivatos" us permetrà verificar que les variables contenen el valor desitjat.

Per practicar

3.3 Escriviu un shellscript que, utilitzant una funció recursiva, mostri el factorial delnombre enter indicat com a paràmetre.


Per assignar a una variable el què una comanda escriu per la seva sortidaestàndard, cal fer servir les cometes inverses.


A la pàgina de manual de l’intèrpret de comandes podeu trobar d’altres sentènciesdel llenguatge de programació de shellscripts.

L’avaluació d’expressions aritmètiques amb la comanda expr és força tediosa.bash ofereix un mecanisme més senzill (tot i que pot donar problemes decompatibilitat si utilitzeu altres intèrprets de comandes com ara sh).

A la xarxa podeu trobar manuals molt complets de programació de shellscripts comara Advanced Bash-Scripting Guide.

Per practicar

3.4 Escriviu un shellscript que mostri els noms del fitxers del directori actual ambmida igual o superior a la mida especificada per l'usuari com a paràmetre.Suggerència: escriviu un bucle que iteri mostrant els noms de tots els fitxers deldirectori actual. A continuació, feu que el bucle també mostri a cada iteració lamida del fitxer. Posteriorment, inicialitzeu una variable (per exemple mida=100)fora del bucle i modifiqueu el bucle de forma que indiqui quins fitxers tenen unamida igual o superior a mida. A continuació, inicialitzeu mida a partir delparàmetre que indiqui l'usuari. Finalment, comenteu les línies que mostrininformació supèrflua.

3.5 Escriviu un shellscript tal que donat el nom d'una comanda ens digui a quindirectori de la variable PATH existeix el fitxer executable corresponent (Nopodeu utilitzar les comandes which/type).Suggerència: escriviu un bucle que mostri mostri els directoris de la variablePATH un a un (probablement haureu d'utilitzar la comanda tr). Continueu comconsidereu més oportú.

3.6 Escriviu un shellscript que, cada 10 segons, indiqui si l'usuari especificat com aparàmetre està connectat al sistema. Quan l'usuari premi Ctrl-C, s'escriurà unmissatge per la sortida estàndard i finalitzarà l'execució del shellscript.Suggerències: amb la comanda adduser podeu crear nous usuaris i amb lacomanda who podeu saber qui està connectat en aquest moment al sistema.Escriviu primer la versió que comprovi si l'usuari està connectat en aquestmoment. A continuació, afegiu el bucle que realitza la temporització i finalitzeuafegint el tractament del Ctrl-C.

3.7 Disposeu d’un fitxer de texte on a cada línia hi ha dos noms de fitxer (separatsper un espai en blanc). Escriviu un shellscript que processi totes les líniesd’aquest fitxer efectuant la següent operació: si el primer fitxer existeix, elcopiarà sobre el segon; si no existeix, copiarà/etc/passwd sobre el segon.

4 Entorn de desenvolupament d'aplicacions 39

4 Entorn de desenvolupament d'aplicacions

L'objectiu del capítol és donar-vos a conèixer alguns del programes de sistema queconstitueixen l'entorn de desenvolupament d'aplicacions i que acostumen a ser oferts per lamajoria de sistemes Unix. Per entorn de desenvolupament entenem el conjunt d'eines quepodem utilitzar durant el cicle de vida d'una aplicació: editors, compiladors, muntadors ... A lapàgina web de suport trobareu els fitxers referenciats al document.

4.1 EDICIÓ DE PROGRAMES

L'editor de text és l'eina que ens permet escriure i modificar el codi font dels programes. Elseditors presents a la majoria de sistemes Unix són vi, vim, gvim, nedit, xedit, emacs,pico, joe ... Els editors més potents són el vi (i derivats) i l’emacs ja que tenen moltesfuncionalitats que poden simplificar la tasca de programació i ajudar-vos a ser mésproductius. Tot seguit s’explicaran algunes característiques útils de l’editor vim; de totesformes, els interessats a treballar amb altres editors són encoratjats a buscar com realitzaraquestes operacions en l’editor del seu gust.

vim (vi improved)Quan invoquem vim hem d'indicar com a paràmetre el nom del fitxer que volem editar. Perseguir la següent explicació, invoqueu-lo amb el fitxer d'exemple sim.c

La major dificultat que presenta aquest editor és que té dos modes de treball: el mode edició iel mode comanda. Al mode edició l'editor es comporta com una màquina d'escriurerudimentària i bàsicament ens permet afegir/esborrar text al fitxer; en mode comanda tenimaccés a la majoria de funcionalitats de l'editor.

Inicialment l'editor es troba en mode comanda. Per passar de mode comanda a mode ediciócal prémer la tecla i (fixeu-vos que a la part inferior de la pantalla ara apareix INSERTindicant el canvi de mode) i per passar de mode edició a mode comanda cal prémer la teclaEsc.

Des de mode comanda, el primer que podem fer és que l'editor ressalti la sintaxi delllenguatge. Això es pot aconseguir escrivint la comanda :syntax on i un salt de línia. Siavanceu pàgines (tecla PgUp o AvPag) observareu que l'editor assigna colors a les paraulesclau, comentaris, variables, constats,... i augmenta la legibilitat del codi.

Fixeu-vos que l'editor mostra a la part inferior dreta el nombre de línia i la posició dins de lalínia on esteu ubicats. Per anar directament a una línia podeu utilitzar la comanda :N seguidad'un salt de línia, on N és el nombre de línia on us voleu situar. Prement G us situarieudirectament a la darrera línia del fitxer.

El moviment dins de la línía es pot fer prement les tecles 0 (inici de línia), $ (fi de línia), w(següent paraula) i b (anterior paraula).


Per buscar una paraula dins del codi podeu fer servir la comanda / i escriure a continuació laparaula a buscar i un salt de línia (per exemple /eventq_next). Ara, si premeu la tecla nveurem la següent aparició de la paraula, i si premeu N l'anterior. Si esteu situats sobre unaparaula i voleu veure la següent o l'anterior aparició d'aquesta mateixa paraula podeu fer-hoprement * o # respectivament. Una altra opció es prement [I, això us mostra a la part inferiorde la finestra totes les aparicions de la paraula al fitxer (feu la prova, per exemple, situant-vossobre eventq_init).

L'editor ens permet autocompletar noms de variables/rutines/... Per exemple, canvieu a modeedició i a una línia en blanc comenceu a escriure eventq_ i premeu Ctrl-n Apareixerà elnom complet d'una variable/rutina ja existent al codi amb un nom que comença per aquestscaràcters. Si premeu Ctrl-n successives vegades apareixeran d’altres possibles noms devariables. Aquesta opció redueix sensiblement els errors produïts al teclejar noms llargs derutines.

Per copiar/moure blocs de línies es fa servir un buffer. Per insertar un bloc de línies al buffercal prémer yy (precedit del nombre de línies si el bloc consta de més d'una línia). Per insertarel contingut del buffer a la posició actual cal prémer p. El cut-and-paste es fa prement dd(esborra la línia actual, o més si ho precediu d'un nombre) i la tecla p.

vim permet treballar amb diverses finestres simultàniament. Per crear-ne una cal prémerCtrl-wn i per canviar de finestra cal prémer Ctrl-ww. Cada finestra pot tenir en edició unfitxer diferent. Per tancar una finestra cal utilitzat :wq o :q! en funció de si volem guardar elscanvis o no (si tenim una única finestra, provoquen el final de l'edició).

Si esteu editant i voleu desfer els darrers canvis introduïts podeu prémer la tecla u (undo) unao més vegades. Per tornar a aplicar els canvis desfets cal prémer Ctrl-r.

Altres comandes útils són % (si esteu sobre un parèntesi/claudàtor obert us mostra elparèntesi/claudàtor tancat que li correspon, i a l'inrevés), gf (si esteu sobre el nom d'un fitxerinclude passeu a editar-lo), Ctrl-o i Ctrl-i (permeten desfer/tornar a fer els darrerscanvis de posició d'edició sobre el(s) fitxer(s)). Si premeu : i tot seguit les fletxes de cursor,podeu recuperar la història de les darreres comandes executades. Finalment, moltes opcionsde configuració es poden emmagatzemar al fitxer .vimrc de forma que es carreguinautomàticament en obrir l'editor. Per buscar ajuda podeu executar la comanda :help iaccedir al tema que us interessi.

És important adonar-se que moltes d'aquestes opcions us poden ajudar a detectar errorssense passar pel compilador. Per exemple, si escriviu malament una paraula reservadaveureu que no canvia de color; si us oblideu un símbol { veureu que la indentació delprograma no és la que esperaríeu,... L'editor té moltíssimes més possibilitats que es podendescobrir consultant l'ajuda incorporada a l'editor.


4.2 COMPILACIÓ/MUNTATGE

Un cop escrit un programa en llenguatge C, cal generar el fitxer executable corresponent. Leseines que s'encarreguen d'aquesta tasca són el compilador (compiler) i el muntador (linker).Els compiladors típics de C a Unix s'anomenen cc (C compiler) o gcc (GNU C compiler); elmuntador s’anomena ld. Per simplificar la vostra tasca, farem que el compilador s'encarreguid'invocar automàticament el muntador.

4.2.1 Aplicacions amb un únic fitxer font

Heu d’indicar al compilador el nom del fitxer font que conté el programa. Si el compiladordetecta algun error sintàctic al fitxer, us mostrarà un missatge d'error i el nombre de línia on elcompilador es pensa que es troba l'error. Si no hi ha cap error, genera un fitxer executableque rep el nom a.out. Si voleu que el fitxer executable tingui un altre nom, heu de passar alcompilador els paràmetres -o i el nom que voleu que tingui l'executable. Com a exemple, perobtenir un executable anomenat a corresponent al fitxer font a.c cal executar la comandacc a.c -o a

A l’exemple, el compilador invoca implícitament el muntador i utilitza les bibliotequesestàndars del llenguatge C. Per veure totes les comandes que són invocades per compiladorpodeu utilitzar el paràmetre -v (verbose), és a dir, cc -v a.c -o a

Un cop obtingut el fitxer executable, per a invocar-lo heu d'escriure el seu nom. Si el shellmostra l'error Command not found, haureu de revisar que la variable PATH contingui eldirectori actual o haureu d'invocar l'executable fent ./nom_executable per forçar que elshell el busqui al directori actual.

4.2.2 Aplicacions amb diversos fitxers font

Si la vostra aplicació té diversos fitxers font, cal especificar-los tots a la línia de comandes.Per exemple: cc main.c util_file.c util_math.c util_net.c -o main

4.2.3 Eina make

Algunes aplicacions contenen desenes de fitxers font. Compilar tots aquests fitxersmanualment i controlar quins han estat modificats i quins no pot resultar molt tediós.

Per practicar

4.1 Comproveu el funcionament de totes aquestes opcions a l'editor gvim, la versiógràfica del vim (fixeu-vos que moltes opcions són accessibles utilitzant elmouse).

4.2 Si esteu habituats a utilitzar un altre editor, comproveu si és possible realitzaraquestes operacions al vostre editor.


L'eina make automatitza la tasca de compilar tots aquests fitxers. make llegeix un fitxeranomenat Makefile on estan especificats els fitxers que composen l’aplicació i quinesdependències existeixen entre ells. L'eina s'encarregarà de veure quins fitxers cal recompilari generarà l'executable compilant el mínim nombre de fitxers.

Si editeu el fitxer Makefile podreu veure el seu format. Típicament, les primeres líniesinicialitzen un seguit de variables; aquestes variables podran ser referenciades més endavantdins del fitxer. Un cop definides les variables apareixen les regles. Una de les primeres reglesdel fitxer és:

prog: $(PROG_SRC)$(CC) $(PROG_SRC) -o $@

Les regles s’interpreten de la forma següent:

prog és l’objectiu de la regla, és a dir, el fitxer que es crearà aplicant aquesta regla.

$(PROG_SRC) fa referència a la variable PROG_SRC i conté la llista de requisits delfitxer prog, és a dir, els fitxers que cal processar per generar prog.

La línia següent conté la(es) comanda(es) que cal executar per crear prog a partirdels fitxers requisits. Típicament, hi apareixen referències a diverses variables: elnom del compilador, la llista de fitxers requisits i l’objectiu de la regla ($@). Aquestalínia ha de començar per tabulador.

Eliminant les referències a les variables, la regla s’escriuria de la forma següent:

prog: main.c util_file.c util_net.c util_math.cgcc main.c util_file.c util_net.c util_math.c -o prog

A aquesta regla tots els fitxers requisit són fitxers font. Però, com veureu quan parlem de lesbiblioteques, és possible que algun fitxer requisit no sigui un fitxer font. En aquest cas, caldràafegir una regla que generi aquest fitxer a partir dels seus requisits.

Més endavant apareixen dues regles genèriques. Per exemple:

%.o: %.c$(CC) -c $< -o $@

La regla indica com generar un fitxer amb extensió .o (fitxer objecte) a partir d’un fitxer .c(fitxer font en llenguatge C). La variable $< fa referència al nom del fitxer requisit.

Finalment apareix la regla clean, que no té cap requisit. Aplicar aquesta regla provoca ques’esborrin els executables, els fitxers objecte i d’altres fitxers auxiliars que s’han creat.

Quan executeu make cal indicar el nom de l’objectiu que voleu crear. Per exemple, siexecuteu make prog veureu com apareixen per pantalla una sèrie de comandes que són


executades per make. L’execució de totes aquestes comandes provoca la creació del fitxerexecutable prog. Si ara torneu a executar make prog apareixerà el missatge prog is up todate (prog està actualitzat), que indica que no cal recompilar-lo ja que el fitxer objectiu(prog) és més recent que els seus fitxers requisits. make clean provocarà que s’esborrinels fitxers creats.

Si invoqueu make sense indicar cap objectiu, es crearà l’objectiu corresponent a la primeraregla que aparegui al fitxer Makefile. Per conveni, la primera regla que apareix a moltsfitxers Makefile acostuma a anomenar-se all; com a requisits té la llista de tots els fitxersexecutables que crea el Makefile i no té cap comanda associada. D’aquesta forma, al’invocar make sense paràmetres es crearan tots els fitxers executables.

4.3 BIBLIOTEQUES CREADES PER L’USUARI

Una biblioteca11 no és més que un fitxer que conté el codi màquina d'una sèrie de rutines ique estan disponibles per a qui les necessiti. Hi ha biblioteques estàtiques (no compartides omuntades en temps de muntatge) i dinàmiques (compartides -shared- o muntades en tempsde càrrega o d’execució); ara veureu com crear-les.

4.3.1 Biblioteques estàtiques (extensió .a)

Per crear una biblioteca estàtica (extensió .a) cal seguir els següents dos pasos:

Obtenir el fitxer objecte corresponent a cada fitxer .c a incloure. Cal invocar elcompilador amb el paràmetre -c perquè generi el fitxer objecte (extensió .o)

Executar la comanda ar per crear la biblioteca. Típicament cal invocar aquestacomanda amb els paràmetres rc , el nom de la biblioteca (per conveni, el nom dela biblioteca comença per lib, per exemple, libutil.a) i la llista de fitxersobjecte que volem incloure a la biblioteca.

Per crear l'executable utilitzant la biblioteca creada, cal invocar el compilador indicant a quindirectori ha de buscar la biblioteca (paràmetre -L seguit del directori) i el nom de la biblioteca(paràmetre -l seguit del nom de la biblioteca sense el prefixe lib i sense l'extensió .a), perexemple -L. -lutil

11.En aquest document hem traduït el terme anglès library com a biblioteca. Tot i que aquesta és latraducció més fidel, d’altres texts l’han traduït com a llibreria.


4.3.2 Biblioteques dinàmiques (extensió .so)

Per crear una biblioteca dinàmica (extensió .so) cal seguir els següents passos:

Obtenir el codi objecte corresponent a cada fitxer .c en format independent de laposició (PIC). Cal invocar el compilador amb el paràmetre -fPIC

Crear la biblioteca dinàmica utilitzant la comanda cc i el paràmetre -shared

La creació de l’executable utilitzant la biblioteca creada és com al cas anterior.

Com a exemple, si executeu make prog_dyn veureu el seguit de comandes que s’executenper crear una biblioteca dinàmica amb el codi dels mateixos fitxers que a l’exemple anterior icom es genera l’executable prog_dyn utilitzant aquesta biblioteca.

Si ara executeu prog_dyn es mostrarà un error indicant que no s’ha trobat la bibliotecadinàmica. El motiu és que, per omissió, les biblioteques dinàmiques només es busquen a unsdirectoris predefinits (/lib ...). Per poder executar prog_dyn caldrà inicialitzar la variableLD_LIBRARY_PATH amb el nom del directori on es troba el vostre fitxer .so12.

12.Si treballeu amb els shells sh o bash, hauríeu d’executar les comandesLD_LIBRARY_PATH=nom_directori i a continuació export LD_LIBRARY_PATHSi treballeu amb els shells csh o tcsh la inicialització seria mitjançant la comandasetenv LD_LIBRARY_PATH nom_directori

Per practicar

4.3 Estudieu la regla que genera el fitxer prog_est. A quines altres regles fareferència aquesta regla?

4.4 Executeu make prog_est Veureu les comandes que s’executen per crear unabiblioteca estàtica amb el codi dels fitxers util_file.c, util_net.c iutil_math.c, i com es genera l’executable prog_est utilitzant la biblioteca.Quina d’aquestes comandes crea la bibilioteca? Quin és el nom del fitxer detipus biblioteca?

4.5 Modifiqueu algun dels fitxers .c que composen la biblioteca i torneu a generarl’executable amb la comanda make. Comproveu que només es recompilen elsfitxers depenents del canvi. Com sap make quins fitxers ha de recompilar i quinsno?

4.6 La comanda ar també permet examinar un fitxer de tipus biblioteca i extreure'nfitxers objecte. Consulteu el manual de la comanda i contesteu les preguntes:Quants fitxers objectes hi ha a la biblioteca /usr/lib/libc.a ? Cominvocaríeu ar per extreure el fitxer rand.o d'aquesta mateixa biblioteca ?


La comanda ldd mostra les biblioteques dinàmiques que utilitza un programa. Si executeuldd prog_dyn veureu que a més de la biblioteca que heu creat n’hi ha dues més: lesbiblioteques estàndard de C.

4.3.3 Biblioteques dinàmiques carregades en temps d'execució (run time)

En alguns casos pot ser útil que la càrrega/descàrrega de biblioteques sigui controladadirectament pel programa en temps d'execució. Es tracta de programes "flexibles" quehaurien de poder utilitzar rutines que no estaven disponibles en el moment de compilar-los(per exemple, un editor de texts que ha d'interpretar un nou format de fitxer). Aquestsprogrames carregaran en temps d'execució la biblioteca que contingui la rutina queimplementi la nova operació.

Aquesta biblioteca ha de ser dinàmica i mitjançant un seguit de rutines podem carregar labiblioteca a memòria (dlopen), buscar-hi una rutina (dlsym) i descarregar la biblioteca dememòria (dlclose). De totes formes, l'objectiu d'aquest capítol no és conèixer la interfícieconcreta d'aquestes rutines, sinó només conèixer la seva funcionalitat bàsica.

Com a exemple, el programa mainsuma.c carrega en temps d'execució una bibliotecadinàmica que hauria de contenir el codi de la rutina suma. Us facilitem dues implementacionsde la rutina suma, una implementació recursiva (al fitxer rec.c) i una altra iterativa (al fitxeriter.c).

Per generar l'executable de mainsuma i les biblioteques on s'emmagatzemaran lesimplementacions de la rutina suma podeu executar la comandamake mainsuma libiter.so librec.so

Per practicar

4.7 Tot i que prog_dyn ha utilitzat la versió dinàmica de la biblioteca, prog_dyn ésmés gran que prog_est. Això és perquè la biblioteca que hem creat és massapetita perquè el canvi sigui rentable. Executeu make prog_tot_est, amb aixòestareu creant un executable que també monta estàticament les bibliotequesestàndard del llenguatge C (paràmetre -static). Quina mida té el fitxerexecutable generat? Comproveu que la mida d’aquest és molt superior a la delsaltres executables que hem creat. A què és deguda la diferència?

4.8 Utilitzeu la comanda ldd per veure les biblioteques dinàmiques que utilitzen elsexecutables que heu generat. Quines biblioteques dinàmiques utilitzen prog,prog_est i prog_dyn?


4.4 D’ALTRES EINES

A continuació es presenten algunes eines que poden resultar útils mentre desenvolupeuaplicacions:

diffCompara dos fitxers de text i ens mostra les diferències entre els fitxers. A algunes màquineshi ha instal·lada una versió gràfica de la comanda: tkdiff. Cal invocar aquestes comandesamb els noms dels fitxers a comparar.

strace Permet veure quines crides al sistema (i amb quins paràmetres) invoca un procés. Pot ser útilper entendre el comportament d'alguns programes.

objdumpMostra informació relativa a fitxers objecte (executables, biblioteques ...). Per exemple, elnombre de seccions (opció -x) , el codi ensamblador de les seccions de codi (opció -d), elcontingut de totes les seccions (opció -s) ...

stringsPermet veure les cadenes de text presents a un fitxer executable.

nmMostra la taula de símbols d’un fitxer objecte, executable o biblioteca.

Per practicar

4.9 Executeu mainsuma passant-li com a paràmetre el nom de la biblioteca acarregar (libiter.so o librec.so). Comproveu com realment s'executa larutina suma de la biblioteca especificada.

4.10 Escriviu al fitxer dir.c el codi font d'una nova rutina que implementi la suma dedos nombres enters (podeu utilitzar directament l'operador + del llenguatge C :-)). Creeu el fitxer libdir.so corresponent i comproveu que l'executablemainsuma és capaç de carregar la biblioteca que heu creat i executar la rutinasuma que heu implementat.

4.11 Executeu la comanda ldd sobre l'executable que acabeu de generar. És normalque no apareguin les biblioteques dinàmiques que es carreguen en tempsd'execució?


4.5 INSTAL·LACIÓ D'APLICACIONS OBTINGUDES A LA XARXA

Les aplicacions disponibles a la xarxa poden estar en format codi font (el més típic si és per aLinux/Unix) o en format executable (el més típic si és per a Windows).

Tot seguit veurem el procediment més habitual per a instal·lar-vos una aplicació Linux quehaguem obtingut a la xarxa. Cal seguir els següents pasos:

En primer terme cal obtenir el codi font de l'aplicació a instal·lar. El format .tar.gz(tarball) és el format més utilitzat per distribuir aplicacións13 ja que és el resultat decompactar tots els fitxers fonts en un de sol (.tar) i després comprimir-ho (.gz).Baixeu del web de suport el fitxer indent-2.2.9.tar.gz; aquest fitxer conté elcodi font de indent, una aplicació que ens permet formatejar el codi font delsprogrames escrits en C.

Descomprimiu el fitxer que heu baixat utilitzant la comanda gunzip passant-li coma paràmetre el nom del fitxer amb extensió .gz. Es generarà un fitxer .tar.

Ara cal descompactar el fitxer .tar utilitzant la comanda tar passant-li com aparàmetre les opcions -xf i el nom del fitxer .tar. Aquest pas ens genera unaestructura de directoris amb una sèrie de fitxers.

Entreu al directori creat.

És aconsellable llegir els fitxers README i INSTALL.

Executeu ./configure per detectar la configuració de la màquina.

13.Les aplicacions també poden estar disponibles en altres formats com ara .tar.bz2 o .rpm.

Per practicar

4.12 Compareu els fitxers a.c i b.c amb l'eina diff. Interpreteu la informaciómostrada.

4.13 Quantes crides al sistema provoca l'execució de la comanda echo hola ?Quines són?

4.14 Quantes seccions hi ha a l'executable /bin/ls ?

4.15 Feu un cop d'ull a les cadenes de text que apareixen al fitxer executable/bin/ls. Podeu identificar els missatges d’error que pot escriure la comanda?

4.16 Observeu les taules de símbols de les biblioteques estàtica i dinàmica que heucreat.


Executeu make per construir l'executable indent (comproveu que realment escrea aquest executable al directori src).

Si sou l'usuari root i esteu treballant sobre una versió de Linux instal·lada al discdur, podeu copiar l'executable i les pàgines de manual als directoris habituals de lamàquina. Cal executar la comanda make install (des del mateix directori onheu executat make).

4.5.1 Aplicació instal·lada: indent

El problema que intenta resoldre indent és que a mesura que aneu modificant un programaés possible que l'editor no pugui mantenir una indentació correcta. També és possible quealgú us passi un programa que no estigui indentat al vostre gust.

indent s'encarrega d'indentar de forma automàtica els fitxers amb codi C (o d'altresllenguatges). Com que hi ha molts estils possibles d'indentació, aquesta eina és altamentparametrizable (consulteu el manual de la comanda si heu pogut instal·lar-lo).


La descripció feta en aquest capítol de la sintaxi dels fitxers Makefile ha estatmolt limitada. A la xarxa podeu trobar manuals complets que descriuen la sevasintaxi.

Una altra eina molt útil per al desenvolupament d’aplicacions és el debugger(comandes gdb -mode text- o ddd -mode gràfic-). Entre altres coses, us permetexecutar una aplicació sentència a sentència de forma que pugueu examinar comevolucionen els valors de les variables del programa a mesura que aquests’executa. Al capítol 10 veureu un cas pràctic d’utilització del debugger.

Existeixen d’altres eines que us ajuden a instal·lar/desinstal·lar aplicacions. Perexemple, rpm. Consulteu el manual si hi esteu interessats.

Per practicar

4.17 Utilitzeu l'eina indent per indentar el fitxer noindentat.c.

4.18 Al fitxer ~/.indent.pro podeu indicar les vostres preferències de forma queno sigui precís indicar-les explícitament cada cop que feu servir l'eina. Creeu unfitxer ~/.indent.pro que reculli el teu vostre estil d'indentació.

5 Gestió de processos a UNIX (1/2) 49

5 Gestió de processos a UNIX (1/2)

Els objectius d'aquest capítol són: a) conèixer amb més profunditat com gestionar processosdes del shell Unix (ps, kill, top i uptime, i el directori /proc) i b) familiaritzar-vos amb lescrides al sistema Unix de gestió de processos (fork, wait, exec, exit, getpid igetppid). A la pàgina web de suport trobareu els fitxers referenciats al document. Recordeuque en cas de dubte respecte a la funcionalitat de comandes o crides al sistema, podeuconsultar el manual del sistema (comanda man).

5.1 DES DE L’INTÈRPRET DE COMANDES

5.1.1 Comandes

psLa comanda ps mostra informació sobre els processos en execució a la màquina. Lacomanda admet gran quantitat d’opcions que es poden classificar en tres grups:

Selecció de processos a llistar: per omissió només presenta els processosassociats al terminal des del que s’ha iniciat la comanda, però podem indicar quevolem veure tots els processos (-e), els d’un usuari (-u seguit de l’identificador del’usuari), els que s’executen a un terminal (-t seguit de l’identificador del terminal),els que executen una comanda determinada (opció -C) ...

Informació a mostrar: per omissió només mostra el pid, el terminal associat (TTY),el temps de CPU consumit i el nom de l’executable, però podem fer que mostri mésdades (opcions -l o -f) o indicar els camps a mostrar (opció -o).

Modificadors del resultat: permeten especificar alguns detalls relatius a com espresenta la informació (nombre de columnes, presència de capçaleres ...).

Els tres tipus d’opcions es poden combinar. És possible que opcions presents a una versiód’Unix no estiguin presents en una altra; en aquest cas caldrà buscar al manual alguna altraopció equivalent o pensar alguna altra forma d’aconseguir el mateix resultat.

uptimeuptime mostra informació variada sobre el sistema: l'hora actual, el temps transcorregut desde la posada en marxa del sistema (uptime), el nombre d'usuaris connectats i la càrregamitjana (load average) al darrer minut, 5 minuts i 15 minuts.

La càrrega mitjana és el nombre mitjà de processos que estan als estats Run o Ready. Amàquines amb un únic processador, valors de càrrega superiors a 2 ò 3 poden provocar queel temps de resposta del sistema s'incrementi significativament. L'administrador del sistemahauria de comprovar periòdicament que aquest no superi un nivell raonable.


Per comprovar el funcionament de la comanda podeu crear una (o diverses) finestra(es) iexecutar la següent comanda14 des de bash o sh: while (true) do date; done Lacomanda realitza un bucle infinit on a cada iteració imprimeix l'hora actual. Des d'una altrafinestra, comproveu com evolucionen les dades de càrrega mostrades per uptime.

topLa comanda top mostra informació sobre els processos en execució al sistema ordenats perconsum de CPU i, a diferència de ps, actualitza aquesta informació periòdicament. Perfinalitzar l’execució de top cal prémer la tecla q.

Les primeres línies mostrades per top donen informació general sobre el sistema. La primerapresenta la mateixa informació que la comanda uptime. La segona indica el nombre total deprocessos i a quants hi ha a cada estat (execució, bloquejat, aturat i zombie). La terceramostra l’ús de la CPU (% en mode usuari, % en mode sistema i % idle, és a dir, sense codi aexecutar). Les dues últimes mostren informació sobre l’ocupació de la memòria física i sobrel’àrea de swap.

Podem fer que top mostri informació sobre els processos d’un usuari concret, que ordeni elsprocessos per altres criteris, modifiqui la freqüència d’actualització ... Per veure totes lesopcions disponibles podeu prémer la tecla h.

Normalment, no és convenient utilitzar aquesta comanda dins de shellscripts ja que, peromissió, requereix que l’usuari premi una tecla per finalitzar la seva execució. A més, comque top pot consumir molt temps de CPU, és possible que no estigui disponible per a tots elsusuaris.

kill i killallSón les comandes que permeten matar processos. El primer paràmetre de les comandes és-9 i el segon és l’identificador que ens permet seleccionar el(s) procés(sos) a matar. Laprimera selecciona el procés a matar a partir del seu pid, la segona el selecciona a partir delnom de la comanda que executa el procés.

Si al primer paràmetre és diferent de -9, podreu enviar senyals (signals) als processos(capítol 3.7.1).

14.Aquest tipus de comandes seria aconsellable que les executéssiu únicament a una sistema on no hihagi d’altres usuaris treballant.


5.1.2 Explorant el directori /proc

Moltes màquines Unix i Linux utilitzen un pseudo-sistema de fitxers per oferir informacióvariada sobre els sistema i sobre els processos que s'hi executen. Per omissió, aquestsistema de fitxers es monta a /proc. Si us situeu a aquest directori i executeu ls veureu unseguit de fitxers i de directoris.

Els fitxers ofereixen informació general sobre la màquina: cpuinfo (característiques de laCPU de la màquina), meminfo (utilització de la memòria), version (versió del sistemaoperatiu) ... Podeu examinar aquests fitxers amb les comandes more, cat ...

El nom de la majoria de directoris és un nombre enter. Aquest nombre representa unidentificador de procés (pid). Si us situeu dins del directori d'algun dels vostres processospodreu obtenir informació respecte al procés com ara la línia de comandes que l’ha creat(cmdline), les variables d’entorn (environ), identificadors diversos associats al procés iinformació d’estat (status) ... Si executeu man proc podeu obtenir informació sobre elcontingut de cadascun d’aquests fitxers.

Per practicar

5.1 Escriviu un shellscript que mostri els N processos que estan consumint mésCPU al sistema. N serà un argument del shellscript.

5.2 Escriviu un shellscript que cada N segons mostri quins són els M usuaris quetenen més processos en execució a la màquina i el seu nombre. N i M són dosarguments del shellscript (pista: us pot resultar d'utilitat repassar la comandauniq del capítol 2.5.1).

5.3 Escriviu un shellscript que cada N segons comprovi si, al darrer minut, la partentera de la càrrega mitjana del sistema és superior a M. En cas afirmatiu, hauriad'imprimir un missatge indicant-ho. N i M seran arguments del shellscript (per ferproves, incrementeu la càrrega del sistema).

5.4 De forma interactiva, feu que top mostri únicament els processos de l’usuariroot, els ordeni per ocupació de memòria i actualitzi les dades cada 0.1segons.

5.5 Escriviu un shellscript que mostri el pid dels processos que estan executant lacomanda especificada com a argument al shellscript.

5.6 Escriviu un shellscript que mati tots els processos que estiguin executant lacomanda especificada com a argument al shellscript (no podeu utilitzar lacomanda killall).


5.2 CRIDES AL SISTEMA UNIX

5.2.1 Crida al sistema fork

Aquesta crida és la responsable de la creació de nous processos. Crea un nou procés(proces fill) que és una rèplica del procés que ha invocat a la crida fork (procés pare); és adir, l'espai de memòria del procés fill (codi, pila i dades) s'inicialitzarà amb el contingut que téel pare. Un cop creat el procés fill, el procés pare i el procés fill s'executen concurrentment apartir de la instrucció següent a la invocació a la crida fork, pero cadascú treballarà amb laseva pròpia còpia de les variables.

La crida fork retorna un valor diferent al procés pare i al procés fill. La crida fork retorna un0 al procés creat i l'identificador del procés creat (que seà més gran que 0) al procés pare.Això permetrà diferenciar el codi que executarà el pare del que executarà el fill. En cas d’error(com totes les altres crides al sistema), retorna -1 i actualitza la variable global errno amb uncodi d’error que indica el motiu que ha provocat l’error.

A les activitats que es presenten a continuació també es fan servir dues crides al sistemarelaciones amb la gestió de processos:

getpid() permet que un procés pugui conèixer el seu identificador de procés. Noté cap paràmetre d’entrada i retorna un enter.

getppid() permet que un procés pugui conèixer l’identificador de procés del seuprocés pare. No té cap paràmetre d’entrada i retorna un enter.

Per practicar

5.7 Escriviu un shellscript com el de l’activitat pràctica 5.5 tot utilitzant la informacióobtinguda explorant el directori /proc. Suggerència: per accedir a /procaprofiteu els metacaràcters d’enumeració de fitxers (*, ? ...).


5.2.2 Crida al sistema wait

Aquesta crida permet sincronitzar l’execució d’un procés pare amb l'acabament d'un delsseus processos fills. La crida al sistema wait retorna l'identificador del procés fill que haacabat; això pot ser útil si un procés té diversos processos fills i vol saber quin d’ells és el queha acabat.

En el moment que el procés pare sap que un procés fill seu ha mort (i no abans), el procés filldesapareix completament del sistema. Al parlar de la crida al sistema exit tornarem a ferènfasi en aquest aspecte.

5.2.3 Crides al sistema exec (execv, execl,...)

Aquestes crides canvien la imatge d'un procés, és a dir, carreguen un nou programa amemòria i inicialitzen la zona de dades i la de pila per a començar la seva execució.

Per practicar

5.8 Compileu i executeu el programa ex01.c (compileu-lo fent make ex01 iexecuteu-lo fent ex01 o ./ex01). Com és que el missatge del segon printfs'escriu dos cops?

5.9 Compileu i executeu el programa ex02.c (procediu de forma anàloga al’exemple anterior). Comproveu que el valor de retorn és diferent per a cadaprocés.

5.10 Compileu i executeu el programa ex03.c. Comproveu que el valor de retorn ésdiferent per a cada procés i que això ens permet discriminar el procés pare delfill.

5.11 Compileu i executeu ex04.c. Com és que el procés pare no acaba mai?

5.12 Compileu i executeu ex05.c. Quants processos es creen? Quina relaciópare/fill existeix entre ells?

5.13 Compileu i executeu ex06.c. Quants processos es creen? Quina relaciópare/fill existeix entre ells?

5.14 Compileu i executeu ex07.c. Justifiqueu el resultat obtingut.

Per practicar

5.15 Compileu i executeu diverses vegades el programa ex11.c. On radica lasincronització?

5.16 Compileu i executeu diverses vegades el programa ex12.c. Comproveu comwait permet saber quin és el primer fill a acabar.


Per invocar-les cal especificar el nom del fitxer executable i els paràmetres de l'execució. Perconveni, el nom de l'executable també és un paràmetre. Per tant, per executar "ls -l", calespecificar el nom de l'executable ("ls") i els paràmetres ("ls" i "-l").

5.2.4 Crida al sistema exit

Aquesta crida permet indicar explícitament l'acabament d'un procés (fins ara, tots elsprocessos acabaven de forma implícita ja que arribaven al final de la rutina main).

exit té un paràmetre de tipus enter (el codi d'acabament, que ja vàreu veure al parlar de lacomanda test al capítol 3.2) que es pot utilitzar perquè el fill es comuniqui amb el seu pare.El pare podrà obtenir aquest valor mitjançant la crida wait.

Finalment, considerarem la temporització entre la mort d’un procés pare i el seu fill:

Un procés pare pot morir abans que els seus fills. En principi, això provoca untrencament a la jerarquia de processos. Per decisió de disseny, a Unix no es pottrencar la jerarquia de processos, és a dir, tot procés ha de tenir un procés pare viu.Per tant, quan un procés mor, els seus fills són adoptats pel procés ambidentificador de procés 1, un procés propi del sistema operatiu. Una de les tasquesd’aquest procés és invocar la crida al sistema wait.

Un procés fill pot morir abans que el seu pare. Des que un procés fill mor fins que elseu pare és conscient de la mort del seu fill (gràcies a la crida wait), el procés fillentra en un estat terminal anomenat zombie (defunct). Tot i que el procés és mort,encara no ha desaparegut completament del sistema i continua ocupant algunrecurs del sistema operatiu. De fet, si un programa crea molts processos quearriben a l’estat zombie i no s’eliminen invocant la crida al sistema wait, es podriaarribar a omplir la quota de processos de l’usuari i, fins i tot, saturar el sistema jaque no es podrien crear nous processos. Per tant, cal evitar que un programa puguiarribar a generar molts processos zombies.

Per practicar

5.17 Compileu i executeu el programa ex21.c Comproveu com s'invoca al'executable "ls". Com és que no apareix el missatge escrit amb el segonprintf?

5.18 Compileu i executeu el programa ex22.c Comproveu les diferències entre lesinterfícies de la crida execlp i la crida execvp comparant ex21.c i ex22.c.

5.19 Consulteu al manual les diferències entre les crides execl, execlp, execle,execv, execvp i execve. Quina és l’única que realment és una crida alsistema?



Al manual del sistema podeu consultar més paràmetres de les comandespresentades en aquest capítol.

Al manual del sistema podeu veure una descripció més detallada del funcionamentde les crides al sistema.

Existeix una versió més potent de la crida wait. S’anomena waitpid i permet,entre altres coses, sincronitzar el procés pare amb la mort d’un procés fill concret.

Per practicar

5.20 Compileu i executeu el programa ex31.c. Comproveu com existeix unacomunicació entre el fill i el pare. Comproveu com des de l'intèrpret decomandes podeu accedir al codi d'acabament del procés pare mitjançant lavariable ? (echo $?).

5.21 Compileu i executeu el programa ex32.c. Des d’una altra finestra, feu un llistatde tots els vostres processos. Què està passant? Utilitzant Ctrl-C, mateu elprograma ex32. Torneu a llistar tots els vostres processos. Què ha passat?

5.22 Escriviu un programa que mostri el fenomen de l’adopció de processos per partdel procés 1 (recordeu que Unix disposa de la crida al sistema getppid perquèun procés pugui conèixer l’identificador del seu procés pare).


6 Gestió de processos a UNIX (2/2)

L'objectiu d'aquest capítol és que desenvolupeu una aplicació que utilitzi les crides al sistemarelacionades amb la gestió de processos (fork, exec, wait i exit) vistes al capítol 5. A lapàgina web de suport trobareu els fitxers referenciats al document.

6.1 DESCRIPCIÓ GENERAL DE L'APLICACIÓ

L'aplicació que desenvolupareu simularà una partida entre N jugadors del joc de cartes del seti mig. Aquesta aplicació estarà composada per diversos processos: un procés pare (croupier)i N processos fills (jugadors).

Us facilitem el codi que hauran d'executar els jugadors (jugador1.c). El programa executaun bucle on a cada iteració genera una carta aleatòriament, acumula la puntuació i decideix sicontinua iterant o si finalitza l'execució (s'ha passat, té 7.5 o es planta). Compileu-lo(make jugador1) i executeu-lo per entendre el seu funcionament.

Haureu de desenvolupar el codi del procés croupier, que s'encarregarà de crear elsprocessos jugadors. Per desenvolupar l'aplicació us proposem un seguit de pasos de formaque les noves funcionalitats a implementar a cada pas estaran molt delimitades.

6.2 BIBLIOTECA libuso.a

També us facilitem una biblioteca (libuso.a, composada per wrappers.c i debug.c) queus simplificarà el tractament d'errors a les crides al sistema i la depuració de codi.

Tractament d'errors a les crides al sistema: us proporcionem uns wrappers("envoltoris") per a totes les crides al sistema que necessitareu. Aquests wrapperstenen la mateixa interfície que la crida al sistema corresponent i s'encarreguend'invocar-la i de fer la comprovació d'errors. En cas d'error, imprimeixen en colorvermell el missatge d'error associat a l'error produït i provoquen la finalització delprocés. El wrapper té el mateix nom que la crida al sistema llevat que el primercaracter és una majúscula (per exemple, el wrapper de la crida al sistema fork ésla rutina Fork).

Debug: us proporcionem una rutina (debug) que té la mateixa interficie queprintf. Per omissió, aquesta rutina realitza un printf en color blau de les dadesindicades, però afegint una línia al vostre codi font podeu aconseguir que lesinvocacions a la rutina no tinguin cap efecte. Aquest tipus de rutines és útil peractivar/desactivar ràpidament els "xivatos" del vostre codi sense haver-los decomentar/esborrar/escriure cada cop que els volem activar/desactivar.


Com a exemple, editeu el fitxer ex_libuso.c; observareu que apareixen invocacions a larutina debug per mostrar informació respecte a les accions que realiza el programa i que esfan servir els wrappers corresponents a les crides al sistema. Compileu-lo(make ex_libuso) i en executar-lo hauríeu de veure que apareixen línies en el colorhabitual de la finestra (resultats "normals" del programa), en color blau (línies de debug) i encolor vermell (errors a les crides al sistema). Fixeu-vos que les línies de debug i d'error estanprecedides pel pid del procés que les ha escrit i que les línies de debug també contenen elnom del fitxer i número de línia de codi font on s'han invocat.

Si editeu ex_libuso.c, esborreu els comentaris de la línia /*#define NDEBUG*/,compileu i executeu ex_libuso. Veureu que ara no s'imprimeixen les línies de debug.

Finalment, si voleu canviar els colors de les línies de debug i d'error cal editar debug.c imodificar els colors associats als símbols PREFIX_DEBUG i PREFIX_ERROR. Si voleu que leslínies no tinguin color, cal comentar la línia #define COLOR_ON de debug.c.

6.3 EXERCICI DE PROGRAMACIÓ

6.3.1 Pas 1: creació de N jugadors seqüencials

Implementeu un programa (croupier1.c) que rebrà per la línia de comandes un paràmetrenumèric (N). Aquest paràmetre indica el nombre de processos jugador que ha de crear;cadascun d'aquests processos haurà de carregar l'executable jugador1. Els processosjugadors s'executaran seqüencialment, és a dir, el jugador i-èssim es crearà quan el jugador(i-1)-èssim hagi acabat la seva execució (per tant, no s'haurien de barrejar línies impreses perdiferents processos jugadors). Observacions:

Al fitxer croupier1.c ja està implementada la lectura del paràmetre i es realitzenels includes necessaris. Per compilar-lo cal fer make croupier1.

Per carregar l'executable jugador1 utilitzeu la crida al sistema execv.

Per recordar com funcionen les crides, repasseu els exemples del capítol 5.

Us facilitem un executable anomenat croupier1_ok, que es comporta de laforma especificada (cal que l'executable jugador1 també existeixi al directoriactual). El vostre codi s'hauria de comportar d'una manera similar.


6.3.2 Pas 2: generació de N jugadors concurrents

Copieu croupier1.c sobre croupier2.c i modifiqueu croupier2.c de forma que eljugador i-èssim es creï encara que el jugador (i-1)-èssim no hagi acabat l'execució (per tant,es podran barrejar línies impreses per diferents jugadors). Observacions:

croupier ha de finalitzar la seva execució quan tots els jugadors hagin acabat.

Per generar croupier2, haureu d'afegir al fitxer Makefile un parell de líniesanàlogues a les quals generen l'executable croupier1.

Us facilitem un executable anomenat croupier2_ok. El vostre codi s'hauria decomportar d'una manera similar.

6.3.3 Pas 3: generació de resultats per part del procés croupier

Fins ara, el croupier no sap com han acabat els processos jugadors. Fareu que els jugadorsinformin el croupier de la seva puntuació final de forma que aquest pugui decidir qui haguanyat (en cas d'empat asssumiu que guanya el jugador de pid inferior). Copieucroupier2.c i jugador1.c sobre croupier3.c i jugador3.c i feu els canvisnecessaris sobre els nous fitxers. Observacions:

Hauríeu d'afegir a Makefile el necessari per compilar croupier3.

Us facilitem uns executables anomenats croupier3_ok i jugador3_ok. Elsvostres programes s'haurien de comportar de forma similar.

7 Sistema de fitxers Unix 61

7 Sistema de fitxers Unix

L'objectiu d'aquest capítol és aprofundir en les comandes Unix que permeten interaccionaramb el sistema de fitxers. S'assumeix que es recorda el funcionament de les comandes vistesal capítol 2 relacionades amb directoris (cd, pwd, mkdir, rmdir) i amb fitxers (cp, mv, rm,cat, more).

7.1 OBTENCIÓ D'INFORMACIÓ SOBRE FITXERS

lsMostra el contingut d'un directori (per defecte, del directori actual). Com en el cas de lacomanda ps, algunes opcions poden no ser presents a totes les distribucions Unix. Lamajoria de les opcions poden combinar-se entre elles. Algunes de les opcions més usualssón:

-l mostra proteccions, mida, propietari, data de creació ...

-a llista també els fitxers ocults (el primer caràcter del nom del fitxer és un .)

-R llista el contingut dels subdirectoris de forma recursiva

-i mostra el nombre d'inode, és a dir, l’identificador numèric que el sistemaoperatiu utilitza per identificar el fitxer

-h mostra la mida del fitxer en format human readable15

-d si passem com a paràmetre a ls -d el nom d'un directori, llista les sevescaracterístiques però no el seu contingut (compareu el resultat d’executar lacomanda ls -l /etc i el de la comanda ls -l -d /etc)

statMostra informació relativa al fitxer passat com a paràmetre: mida, dispositiu ons'enmagatzema, les dates de la darrera lectura sobre el fitxer (access), el darrer accésd'escriptura al contingut del fitxer (modify) i la darrera modificació del inode (change) ...

7.2 PROTECCIONS

Als sistemes Unix podeu trobar dos mecanismes de proteccions de fitxers: el clàssic (els 9bits rwxrwxrwx mostrats per ls i que són manipulats amb la comanda chmod) i les ACL(Access Control Lists) que manipulareu amb les comandes setfacl i getfacl.

15.En Gigabytes, Megagytes i Kilobytes.


chmodAl capítol 2.2.7 ja es va descriure el sistema clàssic Unix de protecció de fitxers:

Es consideren tres tipus d'usuaris: l’usuari propietari del fitxer, els usuaris quepertanyen al seu mateix grup d'usuaris i la resta d'usuaris de la màquina.

Es consideren tres tipus d’operacions: lectura (r), escriptura (w) i execució (x).

Els permisos d'un fitxer es representen amb nou caràcters. Els tres primers indiquen lesoperacions que pot realitzar el propietari del fitxer, els tres següents indiquen les operacionsrealitzables pels usuaris del mateix grup i els tres darrers indiquen les operacions realitzablesper la resta d'usuaris de la màquina. Per exemple, els permisos rwxr----- indiquen que elpropietari pot fer totes les operacions sobre el fitxer (rwx), que els membres del seu grupnomés poden fer lectures (r--) i que la resta d'usuaris no pot fer cap operació sobre el fitxer(---).

Per modificar els permisos d'un fitxer s'utilitza la comanda chmod, que codifica els permisosseguint el codi r=4, w=2 i x=1 i sumant els permisos de cada tipus d'usuari16. És a dir, lesproteccions rwxr-x--- es representen com 750 (4+2+1, 4+0+1, 0+0+0).

chmod està parametritzada amb els permisos a assignar al fitxer i el(s) nom(s) del(s) fitxers.Per exemple, chmod 631 file fa que file passi a tenir proteccions rw--wx--x. Lacomanda chmod admet l'opció -R per a modificar els permisos a tots els fitxersemmagatzemats a una estructura de directoris.

umaskMostra la màscara de permisos màxims assignables als fitxers que es creïn. Aquestamàscara no és més que un nombre octal (per exemple, 027, 22 o 7). Per interpretar-lo, calafegir zeros per l'esquerra fins a tenir un total de tres dígits: el primer/segon/tercer dígit indicaels permisos que no es poden aplicar al propietari/membres del grup/resta d'usuaris. Perexemple, 027 indica que, com a molt, els nous fitxers seran rwx per al propietari, rx per alsmembres del grup i la resta d'usuaris no tindran cap permís.

Per modificar la màscara cal executar umask indicant con a paràmetre el nou valor de lamàscara de permisos màxims.

La màscara és útil per garantir que els programes no crearan fitxers que siguinllegibles/modificables per tots els usuaris de la màquina. Si un cop creat un fitxer modifiqueuels seus permisos amb chmod, el valor de la màscara no té cap influència.

16.També podeu pensar en la codificació en base 2 de les proteccions: r=100, w=010 i x=001. Com aexemple, les proteccions rwxr-x--- es representarien com a 111101000.


setfacl/getfaclCom que les ACL no estan suportades a totes les versions de Unix/Linux, hauríeu dedeterminar si la vostra màquina les suporta: si executeu man setfacl i apareix lacorresponent pàgina de manual, probablement les suporti.

Les ACL eliminen la rigidesa dels 9 bits rwxrwxrwx ja que permeten definir permisos sobreun fitxer per a un usuari concret, sense haver de definir-los per a tots els membres del seugrup d'usuaris o per a tots els usuaris de la màquina.

Cada fitxer pot tenir associada una llista d’ACL entries que tenen la sintaxiàmbit:identificador:permisos on àmbit pot ser u (user) , g (group) o o (other),identificador és un identficador d'usuari o de grup (o res per a afectar a tots) i permisosés una combinació dels caràcters rwx-.

setfacl permet definir ACL entries sobre un fitxer. Cal parametritzar-la amb l'opció -m,indicar la ACL entry que volem definir i el nom del(s) fitxer(s) afectat(s). Per exemple,setfacl -m u:username:r fitxer dóna permís de lectura a username sobre fitxer. Pereliminar una ACL entry cal parametrizar la comanda amb l'opció -x, indicar la ACL entry aeliminar (sense posar els permisos) i el nom del(s) fitxer(s) afectat(s).

getfacl mostra les ACL associades al fitxer indicat com a paràmetre. Com a mínim, mostrales ACL corresponents als permisos rwxrwxrwx del fitxer.

Per decidir si un usuari té accés a un fitxer, les ACL entries més prioritàries són les de tipususer, i la de tipus other és la menys prioritària.

Si definiu ACL sobre un fitxer, la comanda ls amb el paràmetre -l mostrarà el signe +després dels permisos del fitxer.

Per practicar

7.1 Hi hauria alguna diferència entre assignar permisos 007 i 777 a un fitxer?

7.2 Com s'interpreten els permisos rwx sobre un fitxer de tipus directori? Realitzeules proves pertinents per a determinar-ho.

7.3 Quins són tots els permisos mínims necessaris per poder esborrar un fitxer?


7.3 MUNTATGE DE DISPOSITIUS D'EMMAGATZEMAMENT

Una característica d’Unix és que tots els dispositius d'emmagatzemament estan integrats dinsde l'arbre de directoris ofert pel sistema. Això permet que dins del mateix arbre de directorispugui haver-hi fitxers emmagatzemats a un disc dur local, d'altres a un disc dur remot, d'altresa un cd-rom ..., tot això de forma transparent a l'usuari.

mountPer omissió, mostra els dispositius d'emmagatzemament muntats actualment (/dev/fd0,/dev/hda1, /dev/sda3,...), el directori de l'arbre de directoris on estan muntats (/,/home,...) i el format del dispositiu (ext2, nfts, vfat, usbfs, nfs ...).

Els noms dels dispositius d'emmagatzemament més tipics són /dev/floppy o /dev/fd0(disquetera), /dev/hdc (tercer dispositiu IDE), /dev/hda2 (tercera partició del primerdispositiu IDE), /dev/sdb2 (tercera partició del segon dispositiu SCSI) ...

Si esteu autoritzats (l’usuari root sempre ho està, però es poden autoritzar d’altres usuaris), lacomanda mount permet muntar nous dispositius a l'arbre de directoris. Cal parametrizar-laamb el nom del dispositiu a muntar i el nom del directori que constituirà el punt de muntatge(per exemple, mount /dev/fd0 /floppy). Un cop muntat, els fitxers que trobareu a partirdel punt de muntatge corresponen amb el contingut del sistema de fitxers del dispositiumuntat.

umount Per desmuntar un dispositiu de l'arbre de directoris és precís utilitzar la comanda umountpassant-li com a paràmetre el nom del dispositiu a desmuntar. Aquesta comanda provoca ques'actualitzin al dispositiu tots els fitxers que hagin estat modificats17 i comprova que no hi hagicap procés utilitzant algun fitxer del dispositiu.

Quan guardeu informació a dispositius extraïbles com ara els disquets, és vital desmuntar eldispositiu corresponent abans d'extreure el disquet de la unitat de lectura; altrament, podeu

17.Penseu que, per motius d'eficiència, les escriptures a disc no l'actualitzen directament sinó querealitzen l'escriptura sobre memòria i, quan ho decideixi el SO, l'escriptura es realitzarà realment adisc.

Per practicar

7.4 A una distribució on existeixin ACL, creeu un fitxer anomenat acl.prova alvostre home directory que pugui ser llegit únicament per vosaltres i per l'usuaripr_uso.

7.5 A una distribució on existeixin ACL, creeu un directori anomenat uso.dir alvostre home directory on únicament l'usuari pr_uso pugui crear nous fitxers.


perdre les darreres modificacions realitzades. Quan es fa el shutdown d'una màquina, elsistema desmunta ordenadament tots els dispositius que estiguessin muntats.

Fitxer /etc/fstabAquest fitxer conté informació relativa als sistemes de fitxers que es munten en iniciar lamàquina i els punts de muntatge habituals dels dispositius extraïbles. També pot haver-hiinformació respecte als sistemes de fitxers extraïbles i quins usuaris estan autoritzats amuntar-los.

Si quan munteu un dispositiu existent al fitxer /etc/fstab no indiqueu el punt de muntatge,el sistema farà servir el punt de muntatge especificat a /etc/fstab.

7.4 ENLLAÇOS (LINKS)

lnPermet crear hard i soft links.

ln fitxer_existent nom_link crea un hard link entre nom_link i fitxer_existent És a dir, dos noms defitxers diferents que faran referència directament al mateix inode. És necessari queel nou link es creï al mateix dispositiu on s'emmagatzema el fitxer.

ln -s fitxer_existent nom_link crea un soft link (o symbolic link) entre nom_link i fitxer_existent És a dir,un nom de fitxer que farà referència indirectament a l’inode associat a un altrefitxer.

La comanda ls amb el paràmetre -l mostra informació relacionada amb els enllaços. Elnombre mostrat a continuació dels permisos d'un fitxer indica el nombre de hard links al'inode corresponent al fitxer. Si el fitxer és un soft link, ls indica que és de tipus l (primercaràcter de la línia mostrada per ls) i, a continuació del nom, ens mostra el fitxer amb quis'ha establert l'enllac.

Per practicar

7.6 Munteu un disquet i comproveu com aquest dispositiu apareix a la llista dedispositius muntats mostrats per la comanda mount.

7.7 Feu un cd sobre el punt de muntatge i intenteu desmuntar el disquet. Per quèapareix el missatge d'error?

7.8 Munteu un CD i tot seguit premeu la tecla d'obertura de la unitat de CD. Com ésque no respon?


7.5 OCUPACIÓ D'ESPAI

dudu (disk usage) permet conèixer la quantitat d’espai d’emmagatzemament ocupat per tot unarbre de directoris.

Per defecte, du mostra l'espai ocupat (incloent-hi la fragmentació interna i típicament enKilobytes) per tot l'arbre de directoris situat a partir del directori actual; per a cada directori del'arbre, mostra quin espai total ocupa. Si passeu com a paràmetre(s) nom(s) defitxer(s)/directori(s), mostrarà les dades respecte els fitxer(s)/directori(s) indicats.

Amb l'opció -s mostra únicament l'espai total ocupat per l'arbre de directoris, amb l'opció -hmostra les dades en format human readable, amb l'opció -a mostra l'ocupació de cada fitxerordinari present a l'arbre de directoris i amb l'opció --apparent-size mostra l'ocupaciósense considerar la fragmentació interna.

quotaSi treballeu en un sistema configurat de forma que els usuaris tinguin assignades quotesd'ocupació de disc, aquesta comanda permet conèixer els sistemes de fitxers on podeuemmagatzemar informació, el nombre de blocs de disc que esteu ocupant actualment i elnombre màxim que podeu arribar a ocupar. Alguns sistemes també permeten limitar elnombre de fitxers que té creats un usuari.

Alguns sistemes de quotes permeten que l’usuari superi el límit establert durant un certtemps, és el que es coneix com a grace.

dfInforma respecte la utilització de l'espai d'emmagatzemament als dispositius indicants (perdefecte, tots els que estiguin muntats). Per a cada dispositiu mostra l'espai total, l'ocupat, eldisponible, el percentatge d'ocupació i el punt de muntatge.

Per practicar

7.9 Creeu al vostre home directory un fitxer anomentat pshard que sigui un hardlink a /bin/ps. Podeu executar pshard? Com comprovaríeu que realment téassociat el mateix inode que /bin/ps ?

7.10 Creeu al vostre home directory un fitxer anomentat pssoft que sigui un soft linka /bin/ps. Podeu executar pssoft? Com comprovaríeu que realment téassociat un inode diferent que /bin/ps ?

7.11 Podeu justificar d’alguna forma la mida dels fitxers soft link? Feu les proves queconsidereu necessàries.

7.12 Creeu un directori al vostre home directory i executeu ls -l. Com és quel'inode corresponent al directori acabat de crear té dos hard links?


Amb l'opció -i informa respecte la utilització d'inodes, amb l'opció -h mostra les dades enformat human readable, i si especifiqueu com a paràmetre un nom de fitxer, informa sobre eldispositiu d'emmagatzemament on es troba el fitxer.

7.6 COMPACTACIÓ I COMPRESSIÓ DE FITXERS

tarAquesta comanda permet compactar un arbre de directoris i tots els fitxers que hi sónpresents; el resultat de la comanda és un únic fitxer.

tar -cf file.tar directori(s)/fitxer(s) Crea un fitxer tar (file.tar) amb el contingut del directori(s)/fitxer(s) especificats.

tar -xf file.tar Descompacta els fitxers continguts a un fitxer .tar

tar -tf file.tar Mostra el contingut d’un fitxer .tar

Com ja vàreu veure al capítol 4.5, els fitxers tar acostumen a utilitzar-se quan es vol transferirtot un arbre de directoris

Per reduir el seu espai, els fitxers tar acosumen a ser comprimits utilitzant algun delscompressors que es mencionen a continuació.

Per practicar

7.13 Escriviu una comanda que mostri els dos directoris del directori actual queocupen mes espai a disc.

7.14 Escriviu un shellscript tal que, donat un nom de directori, ens indiqui lafragmentació interna que es produeix a l'emmagatzemament a disc de tot el seuarbre de directoris. El nom del directori serà un paràmetre del shellscript.

7.15 Escriviu un shellscript tal que, cada N segons, comprovi si el percentaged'ocupació de la vosta quota de disc supera el M% a algun dispositiu; en casafirmatiu, ha de mostrar un missatge indicant el nom del dispositiu. N i M serandos paràmetres d'entrada del shellscript.

7.16 Escriviu un shellscript tal que, cada N segons, comprovi si hi ha algun dispositiud'emmagatzemament amb un percentatge d'ocupació total superior al M%; encas afirmatiu, ha de mostrar un missatge indicant el nom del dispositiu. N i Mseran dos paràmetres d'entrada del shellscript.


compress/uncompress, gzip/gunzip, bzip2/bunzip2, zip/unzipAquests parells de comandes comprimeixen/descomprimeixen fitxers. Els fitxers comprimitsper cadascuna de les comandes tenen una extensió característica: .Z (compress), .gz(gzip), .bz2 (bzip2) i .zip (zip).

compress espera com a paràmetre un (o més) fitxers i comprimeix el seu contingut generantun fitxer .Z per a cada fitxer d'entrada; a més, esborra els fitxers originals. uncompress ésanàleg a compress i també esborra els fitxers d'entrada. La interfície de gzip/gunzip ibzip2/bunzip2 és força similar a la de compress/ uncompress.

La comanda zip combina les funcionalitat de compactació i compressió. Li hem de passarcom a paràmetre el nom del fitxer .zip a generar i la llista de fitxers a compactar i comprimir.Té opcions que permeten indicar que ha de compactar i comprimir tota una estructura dedirectoris o que ha d'actualitzar únicament alguns fitxer del .zip. La comanda unzip estàparametrizada amb el nom del fitxer a descomprimir.

D’altres opcions molt útils de moltes d’aquestes eines són verificar la integritat dels fitxerscomprimits (típicament, opció -t) i protegir amb password els fitxers comprimits.

zmore / zcat / zgrep / bzcat / zipgrepPermeten examinar el contingut dels fitxers comprimits sense haver de descomprimir-losprèviament. Consulteu el manual per veure el seu funcionament.

7.7 BÚSQUEDA DE FITXERS: COMANDA find

Permet buscar fitxers que compleixin una determinada condició. Per construir la condiciópodeu utilitzar un munt de característiques del fitxer: la data del darrer accés, la data de ladarrera modificació, el format del sistema de fitxers on s'emmagatzema, el seu propietari, elnombre del seu inode, el nombre de links, els permisos, la mida, el tipus del fitxer ... A més,també podeu utilitzar comandes del shell (grep ...) per a construir les condicions. Tot plegatfa que la potència d'aquesta eina sigui molt gran.

Per practicar

7.17 Genereu un fitxer .tar amb tot el contingut de la vostra zona de disc.Compareu l’ocupació d’espai de disc d’aquest fitxer amb l’ocupació d’espai dedisc de la vostra zona de disc.

7.18 Comprimiu un mateix fitxer (per exemple, /bin/vi) amb els diversoscompressors. Comproveu quin d’ells comprimeix més el fitxer.

7.19 Comprimiu un fitxer de text amb zip. Comproveu que zipgrep us permetrealitzar una bùsqueda dins del fitxer sense haver-lo de descomprimir.


La sintaxi de la comanda és find dir1 ... dirM cond1 ... condN . La comandabusca, a partir de cadascun dels directoris indicats (i els seus subdirectoris), fitxers quecompleixin totes les condicions indicades. Les condicions s'avaluen d'esquerra a dreta.

Exemples:

find /bin -links +1 Busca fitxers a /bin i als seus subdirectoris que tinguin 1 o més hardlinks i ensmostra el seu nom.

find /bin -links +1 -type fCom l'anterior però restringeix el resultat als fitxers ordinaris (-type f).

find -size +8k -printf '%p %s\n' Busca els fitxers del directori actual i de tots els seus subdirectoris (directori peromissió), fitxers de 8 o més Kbytes (-size +8k) i escriu el seu nom i mida(-printf '%p %s\n').

find . -name core -exec rm -i {} \; -print Busca fitxers que s'anomenin core (-name core), demana confirmació peresborrar-los (-exec rm -i {} \;) i finaliment escriu el seu nom (-print).-exec permet executar una comanda qualsevol del sistema. En aquest cas, per acada fitxer que superi la primera condició s'executa rm -i nom_fitxer ja que {}representa el nom del fitxer i \; indica la finalització de paràmetres per la comandaexecutada amb -exec.

find /usr/include -name '*.h' -exec grep -H SIGCHLD {} \; Busca els fitxers de /usr/include i els seus subdirectoris (/usr/include) quetinguin extensió .h (-name '*.h', cal posar les cometes per evitar que el shellinterpreti el metacaràcter * i permetre que l’interpreti la comanda find) i quecontinguin la seqüència de caràcters SIGCHLD. En aquest cas, per a cada fitxer que superi la primer condició s'executa grep -HSIGCHLD nom_fitxer .Tal com s'ha parametritzat la comanda grep, mostrarà els noms del fitxers quecontenen la seqüència i el contingut complet de la línia amb la seqüència.

find -atime +1 -type f -exec mv {} TMP \; Mou els fitxers no accedits al llarg del darrer dia (-atime +1) al directori TMP deldirectori actual.



Com sempre, el manual del sistema us pot donar molta informació respecte totesles comandes presentades a aquest capítol. En especial, el manual de la comandafind és particularment interessant ja que aquesta comanda té molts mésparàmetres dels comentats en aquest capítol.

Per practicar

7.20 Escriviu una comanda que mostri els fitxers ordinaris del directori actual i elsseus subdirectoris que fa més d'una setmana que han estat modificats i quetenen una mida superior a 10 Kbytes.

7.21 Escriviu una comanda que copiï al directori updated tots els fitxers ordinaris deldirectori actual i els seus subdirectoris que hagin estat modificats al llarg de lesdarreres 48 hores (per fer proves pot resultar-vos útil la comanda touch quepermet modificar les dates associades a un fitxer).

7.22 Escriviu una comanda que busqui al directori actual i els seus subdirectoris elsfitxers ordinaris que hagin estat modificats fa menys de 24 hores. El nom de totsaquests fitxers haurà de modificar-se i afegint-hi l'extensió .ahir

8 Entrada/sortida a UNIX (1/2) 71

8 Entrada/sortida a UNIX (1/2)

Els objectius del capítol són: a) familiaritzar-vos amb les crides al sistema Unix bàsiquesd'entrada/sortida (open, read, write, close, lseek) i b) saber obtenir informació des delshell Unix respecte l'ús de fitxers (lsof i /proc). A la pàgina web de suport trobareu elsfitxers referenciats al document. En cas de dubte respecte a la funcionalitat de comandes ocrides al sistema, consulteu el manual del sistema (comanda man).

8.1 CRIDES AL SISTEMA UNIX

8.1.1 Crides al sistema read i write

La crida read llegeix dades d'un canal d'entrada/sortida (descriptor de fitxer) i les porta amemòria. La crida write escriu dades emmagatzemades a memòria sobre un canal.

Totes dues crides estan parametrizades de la mateixa manera: el canal sobre el qual volemllegir (escriure), la direcció de memòria a partir de la qual volem emmagatzemar les dadesque es llegeixin (o on es troben les dades a escriure) i el nombre màxim de bytes que volemllegir (escriure). La crida retorna el nombre de bytes que realment s'han llegit (escrit); si lacrida read retorna que ha llegit 0 bytes, indica que s'ha arribat al final del fitxer. Les duescrides assumeixen que els fitxers s'accedeixen seqüencialment, és a dir, el primer read d'unbyte sobre un canal ens retorna el primer byte del fitxer corresponent, el segon read ensretornaria el segon byte, i així successivament.

Tot procés creat des del shell té oberts tres canals:

El canal 0 (també anomenat canal d'entrada estàndard). Per defecte, està associatal teclat, però utilitzant el metacaràcter < indiqueu al shell que l'associï a un altrefitxer (és a dir, estaríeu redireccionant el canal d'entrada estàndard).

El canal 1 (també anomenat canal de sortida estàndard). Per defecte, està associata la pantalla, però utilitzant el metacaràcter > indiqueu al shell que l'associï a unaltre fitxer (és a dir, una redirecció del canal de sortida estàndard).

El canal 2 (també anomenat canal d'error). Per defecte, està associat a la pantalla,però utilitzant el matacaràcter 2> indiqueu al shell que l’associï a un altre fitxer.

int read(int fd, char *addr, int nbytes);int write(int fd, char *addr, int nbytes);


8.1.2 Crides al sistema open i close

Si un procés necessita llegir o escriure fitxers que no siguin els associats als canalsestàndard, és necessari que obri aquests fitxers. La crida responsable d'aquesta tasca és lacrida open. Aquesta crida està parametrizada amb el nom del fitxer i el mode com obrir elfitxer (O_RDONLY, O_WRONLY o O_RDWR); si tot és correcte, la crida open retorna el canalassociat al fitxer obert. Les posteriors lectures i/o escriptures sobre el fitxer hauran d'utilitzarel canal retornat per la crida al sistema open. La crida close és la que ens permet indicar alsistema que el procés no vol utilitzar més un determinat canal.

Per practicar

8.1 es01.c és un programa que llegeix caràcters del canal 0 i els escriu pel canal 1transformant les majúscules en minúscules i a l'inrevés. Compileu-lo (makees01) i executeu-lo de dues formes a) redireccionant l'entrada estàndard aprova1.txt (es01 < prova1.txt) i b) redireccionant l'entrada i la sortidaestàndard cap a dos fitxers diferents. Comproveu que els resultats són elsesperats.

8.2 Executeu es01 sense redireccionar els canals estàndard. A mesura queintroduïu línies, s'aniran convertint. Per a indicar al sistema que ja no hi ha méscaràcters, cal prèmer Ctrl D; això provoca que la crida al sistema read sobreteclat retorni que ha llegit 0 caràcters. En general, quina diferència hi hauriaentre prémer Ctrl-C i Ctrl-D?

8.3 Implementeu el programa parell1.c. Aquest programa hauria de llegir elcanal 0 fins a detectar final de fitxer i escriure pel canal 1 els caràcters llegits aposicions parells (el primer byte és considera que és troba a una posició parell,la zero). Per exemple, si l'executeu redireccionant l'entrada estàndard aparell.txt, hauria de mostrar pel canal 1 Missatge amagat. Observacions: Afegiu al fitxer Makefile el necessari per a poder compilarparell1.c . Com al capítol 6, per facilitar el tractament d’errors podeu utilitzarla biblioteca libuso, que incorpora els wrappers per les crides al sistemad’entrada/sortida.

Per practicar

8.4 Compileu el programa es11.c. Aquest programa és un refinament de es01.c;admet com a paràmetre la llista de fitxers a convertir (per exemple, el podríeuinvocar fent es11 es01.c prova1.txt es11.c). El programa tractarà totsels fitxers.

8.5 Copieu parell1.c sobre parell2.c. Modifiqueu parell2.c de forma quetracti un a un els fitxers que l'usuari indiqui com a paràmetre.


8.1.3 Crida al sistema lseek

Tot fitxer obert té associat un punter que indica la posició sobre la qual es farà la següentoperació de lectura/escriptura. Després de cada lectura/escriptura, aquest punters'incrementa amb el nombre de caràcters llegits/escrits. Per tant, el funcionament d'aquestpunter està pensat per accedir seqüencialment als fitxers.

La crida lseek ens permet modificar el valor d'aquest punter. La modificació es pot ferrespecte a la posició actual del punter (SEEK_CUR), respecte a la darrera posició del fitxer(SEEK_END) o respecte a l'inici del fitxer (SEEK_SET). Consulteu el manual del sistema perveure tots els paràmetres de la crida, la seva interpretació i quin resultat retorna.

8.1.4 Consideracions d'eficiència

Els programes que heu utilitzat fins ara llegien i escrivien caràcter a caràcter tot i que lescrides read i write permeten llegir i escriure diversos caràcters simultàniament. A algunsprogrames, el fet de llegir caràcter a caràcter pot tenir repercusions en el temps d'execuciódel programa. Penseu que cada cop que s'invoca el sistema operatiu, aquest ha de fer unseguit d'operacions (canvi de mode d’execució, comprovació de paràmetres, accés a la taulade canals ...) que poden fer augmentar el temps d'execució del programa.

8.2 EXERCICI DE PROGRAMACIÓ: COMPRESSOR/DESCOMPRESSOR DEFITXERS

L'algorisme de compressió que utilitzareu compacta totes les aparicions consecutives d'unmateix caràcter per 3 caràcters: 1) el caràcter '\0', és a dir, el caràcter de codi ASCII zero,

Per practicar

8.6 Comproveu que es21.c mostra el segon caràcter del fitxer indicat per l'usuari.

8.7 Escriviu un programa que, utilitzant la crida al sistema lseek, permeti obtenir lamida del fitxer indicat per l'usuari.

8.8 Escriviu un programa que mostri les dues darreres línies del fitxer indicat perl'usuari (en llenguatge C, el salt de línia es representa amb el caràcter '\n').

Per practicar

8.9 El programa es31.c realitza un bucle on a cada iteració bolca el contingut d'unfitxer sobre un altre i mostra el temps que ha trigat a realitzar cada iteració. Laprimera lectura del fitxer utilitza un buffer de 64 Kbytes, la segona un buffer de32 Kbytes ..., fins a un buffer d'1 byte. Executeu-lo i justifiqueu els resultatsobtinguts.


2) el propi caràcter repetit i 3) el caràcter de codi ASCII igual al nombre de repeticions. Laresta de caràcters es deixen inalterats.

A continuació es mostra un exemple de compressió. Si compr és l'executable del compressorque llegeix el fitxer a comprimir per la seva entrada estàndard (canal 0) i escriu el fitxercomprimit per la seva sortida estàndard (canal 1). Com que el fitxer comprimit pot tenircaràcters no imprimibles, s'utilitzarà la comanda od (octal dump) per a analitzar el seucontingut. Exemple:

prompt$ cat f1aaaaabcdddaabaprompt$ compr < f1 > f1.Zprompt$ od -bc f1.Z0000000 000 141 005 142 143 000 144 003 141 141 142 141 012 Codi ASCII (octal)

\0 a 005 b c \0 d 003 a a b a \n Representació gràfica0000015 prompt$

Observeu que la seqüència de dues 'a' consecutives no ha estat comprimida perquè haguésocupat més espai que l'ocupat sense comprimir.

8.2.1 Descompressor sense paràmetres

Implementeu el codi del descompressor (uncompr.c) considerant que:

Ha de llegir els caràcters a descomprimir per la seva entrada estàndard, i escriureel resultat de la descompressió per la seva sortida estàndard. Haurà d'acabar quandetecti el final de fitxer llegint de l'entrada estàndard.

Podeu considerar que cap caràcter estarà repetit més de 255 vegades.

Els executables compr_ok i uncompr_ok són un compressor i undescompressor que segueixen l'algorisme de compressió explicat. Utilitzeu-los percomparar el resultat del vostre descompressor amb el resultat generat per undescompressor correcte. Recordeu que la comanda diff permet comparar dosfitxers: diff file1 file2, escriu un missatge si els fitxers són diferents, noescriu res si són iguals.

També podeu utilitzar com a fitxers d'entrada skull.Z i miss.Z.


8.2.2 Descompressor amb paràmetres

Modifiqueu el codi anterior de forma que reconegui arguments per la línia de comandes.

Si s'indica un paràmetre, aquest s'interpretarà com el nom del fitxer adescomprimir. Serà precís que aquest nom del fitxer acabi en .Z. (les rutines debiblioteca strcmp i strlen us poden resultar útils per implementar aquestacomprovació).

El resultat s'haurà d'escriure a un fitxer que tingui el mateix nom però eliminant elsufix .Z. (la generació del nom del fitxer és molt senzilla si teniu clar com esrepresenten els strings en llenguatge C).

Si no s'indica cap paràmetre, el compressor haurà de comportar-se com abans.

Si s'indica més d'un paràmetre, haurà de mostrar algun missatge d'error.

Al vostre programa només hauria d'haver-hi una versió del "nucli" del programa (elbucle que llegeix els caràcters a descomprimir i els descomprimeix).

Exemple:

prompt$ uncompr panic.cerror: Fitxer panic.c no te extensio .zprompt$ uncompr f1.zprompt$ more f1aaaaabcdddaabaprompt$ uncompr f1 f1.zerror: Nombre de paràmetres incorrecteprompt$ uncompr <f1.zaaaaabcdddaabaprompt$

8.2.3 Descompressor amb seqüències majors de 255 caràcters

Ara tractareu la possibilitat que un caràcter aparegui més de 255 vegades consecutives alfitxer d'entrada. En aquest cas, l'algorisme de compressió substituirà aquesta seqüència per 7caràcters: 1) i 2) com abans, 3) el caràcter de codi ASCII zero i 4) a 7) els quatre caràctersque codifiquen l'enter que conté el nombre de repeticions del caràcter.

Els 4 caràcters que codifiquen un nombre enter al fitxer comprimit han estat escritsamb la crida al sistema write(1, &n, sizeof(int))

Podeu utilitzar el fitxer llarg.Z com a fitxer d'entrada


8.2.4 Compressor

Implementeu el compressor de fitxers (compr.c) corresponent a l'algorisme indicat. Penseuen el tractament que cal donar en cas que el caràcter de codi ASCII zero aparegui al fitxer acomprimir; existeix un tractament que no requereix modificar el descompressor que heuimplementat.


8.3.1 Comandes

lsofMostra els fitxers oberts pels diferents processos del sistema. A més de les entradescorresponents a les de les taules de canals dels processos, també mostra informació sobre elfitxer executable, sobre els fitxers de tipus biblioteca que utilitzen els processos ...

Per omissió, per a cada fitxer obert mostra una línia amb el nom i el pid del procés quel'utilitza, l'identificador d'usuari propietari, el FD (indica el descriptor de fitxer o cwd -workingdirectory-, txt -fitxer executable-, mem -fitxer mapejat a memòria-,...), el TYPE (indica si és unfitxer ordinari -REG-, directori -DIR-,...), el DEVICE (major i minor del dispositiu ons'emmagatzema), la mida del fitxer, el seu inode i el nom del fitxer.

Aquesta comanda ofereix diversos paràmetres per restringir la informació mostrada.


Com ja es va veure al capítol 5, moltes màquines Unix i Linux utilitzen un pseudo-sistema defitxers per oferir informació variada sobre els sistema i sobre els processos que s'hi executen.Per omissió, aquest sistema de fitxers es munta a /proc.

A /proc hi ha un directori per a cada procés del sistema; el nom del directori coincideix ambel pid del procés. Dins de cadascun d'aquests directoris hi ha un directori anomenat fd.Aquest directori mostra els canals oberts que té el procés i a quin fitxer correspon cadascund'aquests canals.



Com sempre, les pàgines de manual de les crides al sistema i de les comandespoden aportar-nos més informació respecte al seu funcionament i les sevesopcions.

A aquest capítol heu treballat l’entrada/sortida sobre fitxers. De totes formes, Linuxpermet fer entrada sortida sobre altres tipus de dispositius com ara les pipes i elssockets. Des del punt de vista del programador, la forma d’accedir-hi és forçasimilar a la que hem vist però existeixen algunes diferències. Al capítol 9 uspresentarem els sockets ja que són un mecanisme més potent que les pipes. Elsinteressats a obtenir més informació sobre les pipes, poden consultar la pàgina demanual de la crida al sistema pipe.

Un mateix programa pot barrejar crides al sistema de processos (vistes al capítol 5)i les d’entrada sortida vistes en aquest capítol. Al capítol 9 treballareu amb algunsprogrames que les barregen. De totes formes, consultant les pàgines de manual deles crides al sistema fork i execv podreu veure explicats els efectes d’aquestainteracció.

Per practicar

8.10 Escriviu un shellscript tal que, mitjançant la comanda lsof, mostri, per acadascun dels vostres processos, el seu pid i quants canals oberts té.

8.11 Escriviu un shellscript tal que, mitjançant la informació present al directori/proc, mostri, per a cadascun dels vostres processos, el seu pid i quantscanals oberts té.

8.12 Escriviu un shellscript que mostri quins processos estan utilitzant unadeterminada biblioteca (pista: pot resultar-vos útil el filtre uniq vist al capítol2.5.1).

8.13 Escriviu un shellscript que mostri, per a tots els processos del sistema, el seupid i el nombre de biblioteques que està utilitzant.

8.14 Escriviu un shellscript que, per a cada biblioteca en ús, indiqui quants processosl'estan utilitzant.


9 Entrada/sortida a UNIX (2/2)

Els objectius del capítol són: a) familiaritzar-vos amb les crides al sistema Unix bàsiquesd'entrada/sortida sobre sockets TCP (socket, bind, listen, connect, accept) i b) saberobtenir informació des del shell Unix respecte a la xarxa (informació de les màquines,connexions establertes pels vostres processos ...). A la pàgina web de suport trobareu elsfitxers referenciats al document. En cas de dubte respecte la funcionalitat de comandes ocrides al sistema, consulteu el manual del sistema (comanda man).

9.1 INTRODUCCIÓ

Els sockets són un mecanisme de comunicació per processos que s’executen a màquinesdiferents d’una mateixa xarxa (per exemple, Internet). Molts processos que es comuniquenmitjançant sockets segueixen el model de comunicació client-servidor, on un dels processos(client) genera una petició, l’envia a l’altre procés (servidor), aquest la processa i retorna laresposta al procés client. Un exemple típic seria el vostre navegador web (procés client) i elprocés que us retorna les pàgines on esteu navegant (procés servidor).

En aquest capítol ens centrarem en un tipus de sockets, els sockets TCP. També existeixensockets de tipus UDP. La diferència entre ells és la fiabilitat; els sockets TCP ofereixen uncanal de comunicació fiable. És a dir, de forma transparent a l’usuari, el sistema operatiu faràtot el possible per garantir que totes les dades enviades pel procés client arribin al servidor (ia l'inrevés) exactament en el mateix ordre com han estat escrites; en cas de problemes deconnectivitat, el protocol de comunicacions farà les retransmissions necessàries per tal quetotes les dades arribin al destinatari. Únicament en cas que el protocol consideri que ésimpossible garantir que les dades arriben al destinatari, el procés rebrà la notificació d’error.En canvi, en els sockets UDP, el sistema operatiu no fa aquest esforç. Tot i la manca defiabilitat, els sockets UDP són adients per determinats tipus d’aplicacions on no resulti críticala pèrdua de quantitats petites d’informació (per exemple, transmissió de veu en temps real).

9.2 CRIDES AL SISTEMA

Es presenten diversos programes d'exemple que mostren el funcionament de les crides alsistema relacionades amb la comunicació de processos mitjançant sockets TCP. Aquestescrides permenten comunicar processos que estiguin executant-se a màquines diferents. Tot ique la vostra màquina no estigui connectada a la xarxa, també les podeu utilitzar percomunicar processos executant-se a la mateixa màquina.


9.2.1 Servidors TCP

Els processos que vulguin oferir algun servei a d'altres processos mitjançant una connexióTCP han de seguir una sèrie de passos:

Crear un canal d'entrada/sortida de tipus socket (crida al sistema socket).

Associar el canal a un port de comunicació de la màquina (crida bind).

Dimensionar la mida d'una cua interna d'espera (crida listen).

Esperar peticions de connexió dels clients (crida accept).

Quan aparegui un procés client, el servidor i el client podran comunicar-se mitjançant el canalretornat per la crida al sistema accept. Un cop atès el client, el servidor pot atendre nousclients repetint la crida al sistema accept.

Us facilitem el codi d'un procés servidor (serv_iter). Aquest servidor retorna les línies delfitxer /etc/passwd que comencen per uns caràcters determinats. Per posar-lo en marxa calcompilar-lo (make serv_iter) i executar-lo passant-li com a paràmetre el port on voleuassociar el servei. Els ports s'idenfiquen amb nombres enters i, per conveni, alguns serveisestan associats a ports concrets: www (80), ftp (21), ssh (22),...; els ports inferiors a 1024estan reservats per a processos iniciats des d’usuaris privilegiats.

9.2.2 Clients TCP

Els processos que vulguin ser clients d'algun servidor han de seguir una sèrie de passos:

Crear un canal d'entrada/sortida de tipus socket (crida al sistema socket).

Connectar-se amb un servidor associat a un port d'una màquina (crida connect).

Un cop establerta la connexió, el client i el servidor podran intercanviar-se informació utilitzantles crides read i write sobre els canals associats a la connexió TCP.

Per practicar

9.1 Invoqueu el programa serv_iter passant-li com a paràmetre un número deport major o igual que 1024. Com és que no s'executa la sentència debugposterior a la crida al sistema accept?

9.2 Quina diferència hi ha entre el canal retornat per la crida al sistema socket i elcanal retornat per la crida al sistema accept?

9.3 Si no sou l'usuari root, com és que si intenteu executar serv_iter passant-licom a paràmetre un port inferior al 1024 sempre es mostra un missatge d'error?


Us facilitem el codi d'un programa client (client.c) corresponent al servidor anterior. Elclient està parametrizat amb el nom de la màquina on s'executa el servidor, el nombre de porti dos caràcters (que defineixen el rang de caràcters que espera el servidor). Per exemple, siel servidor està associat al port 15000 de la vostra màquina,client localhost 15000 a k demanaria al servidor ubicat al port 15000 de la màquinalocalhost (la mateixa màquina on s'executa el client) les línies de /etc/passwd quecomencen per algun caràcter comprès entre a i k.

9.2.3 Disseny de servidors TCP

Hi ha diversos dissenys possibles pels servidors TCP, però les dues alternatives bàsiquessón:

Iteratiu (seqüencial): ha de finalitzar el tractament d'un client per poder començar aatendre'n un altre.

Concurrent: pot començar a tractar un client encara que no hagi finalitzat eltractament d'un client anterior. Típicament, crea un procés fill per atendre a cadaclient. Com que el procés fill hereda tots els canals d’entrada/sortida que teniaoberts el pare, el fill podrà accedir al canal que permet comunicar amb el procésclient.

serv_conc.c és la versió concurrent del servidor serv_iter.c. Tots dos programes tenenla mateixa interfície.

Per practicar

9.4 Invoqueu el programa client des d'una altra finestra (d’aquesta forma no esbarrejaran les dades impreses per client i servidor). Com és que ara el servidorimprimeix la línia de debug posterior a la crida al sistema accept?

9.5 Invoqueu el programa client i el servidor passant com a paràmetre el port 22. Ésnormal el comportament observat? Si no ho és, a què es deu aquestcomportament?

9.6 Si teniu la possibilitat, executeu el client i el servidor a màquines diferents queestiguin connectades a la xarxa. Serà necessari que conegueu el nom de lamàquina on s’executa el servidor. Comproveu que s'estableix la comunicacióentre els dos processos.

9.7 Comenteu la línia Close(sock_conn) del programa serv_iter.c. Compileui executeu aquesta nova versió del servidor i executeu un client sobre aquestnou servidor. A què es degut el comportament observat?


9.3 EXERCICI DE PROGRAMACIÓ: SERVIDOR WEB

Heu d'implementar un servidor web que segueixi el protocol de transferència http. Aquestservidor ha de poder servir pàgines web a qualsevol navegador estàndard.

9.3.1 Servidor iteratiu

Implementeu un servidor web que es comuniqui amb els clients mitjançant sockets.

Com a procés client podeu utilitzar qualsevol navegador web estàndard: mozilla,netscape, explorer, lynx... La sintaxi de la URL que permet comunicar unclient amb un servidor web que esperi les peticions per un port que no siguil'estàndar (80) és http://nom_maquina:num_port/nom_pàgina

El servidor ha de llegir la petició del client i analitzar-la. Per fer aquesta tasca usfacilitem la rutina analisi_http. Consulteu la seva interfície a rutines.c i .h.

El servidor contestarà amb una capçalera http (que podeu generar amb la rutinasend_http_header de rutines.c) i, tot seguit, haurà d’enviar el contingut delfitxer corresponent a la pàgina demanada.

Si el client demana accedir a una pàgina no existent o a la que el servidor no téaccés, el servidor hauria de respondre generant el codi d'error http corresponent(rutina send_error de rutines.c).

És aconsellable que el servidor utilitzi la rutina debug de la biblioteca libuso permostrar les accions que va realitzant i els wrappers de la biblioteca libuso perfacilitar el tractament d'errors a les crides al sistema.

Us facilitem l'esquelet del programa (web_iter.c) i fitxers .html per fer proves.

Les pagines .html que serveix el servidor poden emmagatzemar-se al directori detreball del procés servidor.

Per practicar

9.8 Compileu i executeu server_conc. Executeu diversos clients sobre aquestservidor i executeu un ps que mostri tots els vostres processos a la màquina ons'executa el servidor. Què observeu? Com es podria solucionar?


9.3.2 Servidor amb suport a pàgines dinàmiques

Modifiqueu el servidor de forma que si el client especifica una URL on es referenciï un fitxerdel subdirectori cgi-bin, el servidor interpreti que aquest fitxer és un executable, el faciexecutar, i faci arribar al procés client la sortida estàndard del procés.

Les rutines que us hem facilitat per analitzar les peticions http ja indiquen si laURL correspon a una pàgina estàtica o a una pàgina dinàmica.

Haureu d'utilitzar la crida dup2 per tal de redireccionar la sortida estàndard delprocés que executi l'executable cap al socket.

Per fer proves us facilitem data.c, que crea dinàmicament la capçalera http i lapàgina html que indiquen el temps pendent fins les 6:00 del 29 de novembre de2009.

Haureu d'afegir al fitxer Makefile la regla necessària per compilar el programa.

9.3.3 Servidor concurrent (sense límit a la concurrència)

Implementeu el servidor fent que pugui tractar diversos clients de forma concurrent.

9.3.4 Servidor concurrent (limitant la concurrència)

Modifiqueu el servidor concurrent de forma que limiti el grau de concurrència fins a un màximde N processos, on N ha de ser un paràmetre del servidor.

Per fer proves és aconsellable que introduïu algun tipus de retard al generar lesrespostes (per exemple, utilitzant la rutina sleep). D'aquesta manera, podreuprovar que realment es limita el nombre de clients atesos.

9.3.5 Servidor amb pas de paràmetres a pàgines dinàmiques

Si el client vol passar paràmetres a l'executable que genera les pàgines dinàmiques, hauràd'afegir a la URL el caràcter ? i els paràmetres; exemple:http://nom_maquina:port/cgi-bin/prog?par1+par2El servidor utilitzarà la variable d'entorn QUERY_STRING per fer arribar els paràmetres alprocés que executi el programa. Les variables d'entorn d'un procés són accessibles amb lesrutines setenv i getenv, i les crides exec no modifiquen el seu valor.

Consulteu la pàgina de manual de la rutina setenv (comanda man).

Les rutines que us hem facilitat per analitzar les peticions http ja retornen l'stringpassat com a paràmetre a l'executable que genera les pàgines dinàmiques.

Podeu parametritzar el programa data.c amb una data. En aquest cas, data.ccacula el temps pendent fins la data indicada. Per exemple:


http://nom_maquina:port/cgi-bin/data?12+30+0+5+6+2015 hauria demostrar el temps pendent fins les 12:30:00 del 5/6/2015.

9.4 COMANDES

lsofCom es va veure al capítol anterior, entre altres coses, mostra informació sobre els canalsoberts pels processos. Si observeu un canal associat a un socket, mostra el nombre de porton s'estan esperant connexions TCP o les connexions TCP establertes.

hostnameMostra el nom de la màquina.

ifconfigEntre d’altres dades, mostra la direcció IP de la màquina (típicament, cal consultar el campinet addr de la interfície eth0).

hostSi teniu connexió a la xarxa, donat el nom d'una màquina, indica la seva adreça IP. Donadauna adreça IP, indica el nom de màquina corresponent.


Al manual del sistema podeu obtenir informació sobre les crides al sistemarelacionades amb sockets UDP (les bàsiques són socket, bind, sendto irecvfrom).

El llibre UNIX Network Programming, Volume 1, Second Edition: Networking APIs:Sockets and XTI de W. Richard Stevens editat per l’editorial Prentice Hall al 1998us permetrà aprofundir en els sockets.

Per practicar

9.9 Escriviu un shellscript que mostri, per a cadascun dels vostres processos, el seupid i el nombre de connexions TCP establertes.

9.10 Escriviu un shellscript que, cada N segons, comprovi si algun dels vostresprocessos ha establert una connexió amb una màquina determinada. N i el nomde la màquina seràn paràmetres del shellscript.

9.11 Escriviu un shellscript tal que, donats els tres primers bytes d'una direcció IP(per exemple, 147.83.20), indiqui el nom de les 256 màquines amb direccions IPcompreses entre 147.83.20.0 i 147.83.20.255.

10 Memòria 85

10 Memòria

Els objectius d’aquest capítol son: a) conèixer les comandes que ens mostren informaciósobre l’ús de memòria al sistema, b) familiaritzar-se amb les crides al sistema Unixrelacionades amb la memòria dinàmica i c) saber utilitzar les eines que ofereix el sistemaoperatiu per corregir errors relacionats amb l’accés a memòria. A la pàgina web de suporttrobareu els fitxers18 referenciats al document.


10.1.1 Comandes

topEntre d'altres coses, mostra informació respecte a la memòria física de la màquina (quantitattotal instal·lada, quantitat en ús, quantitat lliure) i respecte a l'àrea de swap. També indica lamemòria ocupada per diferents buffers del sistema.

A més, per a cada procés, ens mostra VIRT o SIZE (mida de l’espai lògic del procés, és a dir,quantitat total de memòria ocupada pel procés considerant la memòria física i l'àrea de swap),RSS (resident size, quantitat de memòria física que actualment està ocupant el procés) i %MEM(el percentatge d'ús de memòria física). Prement la lletra f podeu fer que top mostri mésinformació relativa a l’ocupació de memòria per part dels processos. Prement F, top ordenaels processos per la columna que indiqueu.

psPermet obtenir informació sobre l’ocupació de memòria dels processos. Per exemple, amb elparàmetre u mostra %MEM, VSZ i RSS.

freeMostra informació sobre l'ocupació de memòria física i la memòria virtual.


/proc/meminfo ens mostra diferents dades estadístiques sobre l'ocupació de memòria. Aldirectori propi de cada procés, el fitxer maps indica els rangs de direccions associades a lesdiferents biblioteques dinàmiques muntades pel procés.

18.Alguns programes proporcionats són incorrectes. El text del capítol assumeix que executeu aquestsprogrames incorrectes sobre la distribució Einam. A d’altres versions d’Unix els programes també sónincorrectes però poden tenir comportaments diferents.


10.2 ACCESSOS INVÀLIDS A MEMÒRIA

Tot procés té assignat un espai lògic, és a dir, un conjunt d’adreces de memòria que potutilitzar. L’espai lògic es divideix en tres regions: codi, dades i pila. La mida i el contingut inicialde les regions està determinada pel fitxer executable corresponent al procés.

Un tipus d’accés invàlid es produeix quan un procés intenta accedir a una direcció dememòria que no pertany al seu espai lògic. Un altre tipus d’accés invàlid es produeix quan unprocés intenta fer una operació no permesa sobre una direcció de memòria del seu espailògic; per exemple, modificar una direcció que sigui només de lectura. Tots els accessosinvàlids són deguts a errors en el codi del programa i cal corregir-los.

Tots els accessos invàlids són detectats pel sistema operatiu19, però la detecció i eltractament dependrà del mode d’execució que estigui utilitzant el procés en aquell moment.

10.2.1 Des de mode d’execució sistema

Si el procés es troba en mode sistema (està executant el codi d’atenció a alguna crida alsistema) el sistema operatiu no permetrà que realitzi un accés invàlid. Per tant, el codi delsistema operatiu comprova, abans de realitzar efectivament qualsevol crida al sistema, que elrang d’adreces que seran llegides/modificades per la crida al sistema siguin vàlides pelprocés. Si no ho són, la crida al sistema no es realitzarà, retornarà error (resultat -1) amb elcodi d’error errno EFAULT; el procés continuarà la seva execució a partir de la instrucciósegüent a la crida al sistema. Per tant, és molt important que després de tota crida al sistemaes comprovi que aquesta hagi pogut executar-se correctament.

19.Algún accés invàlid pot no ser detectat pel sistema operatiu perquè la memòria està dividida enpàgines (de forma anàloga a la divisió del disc en blocs) i les pàgines constitueixen la unitatd’assignació de memòria.

Per practicar

10.1 Escriviu un shellscript que mostri els N processos que tinguin un espai lògic mésgran. N serà un paràmetre del shellscript.

10.2 Escriviu un shellscript que cada N segons comprovi si la quantitat d'àrea deswap lliure és inferior a M Kilobytes. Si ho és, ha d'escriure un missatgeindicant-ho. N i M seran paràmetres del shellscript.

Per practicar

10.3 El programa mem01.c intenta escriure pel canal 1 el byte emmmagatzemat a ladirecció de memòria 0. Compileu-lo (make mem01) i executeu-lo. Què estàpassant?

10 Memòria 87

10.2.2 Des de mode d’execució usuari

Quan un procés es troba en mode usuari, un hardware especialitat comprova la validesa detots accessos a memòria. Aquest hardware, l’MMU (Memory Management Unit), examinatotes les referències a memòria generades pel procés i, en cas de detectar-ne una d’invàlida,genera una excepció. La rutina del sistema operatiu associada a l’excepció farà avortar elprocés. Finalment, si el procés erroni ha estat creat des del shell, aquest ens mostrarà unmissatge d'error similar a Segmentation Fault (violació de segment o error de segmentació).

Per poder obtenir més informació respecte al punt on s’ha produït l’accés invàlid, podeuindicar al sistema operatiu que generi un fitxer amb l’estat del procés (contingut de memòria,registres del processador,...) en el moment de produir-se l’excepció. Aquest fitxer s’anomenacore (a algunes versions de Linux s’afegeix al nom l’identificador del procés).

Per omissió, aquest fitxer no es genera. Perquè es generi cal executar la comandaulimit -c unlimited (a d’altres intèrprets de comandes pot fer-se amb la comandaunlimit core). A partir d’ara, quan es produeixi un Segmentation Fault també és produiràun Core dumped, és a dir, es crearà el fitxer core amb tota aquesta informació20.

10.2.3 Anàlisi de fitxers core amb el debugger gdb

Els fitxers core poden ser analitzats per molts debuggers. Aquesta anàlisi us permetrà saberen quina part del codi s’ha detectat l'accés invàlid així com quin era el contingut de lesvariables i la memòria. Això us pot simplificar la tasca de buscar l'error al codi font.

Com a debugger podeu utilitzar el gdb (a algunes distribucions Linux també existeixeninterfícies gràfiques d’aquest debugger com ara ddd). Una forma habitual d'invocar-lo éspassant-li com a paràmetres el nom de l'executable i el nom del fitxer core generat.

Perquè el debugger us pugui mostrar informació en alt nivell dels programes és necessaricompilar-los amb l'opció -g (per guardar a l'executable informació de debug).

20.Com que els fitxers core poden ser molt grans, és aconsellable activar la seva generació únicamentquan us interessi que el sistema operatiu els generi. També és aconsellable esborrar el fitxer core uncop examinat i desactivar l'opció en acabar (comanda ulimit -c 0 o limit core 0).

Per practicar

10.4 El programa mem02.c intenta escriure un caràcter a la direcció de memòria 0.Compileu-lo i executeu-lo. Què ha passat? Qui escriu el missatge d'error?

10.5 Habiliteu la generació de fitxers core i torneu a executar mem02. Comproveuque el missatge d'error és diferent a l'obtingut al cas anterior i que s'ha generatun fitxer core.

10.6 Com creieu que el shell sap que el procés ha mort per un Segmentation Fault?


10.3 MODIFICACIÓ DINÀMICA DE L’ESPAI LÒGIC

El fitxer executable determina la mida i contingut inicial de l’espai lògic del procés. De totesformes, dinàmicament (és a dir, al llarg de la vida del procés), es pot modificar tant elcontingut com la mida d’aquestes regions. Cada regió té un mecanisme diferent demodificació de la seva mida.

10.3.1 Regió de codi

Per defecte, la regió de codi és inalterable: no podeu ni modificar el seu contingut ni modificarla seva mida.

10.3.2 Regió de pila

Si programeu en un llenguatge d’alt nivell, la regió de pila es consulta i es modifica de formatransparent al programador. El compilador genera el codi que hi emmagatzema els blocsd’activació de totes les rutines actives (adreces de retorn, variables locals ...).

La mida inicial assignada a la pila pot ser massa petita per les necessitats d’un procés. Si unprocés fa una operació de pila més enllà de la mida inicial assignada, l’MMU (MemoryManagement Unit) generarà una excepció. La rutina del sistema operatiu que atén aquestaexcepció s’encarregarà d’ampliar l’espai associat a la regió de pila del procés. A continuació,el sistema operatiu permetrà que el procés repeteixi l’operació sobre la pila i que continui laseva execució. Per tant, el creixement de la regió de pila es realitza de forma transparent al

Per practicar

10.7 El programa mem03.c conté un error que fa que es produeixi un SegmentationFault. Compileu-lo i executeu-lo permetent que es generi el fitxer core. Acontinuació invoqueu el debugger (gdb mem03 nom_core); normalment, eldebugger us mostrarà la sentència de codi on s'ha produït l'accés invàlid. Eldebugger us permet examinar el contingut de les variables amb la comandaprint (per exemple, print i, print j, print n) així com les adreces dememòria assignades a les variables (print &n[0], print &i). Altrescomandes útils són list, bt, up, down, help... On és l'error del programa? Per què creieu que no es produeix abans elSegmentation Fault?

10.8 El programa mem04.c conté errors que provoquen Segmentation Faults.Analitzant els cores, corregiu justificadament tots els errors del programa (usresultaran útils comandes del debugger com bt, up i down; estudieu el seufuncionament).

10.9 Invoqueu la comanda find perquè esborri tots els fiters core de la vostra zonade disc.

10 Memòria 89

programador. De totes formes, la mida de la regió de pila no pot crèixer indefinidament, elsistema operatiu limita la mida que pot arribar a tenir la pila de tot procés.

10.3.3 Regió de dades

L’accés a la regió de dades és responsabilitat del programador. Si un procés necessitaampliar la mida de la regió de dades, el procés ha de demanar-ho al sistema operatiumitjançant una crida al sistema.

Les crides al sistema Unix relacionades amb la modificació dinàmica de la regió de dadesd’un procés són brk i sbrk. Com que la interfície d’aquestes crides no resulta gaire còmoda,s’aconsella utilitzar les rutines de biblioteca malloc i free.

malloc està parametrizada amb el nombre de bytes consecutius amb els quenecessiteu augmentar l’espai lògic. La rutina retorna una direcció de memòria. Si ladirecció retornada és NULL, indica que no s’ha pogut augmentar l’espai lògic;altrament, l’espai lògic haurà augmentat el nombre de bytes demanats i la direccióretornada correspondrà amb la del primer byte assignat (la resta es troben aposicions consecutives).

free permet lliberar memòria. Està parametrizada amb una direcció de memòria(que heu hagut d’obtenir prèviament amb un malloc); la rutina allibera tota lamemòria assignada al malloc corresponent.

Dues observacions finals: a) quan un procés mor, el sistema operatiu allibera tota la memòriaque tenia assignada; b) a més de la limitació física insalvable (mida de la memòria física mésla de l’àrea de swap), el sistema operatiu pot limitar la mida màxima de la regió de dades d’unprocés.


10.4 ACCESSOS ERRONIS A MEMÒRIA

Tot i que el sistema operatiu no ens indiqui que un procés ha fet un accés invàlid a memòria,això no vol dir que els accessos a memòria que estigui fent el procés siguin "correctes" (desdel punt de vista de les intencions del programador).

Un error de programació pot fer que un accés a memòria estigui fent referència a una posicióque no és la desitjada però que també pertany a l'espai lògic del procés. Aquest tipus d'errorno és detectable per la MMU i pot provocar errors en el funcionament del programa ja que elprocés pot estar fent malbé ("matxacant") el valor d’alguna altra variable.

Els errors relacionats amb la utilització de la memòria poden ser molt complicats de detectarja que, en alguns casos, aparentment no modifiquen el comportament del programa i, end’altres, es manifesten moltes sentències més enllà de la sentència on s’origina l’error. Detotes formes, una gran part dels comportaments "inexplicables" dels programes acostumen aestar relacionats amb accessos incorrectes a memòria. Aquest tipus d'errors poden seraprofitats per usuaris malintencionats per prendre control de la vostra màquina, amb elsproblemes de seguretat que això pot comportar.

Per practicar

10.10Compileu i executeu el programa mem10.c. Des d’una altra finestra, comproveucom augmenta la mida del seu espai lògic (modifiqueu el valor de la constantESPERA si necessiteu ajustar el temps d’execució del programa). A què ésdegut aquest augment de la mida de l’espai lògic? Per què el sistema operatiuacaba fent avortar aquest procés?

10.11 El programa mem11.c espera un paràmetre de tipus numèric com a paràmetre.El programa crea una taula amb tants nombres primers com l’usuari hagi indicat.Per què apareix l’operador sizeof a l’expresió que calcula el nombre decaràcters passats com a paràmetre a malloc?

10.12El programa mem12.c construeix dinàmicament una estructura de dades querepresenta el contingut d’un fitxer de text. L’estructura de dades creada és unallista encadenada amb un element per cada línia del fitxer; cadascun d’aquestselements conté un camp amb la mida de la línia, un altre amb el contingut de lalínia i un altre que apunta a l’element que representa la següent línia.a) Quants mallocs es fan per a cada línia? Quina funció tenen?b) Escriviu una rutina que recorri l’estructura de dades i indiqui quina és la líniamés llarga del fitxer i quina mida té.b) Escriviu una rutina que admeti com a paràmetre un nombre enter (querepresentarà un nombre de línia). La rutina ha d’insertar una línia en blanc(només contindrà un salt de línia) entre la línia indicada i la següent línia delfitxer.

10 Memòria 91


Al manual del sistema podeu obtenir més informació respecte a les rutines debiblioteca malloc i free, així com de brk i sbrk.

Podeu cercar "stack overflow" a la xarxa. Trobareu explicacions més detalladesd’aquest problema així com més exemples de programes problemàtics.

Per practicar

10.13mem20.c és un programa que mostra els caràcters situats a posicions parellsdels fitxers passats com a paràmetre. A més de dues simplificacions alproblema, el programa presenta un error relacionat amb l'ús de la memòria.Indiqueu on és aquest error i com arreglar-lo.

10.14mem21.c és un programa que llegeix un password pel teclat, el compara ambun especificat al codi font (USO) i indica si són iguals. Estudieu el seu codi font.Compileu-lo i executeu-lo introduint passwords qualsevol, el password USO i unde 16 caràcters on el setzè caràcter sigui el caràcter T. A què es degut elcomportament observat?

10.15El programa mem22.c intenta escriure un mateix string des de la rutina main ides d’una altra rutina. Si el compileu i l’executeu veureu que els strings escritsno són idèntics. A què es degut aquest comportament? Com el solucionaríeu?

10.16(molt difícil) El programa mem23.c té un comportament peculiar. Intenteuexplicar a què es degut.

10.17(molt difícil) El programa mem24.c té un comportament peculiar. Intenteuexplicar a què es degut.

enric morancho - studies.ac.upc.edu

Documents