Forum Ubuntu-it

Il forum della comunità italiana di Ubuntu.
https://forum.ubuntu-it.org/

problema con pulizia cartella home

https://forum.ubuntu-it.org/viewtopic.php?f=33&t=578263

Pagina 1 di 2

problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 18:37
da zampy
ciao a tutti, ho un bel problema con la mia cartella home,
qualche giorno fa ho provato a splittare un file di circa 9 giga, qualcosa è andato storto e invece di splittarlo in parti da 4,1 gb li ha divisi ogni 4,1 kb, ora ho la cartella home che contiene centinaia di migliaia di file da 4,1 kb provocando una lentezza immane nel aprile la cartella stessa per cancellare i file.
ho provato a cancellarli un poco per volta, ma cancellare 350 mila file eliminandone 2000 per volta non è facile,
avete qualche idea per riuscire a eliminarli senza dover aprire la cartella home???
p.s. i file sono tutti nominati "rdr2_layer0.rpf.xxxxxx" dove le x corrispondono al numero della parte

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 18:44
da giulux
prova

Codice: Seleziona tutto

rm rdr2_layer0.rpf*

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 18:52
da zampy
mi dice

Codice: Seleziona tutto

bash: /bin/rm: Elenco degli argomenti troppo lungo

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 18:59
da giulux
mhm, prova a metterli in una cartella che crei e poi

Codice: Seleziona tutto

rm -r NOMECARTELLA

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 19:03
da zampy
eh, io non riesco a selezionarli tutti perchè non riesce a caricarli tutti sul nautilus, non hai un comando per spostare tutti i file rdr2_layer0.rpf* dalla cartella home ad un'altra???

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 19:29
da giulux

Codice: Seleziona tutto

mv rdr2_layer0.rpf* /PERCORSO/DESTINAZIONE
ma temo che se erano tropi per rm lo saranno anche per mv.

prova, comunque.

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 20:00
da zampy
infatti, stesso messaggio di prima

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 20:16
da giulux
Ho esaurito le mie scarse risorse; dovrai aspettare qualcuno più bravo.
Oppure se vuoi ti sposto in programmazione e chiedi lì se qualcuno ti suggerisce qualche comando/script per ottenere lo scopo (nel caso dovresti modificare il titolo per far capire cosa vuoi).

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 20:48
da zampy
ok, va bene grazie comunque ;)

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 20:59
da giulux
Vuoi che ti sposto o vuoi restare qui?

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 21:29
da zampy
se mi sposti mi fai un favore, grazie

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 22:10
da giulux
Fatto.
Cambia titolo.

Re: problema con pulizia cartella home

Inviato: martedì 22 aprile 2014, 23:54
da crap0101
prova così

Codice: Seleziona tutto

xargs -n 100 rm -f < <(ls -1 rdr2_layer0.rpf*)
ma potrebbe dare lo stesso problema, in alternativa

Codice: Seleziona tutto

xargs -n 100 rm -f < <(ls -1 | grep ^rdr2_layer0.rpf)
(volendo anche senza specificare "-n 100")

Re: problema con pulizia cartella home

Inviato: mercoledì 23 aprile 2014, 0:22
da UbuNuovo
Da dentro la directory piena zipilla...

Codice: Seleziona tutto

find . -name 'rdr2_layer0.rpf\.[0-9]*' -type f -delete
Ho trovato che find con -delete dovrebbe essere il più efficiente.
Non so però le eventuali controindicazioni, @Crap cosa ne pensi?

Re: problema con pulizia cartella home

Inviato: mercoledì 23 aprile 2014, 17:04
da Vincenzo1968
Una soluzione in C:

main.c

Codice: Seleziona tutto

#define _FILE_OFFSET_BITS 64

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <time.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>

int matchPrefix(const char * szPrefix, int lenPrefix, const char *szFileName)
{
	int i, lenFileName;
	
	lenFileName = strnlen(szFileName, PATH_MAX);
	
	if ( lenFileName < lenPrefix )
		return 0;
		
	for ( i = 0; i < lenPrefix; i++ )
	{
		if ( szPrefix[i] != szFileName[i] )
			return 0;
	}
	
	return 1;
}

