# [TIP][PORTAGE] Stoppare e riprendere un emerge senza dolore!

## FonderiaDigitale

Salve. So gia' che molti mi baceranno il deretano per questo come me lo sono io baciato da solo (ebbene si  :Razz: )

EDIT: c'e' chi l'aveva fatto presente prima di me, precisamente solka in questo post  :Smile: 

Ho scoperto un modo efficace e indolore per stoppare un emerge in corso e riprenderlo senza perdere la compilazione effettuata (cosa MOOLTO utile in caso di macchine lente).

La cosa sorprendente e' quanto possa essere semplice la soluzione di uno dei piu angosciosi dilemmi che attanaglia qualsiasi utente gentoo.

In pratica, dopo che avrete dato

```
emerge pacchetto
```

basta premere

```
CTRL Z
```

per 'ibernare' il processo.

A questo punto potrete andare a farvi i cavoli vostri, e poi riprendere l'emerge dove lo avete lasciato semplicemente digitando

```
fg
```

Provare per credere.

Funziona con qualsiasi emerge, e in generale con qualsiasi processo (almeno dovrebbe) solo nella stessa sessione di terminale.

Questo tip e' beerware (nel senso che a chi e' servito, puo' offrirmi una birra  :Razz:  :Razz: )

----------

## FonderiaDigitale

ad esempio, potrebbe servire  a chi durante l'estate, fa surriscaldare troppo il suo pc, dandogli un attimo di fiato. ma e' solo un esempio tra tanti.

----------

## emix

Ottimo... complimenti! 

Lo userò siuramente per gli emerge lunghissimi  :Wink: 

----------

## Danilo

 *FonderiaDigitale wrote:*   

> 
> 
> Funziona con qualsiasi emerge, e in generale con qualsiasi processo (almeno dovrebbe) solo nella stessa sessione di terminale.
> 
> 

 

Non lo avevo segnalato perche' mi sembrava ovvio...  

