rmtree.c File Reference

#include "postgres.h"
#include <unistd.h>
#include <sys/stat.h>
#include "common/file_utils.h"
#include "storage/fd.h"

Include dependency graph for rmtree.c:

Go to the source code of this file.

Macros
#define	pg_log_warning(...)   elog(WARNING, __VA_ARGS__)
#define	LOG_LEVEL   WARNING
#define	OPENDIR(x)   AllocateDir(x)
#define	CLOSEDIR(x)   FreeDir(x)

Functions
bool	rmtree (const char *path, bool rmtopdir)

Macro Definition Documentation

CLOSEDIR

#define CLOSEDIR

(

x

)

FreeDir(x)

Definition at line 30 of file rmtree.c.

LOG_LEVEL

#define LOG_LEVEL   WARNING

Definition at line 28 of file rmtree.c.

OPENDIR

#define OPENDIR

(

x

)

AllocateDir(x)

Definition at line 29 of file rmtree.c.

pg_log_warning

#define pg_log_warning

(

...

)

elog(WARNING, __VA_ARGS__)

Definition at line 27 of file rmtree.c.

Function Documentation

rmtree()

bool rmtree	(	const char *	path,
		bool	rmtopdir
	)

Definition at line 50 of file rmtree.c.

{
    char        pathbuf[MAXPGPATH];
    DIR        *dir;
    struct dirent *de;
    bool        result = true;
    size_t      dirnames_size = 0;
    size_t      dirnames_capacity = 8;
    char      **dirnames = palloc(sizeof(char *) * dirnames_capacity);
 
    dir = OPENDIR(path);
    if (dir == NULL)
    {
        pg_log_warning("could not open directory \"%s\": %m", path);
        return false;
    }
 
    while (errno = 0, (de = readdir(dir)))
    {
        if (strcmp(de->d_name, ".") == 0 ||
            strcmp(de->d_name, "..") == 0)
            continue;
        snprintf(pathbuf, sizeof(pathbuf), "%s/%s", path, de->d_name);
        switch (get_dirent_type(pathbuf, de, false, LOG_LEVEL))
        {
            case PGFILETYPE_ERROR:
                /* already logged, press on */
                break;
            case PGFILETYPE_DIR:
 
                /*
                 * Defer recursion until after we've closed this directory, to
                 * avoid using more than one file descriptor at a time.
                 */
                if (dirnames_size == dirnames_capacity)
                {
                    dirnames = repalloc(dirnames,
                                        sizeof(char *) * dirnames_capacity * 2);
                    dirnames_capacity *= 2;
                }
                dirnames[dirnames_size++] = pstrdup(pathbuf);
                break;
            default:
                if (unlink(pathbuf) != 0 && errno != ENOENT)
                {
                    pg_log_warning("could not unlink file \"%s\": %m", pathbuf);
                    result = false;
                }
                break;
        }
    }
 
    if (errno != 0)
    {
        pg_log_warning("could not read directory \"%s\": %m", path);
        result = false;
    }
 
    CLOSEDIR(dir);
 
    /* Now recurse into the subdirectories we found. */
    for (size_t i = 0; i < dirnames_size; ++i)
    {
        if (!rmtree(dirnames[i], true))
            result = false;
        pfree(dirnames[i]);
    }
 
    if (rmtopdir)
    {
        if (rmdir(path) != 0)
        {
            pg_log_warning("could not remove directory \"%s\": %m", path);
            result = false;
        }
    }
 
    pfree(dirnames);
 
    return result;
}

References CLOSEDIR, dirent::d_name, get_dirent_type(), i, LOG_LEVEL, MAXPGPATH, OPENDIR, palloc(), pfree(), pg_log_warning, PGFILETYPE_DIR, PGFILETYPE_ERROR, pstrdup(), readdir(), repalloc(), and snprintf.

Referenced by cleanup_directories_atexit(), cleanup_output_dirs(), CreateSlotOnDisk(), dbase_redo(), movedb(), movedb_failure_callback(), regression_main(), remove_dbtablespaces(), remove_new_subdir(), ReplicationSlotDropPtr(), RestoreSlotFromDisk(), and StartupReplicationSlots().