void deleteFiles(char *dirName, const char* szPrefix, int *n)
{
	int removeStatus;
	int lenPrefix;
	DIR *dir = NULL;
	struct dirent entry;
	struct dirent *entryPtr = NULL;
	/* int retval = 0; */
	char pathName[PATH_MAX + 1];
	
	*n = 0;
	
	lenPrefix = strnlen(szPrefix, PATH_MAX);

	dir = opendir(dirName);
	if( dir == NULL )
	{
		printf("Errore nell'apertura della directory '%s': %s\n", dirName, strerror(errno));
		return;
	}	
	
	/* retval = */ readdir_r(dir, &entry, &entryPtr);
	while( entryPtr != NULL )
	{
		struct stat entryInfo;
		
		if( ( strncmp(entry.d_name, ".", PATH_MAX) == 0 ) ||
		    ( strncmp(entry.d_name, "..", PATH_MAX) == 0 ) )
		{
			/* retval = */ readdir_r(dir, &entry, &entryPtr);
		    continue;
		}
 		
		strncpy(pathName, dirName, PATH_MAX);
		strncat(pathName, "/", PATH_MAX);
		strncat(pathName, entry.d_name, PATH_MAX);
		
		if( lstat(pathName, &entryInfo) == 0 )
		{		
			if( S_ISREG(entryInfo.st_mode) )	/* regular file */
			{
				if ( matchPrefix(szPrefix, lenPrefix, entry.d_name) )
				{
					/* printf("Elimino il file %s\n", pathName); */
					removeStatus = remove(pathName);
					if ( removeStatus )
					{
						printf("Errore nella rimozione del file '%s': %s\n", pathName, strerror(errno));
					}
					else
					{
						(*n)++;
					}
				}
			}
		}
		else
		{
			printf("Errore lstat %s: %s\n", pathName, strerror(errno));
		}

		/* retval = */ readdir_r(dir, &entry, &entryPtr);
	}
		
	closedir(dir);		
}

int main(int argc, char **argv)
{
	int n, c;
	
	double TempoInSecondi;
	
	clock_t c_start, c_end;	
		
	if(argc != 3)
	{
		printf("\nUso: %s DirectoryPath PrefixFileName\n\n", argv[0]);
		return -1;
	}
	
	
	printf("\nVerranno rimossi tutti i file con prefisso '%s' dalla directory '%s'\n", argv[2], argv[1]);
	printf("procedere(S/N)? ");
	
	c = fgetc(stdin);
	
	if ( c != 'S' && c != 's' )
		return 0;
	
	c_start = clock();

	deleteFiles(argv[1], argv[2], &n);
	
	c_end = clock();
	
	TempoInSecondi = (double)(c_end - c_start) / CLOCKS_PER_SEC;
		
	printf("\nRimossi %d file.\n", n);
	
	printf("\nTempo impiegato -> %5.5f secondi\n\n", TempoInSecondi);		
		
	return 0;
}
Output:

Codice: Seleziona tutto

[vincenzo]$ gcc -Wall -W -pedantic -O2 main.c -o remfiles
[vincenzo]$ ./remfiles

Uso: ./remfiles DirectoryPath PrefixFileName

[vincenzo]$ ./remfiles ./Temp2 rdr2_layer0.rpf

Verranno rimossi tutti i file con prefisso 'rdr2_layer0.rpf' dalla directory './Temp2'
procedere(S/N)? s

Rimossi 8 file.

Tempo impiegato -> 0.00000 secondi

Re: problema con pulizia cartella home

Inviato: mercoledì 23 aprile 2014, 18:57
da crap0101
UbuNuovo [url=http://forum.ubuntu-it.org/viewtopic.php?p=4568874#p4568874][img]http://forum.ubuntu-it.org/images/icons/icona-cita.gif[/img][/url] ha scritto:Da dentro la directory piena zipilla...

Codice: Seleziona tutto

find . -name 'rdr2_layer0.rpf\.[0-9]*' -type f -delete
Ho trovato che find con -delete dovrebbe essere il più efficiente.
Non so però le eventuali controindicazioni, @Crap cosa ne pensi?
sì, così è pure meglio... mi ero fissato con xargs :-)

Re: problema con pulizia cartella home

Inviato: mercoledì 23 aprile 2014, 22:35
da UbuNuovo
Ho appena fatto qualche prova... il programma in C vince di brutto! Per il resto non ci sono distacchi enormi.
Le prove le ho fatte con 5000 file vuoti; con file grandi probabilmente cambierebbero i risultati!?

Codice: Seleziona tutto

PROVE VELOCITÀ DI CANCELLAZIONE
########################################################
creo i 5000 file

for n in $(seq 1 5000);do touch "rdr2_layer0.rpf.$n"; done


#########################

RM (con 5000 file non si inceppa)

8-) time rm -f rdr2_layer0.rpf* 

real	0m0.298s
user	0m0.132s
sys		0m0.148s

#########################

XARGS RM

8-) time xargs -n 100 rm -f < <(ls -1 | grep ^rdr2_layer0.rpf)