Comunque confermo funge su ogni processo (almeno finora NESSUN processo NON si e' ibernato).

E' una features dei sistemi unix(-like).

ctrl-z non fa altro che freezare il processo in attesa di altre istruzioni:

fg (foreground) che hai segnalato continua il processo.

bg (background) lo manda in background

Io lo uso sopratutto se dopo aver dato un emerge e mi che dura troppo e voglio dare un halt alla macchina dopo la compilazione stessa.

```

fg && halt

```

Ovvio non funge se ho dato un 

```

qualcosa &

```

in quel caso devo prima portare il processo in foreground (fg) e poi sospenderlo...

----------

## xchris

tip semplice, alla luce dei fatti ovvio...

ma geniale  :Very Happy: 

perche' non ci abbiamo pensato prima?  :Very Happy: 

le migliori idee sono quelle + semplici!

compliments  :Very Happy: 

ciauz

P.S.: maratona dello script?maratona dei tip?  :Very Happy: 

----------

## codadilupo

l'aveva già fatto presente solka, ma ricordarlo non fa male  :Wink: 

Coda

----------

## FonderiaDigitale

 *codadilupo wrote:*   

> l'aveva già fatto presente solka

 

Arg! m'era sfuggito....... lo cito subito

----------

## n3m0

 *Danilo wrote:*   

> 
> 
> ctrl-z non fa altro che freezare il processo in attesa di altre istruzioni:
> 
> 

 

a voler essere pignoli, invia un segnale SIGSTOP al processo in foreground.

```

# kill -l

```

per l'elenco dei segnali che si possono inviare ad un processo.

Un processo che riceve SIGSTOP passa dallo stato di running a quello di suspended (e vi rimane fino a che non riceve un segnale di risveglio, es: SIGCONT); il suo contesto viene salvato per poi essere ricaricato nel momento in cui il processo ritorna nello stato di running.

Quindi il processo riprenderà l'esecuzione dall'istruzione "logicamente successiva" all'ultima eseguita prima del suspend.

Quando si esegue 

```

# bg

```

si manda in background-running il primo job della shell.

Quando si esegue 

```

# fg

```

si manda in foreground-running il primo job della shell.

Con

```

# man bg fg

```

scoprirete che questi comandi accettano come parametro opzionale l'id di un job.

Per avere un elenco dei job di una data istanza del processo di shell, digitare

```

# jobs

```

 *Danilo wrote:*   

> 
> 
> Ovvio non funge se ho dato un 
> 
> ```
> ...

 

Poiche' il processo è già running in background, e CTRL-Z invia SIGSTOP al processo in foreground-running della shell.

 *Danilo wrote:*   

> 
> 
> in quel caso devo prima portare il processo in foreground (fg) e poi sospenderlo...

 

Oppure 

```

# kill -STOP <qualcosa-pid>

```

Bye bye.

----------

## RenfildDust

Ma cosi' non si creano dei files compilati a meta'?

Non potrebbe dare problemi?

E nel caso in cui chiudiamo la shell o riavviamo la macchina, non funzionerebbe..

Comunque e' una buona soluzione nella sua semplicita'..

----------

## bld

hmm ho visto un tip su tips and tricks molto molto carino...

praticamente emergi usando screen e la sua funzione script  :Razz: 

https://forums.gentoo.org/viewtopic.php?t=14562

----------

## n3m0

 *RenfildDust wrote:*   

> Ma cosi' non si creano dei files compilati a meta'?
> 
> 

 

No.

 *RenfildDust wrote:*   

> 
> 
> Non potrebbe dare problemi?
> 
> 

 

No.

 *RenfildDust wrote:*   

> 
> 
> E nel caso in cui chiudiamo la shell o riavviamo la macchina, non funzionerebbe..
> 
> 

 

Questo si.

----------

## koma

.... lo usavo da un paio d'anni sta cosa ..... pensavo fosse palese

----------

## xchris

sara' forse palese per te..

ma tieni conto che il forum e' consultato anche da persone con minore esperienza.

sebbene molto semplice io ad esempio non ci avevo pensato.

e risulta molto comodo.

ciao

----------

## koma

 :Smile:  io ho cominciato con gentoo quando mi sono registrato al forum il  06/06/03 mettici uno scarto di 6 mesi con red hat e yellowdog e suse . Non sono un Veterano come dice la scritta sono solo fortunato e mi piace leggere un po' di manuali a random  :Smile: 

anzi a dirla tutta una volta ho fatto ctrl+z invece di ctrl+x io chiude sempre le shel con exit e mi ha detto There are unstopped jobs. allora ho fatto jobs --help ed ho capito  :Wink: 

----------

## Danilo

 *xchris wrote:*   

> 
> 
> sebbene molto semplice io ad esempio non ci avevo pensato.
> 
> e risulta molto comodo.
> ...

 

Lo stesso successe a me prima che fosse sollevato nell'altro thread.

Eppure sono anni che gioco con i ctrl-z, fg ecc...

----------

## Benve

sarebbe bello poter congelare un processo e salvarlo su disco per poi riprenderlo dopo un reboot o su un'altra macchina

Credo che l'unico che lo faccia sia DragonFly BSD

----------

## n3m0

 *Benve wrote:*   

> sarebbe bello poter congelare un processo e salvarlo su disco per poi riprenderlo

 

Tale "tecnica" si chiama checkpointing

Per Linux conosco questo: 

http://www.unicc.kiev.ua/tasks/chpx_eng.html

----------

## FonderiaDigitale

come su segnalato, per congelare processi e rieseguirli in un altro terminale, usate screen

----------

## lopio

Qualcuno dice semplice (perche' lo sapeva gia' forse) ma per me proprio ottimo!!!

grazie   :Laughing: 

----------

## -YoShi-

Up per il Tip  :Smile:  adesso potro stoppare la maratona di 2 giorni di compilazione che ogni volta mi fa openoffice...Così la cpu riprende fiato e si raffredda un filino

----------

## flocchini

Io sono cretino  :Smile: 

Situazione ricorrente: lancio emerge via ssh da una macchina remota ma ... azz! Non ho lanciato prima screen. Stoppo, lancio screen e riemergio, detachando poi qdo devo spegnere la macchina locale con il sistema remoto che continua il suo emerge. Come potrei fare x evitare tutto cio'? posso fare in modo di detachare l'emerge gia' in corso (lo so che no detacho di fatto emerge, pero' e' + esplicativo  :Smile:   )

----------

## Cazzantonio

No è che magari funziona anche un 

```
nohup emerge -xxx yyyyy
```

 ??

in questo modo posso anche disconnettere l'utente e la compilazione va in background

ora provo!

----------

## xchris

per fare questo basta screen

ciao

----------

## koma

 *Cazzantonio wrote:*   

> No è che magari funziona anche un 
> 
> ```
> nohup emerge -xxx yyyyy
> ```
> ...

 Non solo con questo metodo avrai l'output dell'intera compilazione su nohup.out nella cartella dove hai lanciato l'emerge. e potravi così vedere ogni passaggio e errore. e controllare se l'emerge è andato a buon fine con un semplice tail nohup.out

----------

## Benve

 *n3m0 wrote:*   

>  *Benve wrote:*   sarebbe bello poter congelare un processo e salvarlo su disco per poi riprenderlo 
> 
> Tale "tecnica" si chiama checkpointing
> 
> Per Linux conosco questo: 
> ...

 

Bello, appena ho di nuovo una macchina linux ci guardo meglio

----------

## Danilo

 *Cazzantonio wrote:*   

> No è che magari funziona anche un 
> 
> ```
> nohup emerge -xxx yyyyy
> ```
> ...

 

Come hai fatto tu non va in background:

cosi' si 

```
nohup emerge -xxx yyyyy &
```

la & finale lo manda in bg

----------

## Cazzantonio

Se vogliamo essere precisi fino in fondo allora va bene anche un "ctrl+z" seguita da un "bg"

----------

## marco86

```

ctrl+z

fg && halt

```

 *Danilo wrote:*   

> 
> 
> Io lo uso sopratutto se dopo aver dato un emerge e mi che dura troppo e voglio dare un halt alla macchina dopo la compilazione stessa.

 

Spettacolo, l'ho appena provato mentre sto emergiando KDE, e io gia che pensavo di lasciare il pc acceso fino a lunedì quando tornavo!

 *koma wrote:*   

> .... lo usavo da un paio d'anni sta cosa ..... pensavo fosse palese

 

 :Twisted Evil: 

sarà palese x qualcuno, x me è una novità, come quasi tutto a dire la verità  :Embarassed:  , ma lo trovo molto utile e comodo!

 :Laughing: 

----------

## maiosyet

Ma c'e' qualche differenza se lo stoppo con ctrl-C e poi faccio emerge --resume?   :Question: 

----------

## fedeliallalinea

 *maiosyet wrote:*   

> Ma c'e' qualche differenza se lo stoppo con ctrl-C e poi faccio emerge --resume?  

 

Che se non sbaglio se dai ctrl+C a meta' della compilazione di kdebase quando ridarai emerge ricomincia a ricompilare dall'inizio e non da dove eri arrivato.

----------

## marco86

 *maiosyet wrote:*   

> Ma c'e' qualche differenza se lo stoppo con ctrl-C e poi faccio emerge --resume?  

 

si, perchè con ctrl-c, da quello che avevo letto su una guida in inglese, non salva lo stato di avanzamento nella tabella dei descrittori, cioè, lo schedulatore dei processi lo fa, ma merge --resume non riesce a capire le tutte le info, tra cui il punto in cui lo fermi! almeno, queso era quello che avevo capito con il mio scarso inglese....

----------

## n3m0

 *maiosyet wrote:*   

> Ma c'e' qualche differenza se lo stoppo con ctrl-C e poi faccio emerge --resume?  

 

La differenza e' sostanziale.

Con CTRL-Z tu sospendi il processo, ma le informazioni su quest'ultimo sono ancora tutte in memoria e quindi il processo puo' essere ripreso in qualsiasi momento

Con CTRL-C tu termini il processo, quindi il kernel rilascia tutte le strutture dati che erano state allocate per gestire il processo.

Quando fai emerge --resume emerge non fa altro che "ricordarsi" quali erano i pacchetti lasciati in sospeso dall'ultima terminazione anomala, e farne il merge...

----------

## Mr.Evolution

Nessuno sa come fare per:

1 stoppare

2 spegnere

3 attendere il tempo che voglio

4 accendere

5 riprendere il lavoro precentemente iniziato????

Mi sarebbe utilissimo..........

Ho visto che emrge ho una funzione di --resume ma non sembra funzionare a dovere (o io non la so usare)

----------

## FonderiaDigitale

 *Mr.Evolution wrote:*   

> Nessuno sa come fare per:
> 
> 1 stoppare
> 
> 2 spegnere
> ...

 

una parola: screen

cerca nei post precedenti e nel forum documentazione per esempi.

----------

## fedeliallalinea

@Mr.Evolution: --resume funziona con l'opzione -e. Per fare quello che vuoi tu penso che ccache faccia al caso tuo

----------

## FonderiaDigitale

si ma --resume e' provato che non funziona spesso e volentieri e solo alla terminazione di ogni singolo merge

----------

## matttions

 *fedeliallalinea wrote:*   

> 
> 
> una parola: screen
> 
> cerca nei post precedenti e nel forum documentazione per esempi.

 

scusa ma ho cercato sul forum, ed non ho trovato nulla.

inoltre ho guardato in portage e c'è un programma che si chiama screen.

Ora non mi sembra quello che sto cercando oppure sì ed o letto male la doc?

quindi se potete darmi un link per questa applicazione mi risolvereste un sacco di problemi riguardo alla scelta di quando far partire la compilazione.

thanks.

 :Smile: 

----------

## andr0z

Per STOPPARE/SPEGNERE/(farsi 50 Km per il lavoro)/RIACCENDERE/RIPRENDERE la compilazione... Sicuramente lo conoscevate gia'... tratto da una (non ricordo quale) delle ultime GWN...:

 *Quote:*   

> 
> 
> From: Marcos García <marcos.gm <at> gmail.com>
> 
> Subject: Re: How to restart an emerge.
> ...

 

CIAOLast edited by andr0z on Sat Nov 20, 2004 1:17 pm; edited 1 time in total

----------

## matttions

bon ...

Tenterò  :Very Happy: 

thanks  :Wink: 

----------

## fbcyborg

E' molto utile questo trucchetto, devo dire... 

Vorrei sapere se esiste un meccanismo analogo che mi permette di spegnere il pc tranquillamente e riprendere la compilazione il giorno dopo, dallo stesso punto di partenza...

faccio ctrl +c e domani do di nuovo lo stesso comando???

x esempio adesso sto facendo emerge -uDN world.

----------

## andr0z

Yep, lo stesso comando.

Si potrebbe dire..  Per STOPPARE/SPEGNERE/(farsi 5000 Km di volo per lavoro - dormire in albergo - visitare la città - recarsi all'appuntamento di lavoro - tornare in albergo e...)/RIACCENDERE/RIPRENDERE la compilazione.  ..puoi usare questo comando.

CIAUZ  :Shocked: 

----------

## fbcyborg

ok, cmq a sto punto farei emerge --resume

----------

## bandreabis

Una cosa non ho capito: se stoppo emerge riavvio il PC e poi do emerge --resume... che succede?

Riparte emerge dall'ultimo pacchetto che ha terminato di emergere?

Mi serve saperlo perchè stanotte non potro assolutamente tenere il PC acceso, se voglio far dormire mio padre   :Rolling Eyes: 

Grazie

Andrea

----------

## fbcyborg

se interrompi emerge con ctrl +c e poi domani dai un emerge --resume, ti riprende dallo stesso punto in cui era rimasto. Almeno a me ha funzionato!

----------

## Fuzzo

1. emerge qualcosa

2. CTRL+Z

3. hibernate

4. ...

5. fg

Funziona a dovere vero?

----------

## Kernel78

 *Fuzzo wrote:*   

> 1. emerge qualcosa
> 
> 2. CTRL+Z
> 
> 3. hibernate
> ...

 

Se iberni (e l'ibernazione funziona a dovere) allora puoi fare a meno di ctrl+z e successivo fg. Ti limiti a ibernare DURANTE l'emerge e quando riaccendi la macchina l'emerge (come tutto il resto) riparta da dove si era fermato.

Se dubiti del funzionamento di hibernate allora ti conviene la FEATURES="keepwork" ma devi ricordarti di cancellare la directory /var/tmp/portage almeno ogni tanto (e sempre a emerge terminato)

----------

## Fuzzo

Non dubito minimamente di hibernate: ci ho perso così tanto tempo che è al massimo del tuning  :Smile: 

Dare prima CTRL-Z era solo per "sicurezza"  :Smile: 

----------

## bandreabis

Domanda: se voglio iniziare un emerge lungo (openoffice) allora posso usare 

```
FEATURES="keepwork" emerge openoffice
```

 e dopo un CTRL+C domani riprendere con un altro "keepwork"?

Ho capito bene la citazione?

Funziona?

Alla fine do un rm -rf /var/tmp/portage

Cosa significa  *Quote:*   

> Actually it checks if WORKDIR exists when emerging, and if it exists then execs "configure" and "make", but "make" recycle everything you have already compiled. 

 

----------

## Onip

significa che salta la fase di scompattazione. Esegue, però, il configure e il make. Make non ricompila tutto (fa così normalmente, non solo per emerge) ma solo ciò che manca o qualche sorgente che è stato modificato, controllando la data.

----------

## bandreabis

Che piciu!

Ho fatto un papocchio e ho dato l'emerge senza la FEATURE!   :Evil or Very Mad: 

 :Embarassed:   :Embarassed:   :Embarassed: 

----------

## Onip

se dai CTRL+C e poi metti la FEATURE alla ripresa funziona lo stesso

----------

## bandreabis

 *Onip wrote:*   

> se dai CTRL+C e poi metti la FEATURE alla ripresa funziona lo stesso

 

Grazie.

Ho tagliato la testa all'"open-toro" lasciandolo compilare per la notte.

Il bello dei laptop è poterli riporre dove non disturbano.   :Laughing: 

----------

