Line data    Source code

       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  * rmtree.c
       4              :  *
       5              :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       6              :  * Portions Copyright (c) 1994, Regents of the University of California
       7              :  *
       8              :  * IDENTIFICATION
       9              :  *    src/common/rmtree.c
      10              :  *
      11              :  *-------------------------------------------------------------------------
      12              :  */
      13              : 
      14              : #ifndef FRONTEND
      15              : #include "postgres.h"
      16              : #else
      17              : #include "postgres_fe.h"
      18              : #endif
      19              : 
      20              : #include <unistd.h>
      21              : #include <sys/stat.h>
      22              : 
      23              : #include "common/file_utils.h"
      24              : 
      25              : #ifndef FRONTEND
      26              : #include "storage/fd.h"
      27              : #define pg_log_warning(...) elog(WARNING, __VA_ARGS__)
      28              : #define LOG_LEVEL WARNING
      29              : #define OPENDIR(x) AllocateDir(x)
      30              : #define CLOSEDIR(x) FreeDir(x)
      31              : #else
      32              : #include "common/logging.h"
      33              : #define LOG_LEVEL PG_LOG_WARNING
      34              : #define OPENDIR(x) opendir(x)
      35              : #define CLOSEDIR(x) closedir(x)
      36              : #endif
      37              : 
      38              : /*
      39              :  *  rmtree
      40              :  *
      41              :  *  Delete a directory tree recursively.
      42              :  *  Assumes path points to a valid directory.
      43              :  *  Deletes everything under path.
      44              :  *  If rmtopdir is true deletes the directory too.
      45              :  *  Returns true if successful, false if there was any problem.
      46              :  *  (The details of the problem are reported already, so caller
      47              :  *  doesn't really have to say anything more, but most do.)
      48              :  */
      49              : bool
      50         3790 : rmtree(const char *path, bool rmtopdir)
      51              : {
      52              :     char        pathbuf[MAXPGPATH];
      53              :     DIR        *dir;
      54              :     struct dirent *de;
      55         3790 :     bool        result = true;
      56         3790 :     size_t      dirnames_size = 0;
      57         3790 :     size_t      dirnames_capacity = 8;
      58              :     char      **dirnames;
      59              : 
      60         3790 :     dir = OPENDIR(path);
      61         3790 :     if (dir == NULL)
      62              :     {
      63            0 :         pg_log_warning("could not open directory \"%s\": %m", path);
      64            0 :         return false;
      65              :     }
      66              : 
      67         3790 :     dirnames = palloc_array(char *, dirnames_capacity);
      68              : 
      69       170048 :     while (errno = 0, (de = readdir(dir)))
      70              :     {
      71       166258 :         if (strcmp(de->d_name, ".") == 0 ||
      72       162468 :             strcmp(de->d_name, "..") == 0)
      73         7580 :             continue;
      74       158678 :         snprintf(pathbuf, sizeof(pathbuf), "%s/%s", path, de->d_name);
      75       158678 :         switch (get_dirent_type(pathbuf, de, false, LOG_LEVEL))
      76              :         {
      77            0 :             case PGFILETYPE_ERROR:
      78              :                 /* already logged, press on */
      79            0 :                 break;
      80         2957 :             case PGFILETYPE_DIR:
      81              : 
      82              :                 /*
      83              :                  * Defer recursion until after we've closed this directory, to
      84              :                  * avoid using more than one file descriptor at a time.
      85              :                  */
      86         2957 :                 if (dirnames_size == dirnames_capacity)
      87              :                 {
      88          208 :                     dirnames = repalloc(dirnames,
      89              :                                         sizeof(char *) * dirnames_capacity * 2);
      90          208 :                     dirnames_capacity *= 2;
      91              :                 }
      92         2957 :                 dirnames[dirnames_size++] = pstrdup(pathbuf);
      93         2957 :                 break;
      94       155721 :             default:
      95       155721 :                 if (unlink(pathbuf) != 0 && errno != ENOENT)
      96              :                 {
      97            0 :                     pg_log_warning("could not remove file \"%s\": %m", pathbuf);
      98            0 :                     result = false;
      99              :                 }
     100       155721 :                 break;
     101              :         }
     102              :     }
     103              : 
     104         3790 :     if (errno != 0)
     105              :     {
     106            0 :         pg_log_warning("could not read directory \"%s\": %m", path);
     107            0 :         result = false;
     108              :     }
     109              : 
     110         3790 :     CLOSEDIR(dir);
     111              : 
     112              :     /* Now recurse into the subdirectories we found. */
     113         6747 :     for (size_t i = 0; i < dirnames_size; ++i)
     114              :     {
     115         2957 :         if (!rmtree(dirnames[i], true))
     116            0 :             result = false;
     117         2957 :         pfree(dirnames[i]);
     118              :     }
     119              : 
     120         3790 :     if (rmtopdir)
     121              :     {
     122         3790 :         if (rmdir(path) != 0)
     123              :         {
     124            0 :             pg_log_warning("could not remove directory \"%s\": %m", path);
     125            0 :             result = false;
     126              :         }
     127              :     }
     128              : 
     129         3790 :     pfree(dirnames);
     130              : 
     131         3790 :     return result;
     132              : }