real	0m0.489s
user	0m0.116s
sys	0m0.228s

#########################

FIND con -delete

8-) time find . -name 'rdr2_layer0.rpf\.[0-9]*' -type f -delete

real	0m0.225s
user	0m0.008s
sys	0m0.168s

#####################

REMFILES (c)

8-) ./remfiles dir_piena rdr2_layer0.rpf

Verranno rimossi tutti i file con prefisso 'rdr2_layer0.rpf' dalla directory 'dir_piena'
procedere(S/N)? s

Rimossi 5000 file.

Tempo impiegato -> 0.16000 secondi

Re: problema con pulizia cartella home

Inviato: giovedì 24 aprile 2014, 15:38
da Vincenzo1968
UbuNuovo [url=http://forum.ubuntu-it.org/viewtopic.php?p=4569582#p4569582][img]http://forum.ubuntu-it.org/images/icons/icona-cita.gif[/img][/url] ha scritto: Le prove le ho fatte con 5000 file vuoti; con file grandi probabilmente cambierebbero i risultati!?
Non credo.

Puoi provare con questo programma:

makefiles.c

Codice: Seleziona tutto

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>

int MakeDir(const char *dirName)
{
	DIR *dir = NULL;
	char pathName[PATH_MAX + 1];
	int len;
	int x = 0;
	int y = 0;

	strncpy(pathName, dirName, PATH_MAX);
	
	len = strlen(pathName);
	dir = opendir(pathName);
	if( dir == NULL )
	{
		if ( errno == ENOENT )
		{
			for ( x = len - 1; x >= 0; x-- )
			{
				if ( pathName[x] == '/' )
				{
					pathName[x] = '\0';
					dir = opendir(pathName);
					if ( dir != NULL )
					{
						closedir(dir);
						break;
					}
				}
			}
			
			strncpy(pathName, dirName, PATH_MAX);
			
			for ( y = x + 1; y <= len; y++ )
			{
				if ( pathName[y] == '/' || pathName[y] == '\0' )
				{
					pathName[y] = '\0';
					if ( mkdir(pathName, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0 )
					{
						printf("Errore nella creazione della directory '%s'; %s.\n", pathName, strerror(errno));
						return 0;
					}
					else
					{
						pathName[y] = '/';
					}
				}
			}
			
			return 1;
		}
		else
		{		
			printf("Errore nell'apertura della directory '%s': %s\n", dirName, strerror(errno));
			return 0;
		}		
	}
		
	closedir(dir);
	
	return 1;
}

int MakeFiles(const char *dirName, unsigned int n, unsigned int SizeKb)
{
	FILE *fpOutput;
	char szFileOutput[PATH_MAX + 1];
	unsigned char *pBuffer = NULL;
		
	unsigned int dimFile;
	char szNumFile[256];
	unsigned int k;
	
	dimFile = SizeKb * 1024;
	pBuffer = (unsigned char*)malloc(dimFile);
	if ( !pBuffer )
	{
		printf("Impossibile allocare la memoria.\n");
		return 0;
	}
	memset(pBuffer, 'a', dimFile);
	
	if ( !MakeDir(dirName) )
	{
		free(pBuffer);
		return 0;
	}
	
	for ( k = 1; k <= n; k++ )
	{
		strncpy(szFileOutput, dirName, PATH_MAX);
		strncat(szFileOutput, "/rdr2_layer0.rpf.", PATH_MAX);
		sprintf(szNumFile, "%d", k);
		strncat(szFileOutput, szNumFile, PATH_MAX);
		
		fpOutput = fopen(szFileOutput, "wb");
		if ( fpOutput == NULL )
		{
			printf("Errore nell'apertura del file %s\n", szFileOutput);
			free(pBuffer);
			return 0;
		}
		
		fwrite(pBuffer, dimFile, 1, fpOutput);
		
		fclose(fpOutput);
	}
	
	free(pBuffer);

	return 1;
}

int ParseParam(const char *szParam, unsigned int *p)
{
	int k, len;
	int c;
	
	len = strlen(szParam);
	
	c = szParam[0];	
	if ( !isdigit(c) )
	{
		printf("Carattere non valido '%c'\n", c);
		return 0;
	}
	*p = c - '0';
	
	for ( k = 1; k < len; k++ )
	{
		c = szParam[k];
		if ( !isdigit(c) )
		{
			printf("Carattere non valido '%c'\n", c);
			return 0;
		}
		*p = *p * 10 + c - '0';
	}
	
	return 1;
}

int main(int argc, char* argv[])
{
	unsigned int numFiles;
	unsigned int sizeKb;
	
	if ( argc < 4 )
	{
		printf("\nUso: %s DirectoryPath n k\n", argv[0]);
		printf("n = numero dei file da creare\n");
		printf("k = dimensione di ciascun file in Kb\n");
		printf("Per esempio:\n\n %s dir_piena 100 4 \n\ncrea 100 file della dimensione di 4 Kb, nella directory 'dir_piena'\n\n", argv[0]);
		
		return -1;
	}
	
	if ( !ParseParam(argv[2], &numFiles) )
	{
		printf("Valore errato per il parametro n: %s\n", argv[2]);
		return -1;
	}

	if ( !ParseParam(argv[3], &sizeKb) )
	{
		printf("Valore errato per il parametro k: %s\n", argv[3]);
		return -1;
	}
	
	if ( !MakeFiles(argv[1], numFiles, sizeKb) )
		return -1;

	return 0;
}
Output:

Codice: Seleziona tutto

[vincenzo]$ gcc -Wall -W -pedantic -O2 makefiles.c -o makefiles
[vincenzo]$ ./makefiles

Uso: ./makefiles DirectoryPath n k
n = numero dei file da creare
k = dimensione di ciascun file in Kb
Per esempio:

 ./makefiles dir_piena 100 4 

crea 100 file della dimensione di 4 Kb, nella directory 'dir_piena'

[vincenzo]$ ./makefiles dir_piena 100 4
[vincenzo]$

Re: problema con pulizia cartella home

Inviato: giovedì 24 aprile 2014, 16:45
da Vincenzo1968
Ho aggiunto la rimozione ricorsiva dei file dalle sottodirectory(opzionale):

remfiles.c

Codice: Seleziona tutto

#define _FILE_OFFSET_BITS 64

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <time.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>

int matchPrefix(const char * szPrefix, const char *szFileName)
{	
	while ( *szPrefix )
	{
		if ( *szPrefix++ != *szFileName++ )
			return 0;
	}
	
	return 1;
}

void deleteFiles(char *dirName, const char* szPrefix, int *n)
{
	int removeStatus;
	DIR *dir = NULL;
	struct dirent entry;
	struct dirent *entryPtr = NULL;
	/* int retval = 0; */
	char pathName[PATH_MAX + 1];
	
	/* *n = 0; */
	
	dir = opendir(dirName);
	if( dir == NULL )
	{
		printf("Errore nell'apertura della directory '%s': %s\n", dirName, strerror(errno));
		return;
	}	
	
	/* retval = */ readdir_r(dir, &entry, &entryPtr);
	while( entryPtr != NULL )
	{
		struct stat entryInfo;
		
		if( ( strncmp(entry.d_name, ".", PATH_MAX) == 0 ) ||
		    ( strncmp(entry.d_name, "..", PATH_MAX) == 0 ) )
		{
			/* retval = */ readdir_r(dir, &entry, &entryPtr);
		    continue;
		}
 		
		strncpy(pathName, dirName, PATH_MAX);
		strncat(pathName, "/", PATH_MAX);
		strncat(pathName, entry.d_name, PATH_MAX);
		
		if( lstat(pathName, &entryInfo) == 0 )
		{		
			if( S_ISREG(entryInfo.st_mode) )	/* regular file */
			{
				if ( matchPrefix(szPrefix, entry.d_name) )
				{
					/* printf("Elimino il file %s\n", pathName); */
					removeStatus = remove(pathName);
					if ( removeStatus )
					{
						printf("Errore nella rimozione del file '%s': %s\n", pathName, strerror(errno));
					}
					else
					{
						(*n)++;
					}
				}
			}
		}
		else
		{
			printf("Errore lstat %s: %s\n", pathName, strerror(errno));
		}

		/* retval = */ readdir_r(dir, &entry, &entryPtr);
	}
		
	closedir(dir);		
}

void deleteFilesRecursive(char *dirName, const char* szPrefix, int *n)
{
	int removeStatus;
	DIR *dir = NULL;
	struct dirent entry;
	struct dirent *entryPtr = NULL;
	/* int retval = 0; */
	char pathName[PATH_MAX + 1];
	
	/* *n = 0; */
	
	/* lenPrefix = strnlen(szPrefix, PATH_MAX); */

	dir = opendir(dirName);
	if( dir == NULL )
	{
		printf("Errore nell'apertura della directory '%s': %s\n", dirName, strerror(errno));
		return;
	}	
	
	/* retval = */ readdir_r(dir, &entry, &entryPtr);
	while( entryPtr != NULL )
	{
		struct stat entryInfo;
		
		if( ( strncmp(entry.d_name, ".", PATH_MAX) == 0 ) ||
		    ( strncmp(entry.d_name, "..", PATH_MAX) == 0 ) )
		{
			/* retval = */ readdir_r(dir, &entry, &entryPtr);
		    continue;
		}
 		
		strncpy(pathName, dirName, PATH_MAX);
		strncat(pathName, "/", PATH_MAX);
		strncat(pathName, entry.d_name, PATH_MAX);
		
		if( lstat(pathName, &entryInfo) == 0 )
		{		
			if( S_ISREG(entryInfo.st_mode) )	/* regular file */
			{
				if ( matchPrefix(szPrefix, entry.d_name) )
				{
					/* printf("Elimino il file %s\n", pathName); */
					removeStatus = remove(pathName);
					if ( removeStatus )
					{
						printf("Errore nella rimozione del file '%s': %s\n", pathName, strerror(errno));
					}
					else
					{
						(*n)++;
					}
				}
			}
			else if( S_ISDIR(entryInfo.st_mode) )		/* directory */
			{
				deleteFilesRecursive(pathName, szPrefix, n);
			}			
		}
		else
		{
			printf("Errore lstat %s: %s\n", pathName, strerror(errno));
		}

		/* retval = */ readdir_r(dir, &entry, &entryPtr);
	}
		
	closedir(dir);		
}

int main(int argc, char **argv)
{
	int n, c;
	int recursive;
	double TempoInSecondi;
	
	clock_t c_start, c_end;	
		
	if( argc < 3 || argc > 4 )
	{
		printf("\nUso: %s DirectoryPath PrefixFileName [r]\n", argv[0]);
		printf("Specificare il parametro opzionale r se si desidera rimuovere i file anche nelle sottodirectory.\n\n");
		return -1;
	}	
	
	recursive = 0;
	if ( argc == 4 )
	{
		if ( strlen(argv[3]) == 1 && argv[3][0] == 'r' )
		{
			recursive = 1;
		}
		else
		{
			printf("\nUso: %s DirectoryPath PrefixFileName [r]\n", argv[0]);
			printf("Specificare il parametro opzionale r se si desidera rimuovere i file anche nelle sottodirectory.\n\n");
			return -1;			
		}
	}
	
	if ( recursive )
		printf("\nVerranno rimossi tutti i file con prefisso '%s' dalla directory '%s' e dalle sue sottodirectory\n", argv[2], argv[1]);
	else
		printf("\nVerranno rimossi tutti i file con prefisso '%s' dalla directory '%s'\n", argv[2], argv[1]);
	printf("procedere(S/N)? ");
	
	c = fgetc(stdin);
	
	if ( c != 'S' && c != 's' )
		return 0;
	
	c_start = clock();

	n = 0;
	if ( recursive )
		deleteFilesRecursive(argv[1], argv[2], &n);
	else
		deleteFiles(argv[1], argv[2], &n);
	
	c_end = clock();
	
	TempoInSecondi = (double)(c_end - c_start) / CLOCKS_PER_SEC;
		
	printf("\nRimossi %d file.\n", n);
	
	printf("\nTempo impiegato -> %5.5f secondi\n\n", TempoInSecondi);		
		
	return 0;
}
Output:

Codice: Seleziona tutto

[vincenzo]$ gcc -Wall -W -pedantic -O2 remfiles.c -o remfiles
[vincenzo]$ ./remfiles

Uso: ./remfiles DirectoryPath PrefixFileName [r]
Specificare il parametro opzionale r se si desidera rimuovere i file anche nelle sottodirectory.

[vincenzo]$ ./remfiles dir_piena rdr2_layer0.rpf r

Verranno rimossi tutti i file con prefisso 'rdr2_layer0.rpf' dalla directory 'dir_piena' e dalle sue sottodirectory
procedere(S/N)? s

Rimossi 112 file.

Re: problema con pulizia cartella home

Inviato: venerdì 25 aprile 2014, 1:27
da UbuNuovo
Ciao Vincenzo, se non mi cade la connessione, mi hanno detto che ci stanno lavorando, vedrai questo post.
È da ieri sera che non riesco a connettermi.
Domani provo i tuoi programmi e faccio qualche esperimento con numero di file variabile e in varie dimensioni, per levarmi una mia curiosità.
Probabilmente non influisce perché nella cancellazione viene disallocato l'inode, ma mi piace sperimentare.
Grazie per il tuo codice.

edit per scrivere questo messaggio mi ci sono volute due connessioni. Speriamo risolvano!!!!
Tutti gli orari sono UTC+02:00 Europa/Roma
Pagina 1 di 2

Basato su phpBB® Forum Software © phpBB Limited • PostgreSQL© • Megmoticons©