LCOV - code coverage report
Current view: top level - src/common - rmtree.c (source / functions) Coverage Total Hit
Test: PostgreSQL 20devel Lines: 78.6 % 42 33
Test Date: 2026-08-25 05:15:49 Functions: 100.0 % 1 1
Legend: Lines:     hit not hit
Branches: + taken - not taken # not executed
Branches: 57.1 % 35 20

             Branch data     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                 :        4005 : rmtree(const char *path, bool rmtopdir)
      51                 :             : {
      52                 :             :     char        pathbuf[MAXPGPATH];
      53                 :             :     DIR        *dir;
      54                 :             :     struct dirent *de;
      55                 :        4005 :     bool        result = true;
      56                 :        4005 :     size_t      dirnames_size = 0;
      57                 :        4005 :     size_t      dirnames_capacity = 8;
      58                 :             :     char      **dirnames;
      59                 :             : 
      60                 :        4005 :     dir = OPENDIR(path);
      61         [ +  + ]:        4005 :     if (dir == NULL)
      62                 :             :     {
      63         [ +  - ]:           1 :         pg_log_warning("could not open directory \"%s\": %m", path);
      64                 :           1 :         return false;
      65                 :             :     }
      66                 :             : 
      67                 :        4004 :     dirnames = palloc_array(char *, dirnames_capacity);
      68                 :             : 
      69         [ +  + ]:      191057 :     while (errno = 0, (de = readdir(dir)))
      70                 :             :     {
      71         [ +  + ]:      187053 :         if (strcmp(de->d_name, ".") == 0 ||
      72         [ +  + ]:      183049 :             strcmp(de->d_name, "..") == 0)
      73                 :        8008 :             continue;
      74                 :      179045 :         snprintf(pathbuf, sizeof(pathbuf), "%s/%s", path, de->d_name);
      75      [ -  +  + ]:      179045 :         switch (get_dirent_type(pathbuf, de, false, LOG_LEVEL))
      76                 :             :         {
      77                 :           0 :             case PGFILETYPE_ERROR:
      78                 :             :                 /* already logged, press on */
      79                 :           0 :                 break;
      80                 :        3095 :             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         [ +  + ]:        3095 :                 if (dirnames_size == dirnames_capacity)
      87                 :             :                 {
      88                 :         218 :                     dirnames = repalloc_array(dirnames, char *, dirnames_capacity * 2);
      89                 :         218 :                     dirnames_capacity *= 2;
      90                 :             :                 }
      91                 :        3095 :                 dirnames[dirnames_size++] = pstrdup(pathbuf);
      92                 :        3095 :                 break;
      93                 :      175950 :             default:
      94   [ -  +  -  - ]:      175950 :                 if (unlink(pathbuf) != 0 && errno != ENOENT)
      95                 :             :                 {
      96         [ #  # ]:           0 :                     pg_log_warning("could not remove file \"%s\": %m", pathbuf);
      97                 :           0 :                     result = false;
      98                 :             :                 }
      99                 :      175950 :                 break;
     100                 :             :         }
     101                 :             :     }
     102                 :             : 
     103         [ -  + ]:        4004 :     if (errno != 0)
     104                 :             :     {
     105         [ #  # ]:           0 :         pg_log_warning("could not read directory \"%s\": %m", path);
     106                 :           0 :         result = false;
     107                 :             :     }
     108                 :             : 
     109                 :        4004 :     CLOSEDIR(dir);
     110                 :             : 
     111                 :             :     /* Now recurse into the subdirectories we found. */
     112         [ +  + ]:        7099 :     for (size_t i = 0; i < dirnames_size; ++i)
     113                 :             :     {
     114         [ -  + ]:        3095 :         if (!rmtree(dirnames[i], true))
     115                 :           0 :             result = false;
     116                 :        3095 :         pfree(dirnames[i]);
     117                 :             :     }
     118                 :             : 
     119         [ +  - ]:        4004 :     if (rmtopdir)
     120                 :             :     {
     121         [ -  + ]:        4004 :         if (rmdir(path) != 0)
     122                 :             :         {
     123         [ #  # ]:           0 :             pg_log_warning("could not remove directory \"%s\": %m", path);
     124                 :           0 :             result = false;
     125                 :             :         }
     126                 :             :     }
     127                 :             : 
     128                 :        4004 :     pfree(dirnames);
     129                 :             : 
     130                 :        4004 :     return result;
     131                 :             : }
        

Generated by: LCOV version 2.0-1