Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * copydir.c
4 : : * copies a directory
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : * While "xcopy /e /i /q" works fine for copying directories, on Windows XP
10 : : * it requires a Window handle which prevents it from working when invoked
11 : : * as a service.
12 : : *
13 : : * IDENTIFICATION
14 : : * src/backend/storage/file/copydir.c
15 : : *
16 : : *-------------------------------------------------------------------------
17 : : */
18 : :
19 : : #include "postgres.h"
20 : :
21 : : #ifdef HAVE_COPYFILE_H
22 : : #include <copyfile.h>
23 : : #endif
24 : : #include <fcntl.h>
25 : : #include <unistd.h>
26 : :
27 : : #include "common/file_utils.h"
28 : : #include "miscadmin.h"
29 : : #include "pgstat.h"
30 : : #include "storage/copydir.h"
31 : : #include "storage/fd.h"
32 : : #include "utils/wait_event.h"
33 : :
34 : : /* GUCs */
35 : : int file_copy_method = FILE_COPY_METHOD_COPY;
36 : :
37 : : static void clone_file(const char *fromfile, const char *tofile);
38 : :
39 : : /*
40 : : * copydir: copy a directory
41 : : *
42 : : * If recurse is false, subdirectories are ignored. Anything that's not
43 : : * a directory or a regular file is ignored.
44 : : *
45 : : * This function uses the file_copy_method GUC. New uses of this function must
46 : : * be documented in doc/src/sgml/config.sgml.
47 : : */
48 : : void
49 : 171 : copydir(const char *fromdir, const char *todir, bool recurse)
50 : : {
51 : : DIR *xldir;
52 : : struct dirent *xlde;
53 : : char fromfile[MAXPGPATH * 2];
54 : : char tofile[MAXPGPATH * 2];
55 : :
56 [ - + ]: 171 : if (MakePGDirectory(todir) != 0)
57 [ # # ]: 0 : ereport(ERROR,
58 : : (errcode_for_file_access(),
59 : : errmsg("could not create directory \"%s\": %m", todir)));
60 : :
61 : 171 : xldir = AllocateDir(fromdir);
62 : :
63 [ + + ]: 55302 : while ((xlde = ReadDir(xldir, fromdir)) != NULL)
64 : : {
65 : : PGFileType xlde_type;
66 : :
67 : : /* If we got a cancel signal during the copy of the directory, quit */
68 [ - + ]: 55131 : CHECK_FOR_INTERRUPTS();
69 : :
70 [ + + ]: 55131 : if (strcmp(xlde->d_name, ".") == 0 ||
71 [ + + ]: 54960 : strcmp(xlde->d_name, "..") == 0)
72 : 342 : continue;
73 : :
74 : 54789 : snprintf(fromfile, sizeof(fromfile), "%s/%s", fromdir, xlde->d_name);
75 : 54789 : snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name);
76 : :
77 : 54789 : xlde_type = get_dirent_type(fromfile, xlde, false, ERROR);
78 : :
79 [ - + ]: 54789 : if (xlde_type == PGFILETYPE_DIR)
80 : : {
81 : : /* recurse to handle subdirectories */
82 [ # # ]: 0 : if (recurse)
83 : 0 : copydir(fromfile, tofile, true);
84 : : }
85 [ + - ]: 54789 : else if (xlde_type == PGFILETYPE_REG)
86 : : {
87 [ - + ]: 54789 : if (file_copy_method == FILE_COPY_METHOD_CLONE)
88 : 0 : clone_file(fromfile, tofile);
89 : : else
90 : 54789 : copy_file(fromfile, tofile);
91 : : }
92 : : }
93 : 171 : FreeDir(xldir);
94 : :
95 : : /*
96 : : * Be paranoid here and fsync all files to ensure the copy is really done.
97 : : * But if fsync is disabled, we're done.
98 : : */
99 [ + - ]: 171 : if (!enableFsync)
100 : 171 : return;
101 : :
102 : 0 : xldir = AllocateDir(todir);
103 : :
104 [ # # ]: 0 : while ((xlde = ReadDir(xldir, todir)) != NULL)
105 : : {
106 [ # # ]: 0 : if (strcmp(xlde->d_name, ".") == 0 ||
107 [ # # ]: 0 : strcmp(xlde->d_name, "..") == 0)
108 : 0 : continue;
109 : :
110 : 0 : snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name);
111 : :
112 : : /*
113 : : * We don't need to sync subdirectories here since the recursive
114 : : * copydir will do it before it returns
115 : : */
116 [ # # ]: 0 : if (get_dirent_type(tofile, xlde, false, ERROR) == PGFILETYPE_REG)
117 : 0 : fsync_fname(tofile, false);
118 : : }
119 : 0 : FreeDir(xldir);
120 : :
121 : : /*
122 : : * It's important to fsync the destination directory itself as individual
123 : : * file fsyncs don't guarantee that the directory entry for the file is
124 : : * synced. Recent versions of ext4 have made the window much wider but
125 : : * it's been true for ext3 and other filesystems in the past.
126 : : */
127 : 0 : fsync_fname(todir, true);
128 : : }
129 : :
130 : : /*
131 : : * copy one file
132 : : */
133 : : void
134 : 54809 : copy_file(const char *fromfile, const char *tofile)
135 : : {
136 : : char *buffer;
137 : : int srcfd;
138 : : int dstfd;
139 : : ssize_t nbytes;
140 : : off_t offset;
141 : : off_t flush_offset;
142 : :
143 : : /* Size of copy buffer (read and write requests) */
144 : : #define COPY_BUF_SIZE (8 * BLCKSZ)
145 : :
146 : : /*
147 : : * Size of data flush requests. It seems beneficial on most platforms to
148 : : * do this every 1MB or so. But macOS, at least with early releases of
149 : : * APFS, is really unfriendly to small mmap/msync requests, so there do it
150 : : * only every 32MB.
151 : : */
152 : : #if defined(__darwin__)
153 : : #define FLUSH_DISTANCE (32 * 1024 * 1024)
154 : : #else
155 : : #define FLUSH_DISTANCE (1024 * 1024)
156 : : #endif
157 : :
158 : : /* Use palloc to ensure we get a maxaligned buffer */
159 : 54809 : buffer = palloc(COPY_BUF_SIZE);
160 : :
161 : : /*
162 : : * Open the files
163 : : */
164 : 54809 : srcfd = OpenTransientFile(fromfile, O_RDONLY | PG_BINARY);
165 [ - + ]: 54809 : if (srcfd < 0)
166 [ # # ]: 0 : ereport(ERROR,
167 : : (errcode_for_file_access(),
168 : : errmsg("could not open file \"%s\": %m", fromfile)));
169 : :
170 : 54809 : dstfd = OpenTransientFile(tofile, O_RDWR | O_CREAT | O_EXCL | PG_BINARY);
171 [ - + ]: 54809 : if (dstfd < 0)
172 [ # # ]: 0 : ereport(ERROR,
173 : : (errcode_for_file_access(),
174 : : errmsg("could not create file \"%s\": %m", tofile)));
175 : :
176 : : /*
177 : : * Do the data copying.
178 : : */
179 : 54809 : flush_offset = 0;
180 : 54809 : for (offset = 0;; offset += nbytes)
181 : : {
182 : : /* If we got a cancel signal during the copy of the file, quit */
183 [ - + ]: 109043 : CHECK_FOR_INTERRUPTS();
184 : :
185 : : /*
186 : : * We fsync the files later, but during the copy, flush them every so
187 : : * often to avoid spamming the cache and hopefully get the kernel to
188 : : * start writing them out before the fsync comes.
189 : : */
190 [ + + ]: 109043 : if (offset - flush_offset >= FLUSH_DISTANCE)
191 : : {
192 : 32 : pg_flush_data(dstfd, flush_offset, offset - flush_offset);
193 : 32 : flush_offset = offset;
194 : : }
195 : :
196 : 109043 : pgstat_report_wait_start(WAIT_EVENT_COPY_FILE_READ);
197 : 109043 : nbytes = read(srcfd, buffer, COPY_BUF_SIZE);
198 : 109043 : pgstat_report_wait_end();
199 [ - + ]: 109043 : if (nbytes < 0)
200 [ # # ]: 0 : ereport(ERROR,
201 : : (errcode_for_file_access(),
202 : : errmsg("could not read file \"%s\": %m", fromfile)));
203 [ + + ]: 109043 : if (nbytes == 0)
204 : 54809 : break;
205 : 54234 : errno = 0;
206 : 54234 : pgstat_report_wait_start(WAIT_EVENT_COPY_FILE_WRITE);
207 [ - + ]: 54234 : if (write(dstfd, buffer, nbytes) != nbytes)
208 : : {
209 : : /* if write didn't set errno, assume problem is no disk space */
210 [ # # ]: 0 : if (errno == 0)
211 : 0 : errno = ENOSPC;
212 [ # # ]: 0 : ereport(ERROR,
213 : : (errcode_for_file_access(),
214 : : errmsg("could not write to file \"%s\": %m", tofile)));
215 : : }
216 : 54234 : pgstat_report_wait_end();
217 : : }
218 : :
219 [ + + ]: 54809 : if (offset > flush_offset)
220 : 44708 : pg_flush_data(dstfd, flush_offset, offset - flush_offset);
221 : :
222 [ - + ]: 54809 : if (CloseTransientFile(dstfd) != 0)
223 [ # # ]: 0 : ereport(ERROR,
224 : : (errcode_for_file_access(),
225 : : errmsg("could not close file \"%s\": %m", tofile)));
226 : :
227 [ - + ]: 54809 : if (CloseTransientFile(srcfd) != 0)
228 [ # # ]: 0 : ereport(ERROR,
229 : : (errcode_for_file_access(),
230 : : errmsg("could not close file \"%s\": %m", fromfile)));
231 : :
232 : 54809 : pfree(buffer);
233 : 54809 : }
234 : :
235 : : /*
236 : : * clone one file
237 : : */
238 : : static void
239 : 0 : clone_file(const char *fromfile, const char *tofile)
240 : : {
241 : : #if defined(HAVE_COPYFILE) && defined(COPYFILE_CLONE_FORCE)
242 : : if (copyfile(fromfile, tofile, NULL, COPYFILE_CLONE_FORCE) < 0)
243 : : ereport(ERROR,
244 : : (errcode_for_file_access(),
245 : : errmsg("could not clone file \"%s\" to \"%s\": %m",
246 : : fromfile, tofile)));
247 : : #elif defined(HAVE_COPY_FILE_RANGE)
248 : : int srcfd;
249 : : int dstfd;
250 : : ssize_t nbytes;
251 : :
252 : 0 : srcfd = OpenTransientFile(fromfile, O_RDONLY | PG_BINARY);
253 [ # # ]: 0 : if (srcfd < 0)
254 [ # # ]: 0 : ereport(ERROR,
255 : : (errcode_for_file_access(),
256 : : errmsg("could not open file \"%s\": %m", fromfile)));
257 : :
258 : 0 : dstfd = OpenTransientFile(tofile, O_WRONLY | O_CREAT | O_EXCL | PG_BINARY);
259 [ # # ]: 0 : if (dstfd < 0)
260 [ # # ]: 0 : ereport(ERROR,
261 : : (errcode_for_file_access(),
262 : : errmsg("could not create file \"%s\": %m", tofile)));
263 : :
264 : : do
265 : : {
266 : : /*
267 : : * Don't copy too much at once, so we can check for interrupts from
268 : : * time to time if it falls back to a slow copy.
269 : : */
270 [ # # ]: 0 : CHECK_FOR_INTERRUPTS();
271 : 0 : pgstat_report_wait_start(WAIT_EVENT_COPY_FILE_COPY);
272 : 0 : nbytes = copy_file_range(srcfd, NULL, dstfd, NULL, 1024 * 1024, 0);
273 [ # # # # ]: 0 : if (nbytes < 0 && errno != EINTR)
274 [ # # ]: 0 : ereport(ERROR,
275 : : (errcode_for_file_access(),
276 : : errmsg("could not clone file \"%s\" to \"%s\": %m",
277 : : fromfile, tofile)));
278 : 0 : pgstat_report_wait_end();
279 : : }
280 [ # # ]: 0 : while (nbytes != 0);
281 : :
282 [ # # ]: 0 : if (CloseTransientFile(dstfd) != 0)
283 [ # # ]: 0 : ereport(ERROR,
284 : : (errcode_for_file_access(),
285 : : errmsg("could not close file \"%s\": %m", tofile)));
286 : :
287 [ # # ]: 0 : if (CloseTransientFile(srcfd) != 0)
288 [ # # ]: 0 : ereport(ERROR,
289 : : (errcode_for_file_access(),
290 : : errmsg("could not close file \"%s\": %m", fromfile)));
291 : : #else
292 : : /* If there is no CLONE support this function should not be called. */
293 : : pg_unreachable();
294 : : #endif
295 : 0 : }
|
