problema con pulizia cartella home

[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

[giulux]

prova

Codice: Seleziona tutto

rm rdr2_layer0.rpf*

[zampy]

mi dice

Codice: Seleziona tutto

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

[giulux]

mhm, prova a metterli in una cartella che crei e poi

Codice: Seleziona tutto

rm -r NOMECARTELLA

[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???

[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.

[zampy]

infatti, stesso messaggio di prima

[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).

[zampy]

ok, va bene grazie comunque

[giulux]

Vuoi che ti sposto o vuoi restare qui?

[zampy]

se mi sposti mi fai un favore, grazie

[giulux]

Fatto.
Cambia titolo.

[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")

[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?

[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

[crap0101]

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 :-)

[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

[Vincenzo1968]

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]$

[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.

[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!!!!