Mercurial

comparison third_party/libuv/src/unix/fs.c @ 160:948de3f54cea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added libuv
author June Park <parkjune1995@gmail.com>
date Wed, 14 Jan 2026 19:39:52 -0800
parents
children
comparison
equal deleted inserted replaced
159:05cf9467a1c3 160:948de3f54cea
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to
5 * deal in the Software without restriction, including without limitation the
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7 * sell copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
9 *
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19 * IN THE SOFTWARE.
20 */
21
22 /* Caveat emptor: this file deviates from the libuv convention of returning
23 * negated errno codes. Most uv_fs_*() functions map directly to the system
24 * call of the same name. For more complex wrappers, it's easier to just
25 * return -1 with errno set. The dispatcher in uv__fs_work() takes care of
26 * getting the errno to the right place (req->result or as the return value.)
27 */
28
29 #include "uv.h"
30 #include "internal.h"
31
32 #include <errno.h>
33 #include <dlfcn.h>
34 #include <stdatomic.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <limits.h> /* PATH_MAX */
39
40 #include <sys/types.h>
41 #include <sys/socket.h>
42 #include <sys/stat.h>
43 #include <sys/time.h>
44 #include <sys/uio.h>
45 #include <unistd.h>
46 #include <fcntl.h>
47 #include <poll.h>
48
49 #if defined(__linux__)
50 # include <sys/sendfile.h>
51 #endif
52
53 #if defined(__sun)
54 # include <sys/sendfile.h>
55 # include <sys/sysmacros.h>
56 #endif
57
58 #if defined(__APPLE__)
59 # include <sys/sysctl.h>
60 #elif defined(__linux__) && !defined(FICLONE)
61 # include <sys/ioctl.h>
62 # define FICLONE _IOW(0x94, 9, int)
63 #endif
64
65 #if defined(_AIX) && !defined(_AIX71)
66 # include <utime.h>
67 #endif
68
69 #if defined(__APPLE__) || \
70 defined(__DragonFly__) || \
71 defined(__FreeBSD__) || \
72 defined(__OpenBSD__) || \
73 defined(__NetBSD__)
74 # include <sys/param.h>
75 # include <sys/mount.h>
76 #elif defined(__sun) || \
77 defined(__MVS__) || \
78 defined(__NetBSD__) || \
79 defined(__HAIKU__) || \
80 defined(__QNX__)
81 # include <sys/statvfs.h>
82 #else
83 # include <sys/statfs.h>
84 #endif
85
86 #if defined(_AIX) && _XOPEN_SOURCE <= 600
87 extern char *mkdtemp(char *template); /* See issue #740 on AIX < 7 */
88 #endif
89
90 #define INIT(subtype) \
91 do { \
92 if (req == NULL) \
93 return UV_EINVAL; \
94 UV_REQ_INIT(req, UV_FS); \
95 req->fs_type = UV_FS_ ## subtype; \
96 req->result = 0; \
97 req->ptr = NULL; \
98 req->loop = loop; \
99 req->path = NULL; \
100 req->new_path = NULL; \
101 req->bufs = NULL; \
102 req->cb = cb; \
103 } \
104 while (0)
105
106 #define PATH \
107 do { \
108 assert(path != NULL); \
109 if (cb == NULL) { \
110 req->path = path; \
111 } else { \
112 req->path = uv__strdup(path); \
113 if (req->path == NULL) \
114 return UV_ENOMEM; \
115 } \
116 } \
117 while (0)
118
119 #define PATH2 \
120 do { \
121 if (cb == NULL) { \
122 req->path = path; \
123 req->new_path = new_path; \
124 } else { \
125 size_t path_len; \
126 size_t new_path_len; \
127 path_len = strlen(path) + 1; \
128 new_path_len = strlen(new_path) + 1; \
129 req->path = uv__malloc(path_len + new_path_len); \
130 if (req->path == NULL) \
131 return UV_ENOMEM; \
132 req->new_path = req->path + path_len; \
133 memcpy((void*) req->path, path, path_len); \
134 memcpy((void*) req->new_path, new_path, new_path_len); \
135 } \
136 } \
137 while (0)
138
139 #define POST \
140 do { \
141 if (cb != NULL) { \
142 uv__req_register(loop); \
143 uv__work_submit(loop, \
144 &req->work_req, \
145 UV__WORK_FAST_IO, \
146 uv__fs_work, \
147 uv__fs_done); \
148 return 0; \
149 } \
150 else { \
151 uv__fs_work(&req->work_req); \
152 return req->result; \
153 } \
154 } \
155 while (0)
156
157
158 static int uv__fs_close(int fd) {
159 int rc;
160
161 rc = uv__close_nocancel(fd);
162 if (rc == -1)
163 if (errno == EINTR || errno == EINPROGRESS)
164 rc = 0; /* The close is in progress, not an error. */
165
166 return rc;
167 }
168
169
170 static ssize_t uv__fs_fsync(uv_fs_t* req) {
171 #if defined(__APPLE__)
172 /* Apple's fdatasync and fsync explicitly do NOT flush the drive write cache
173 * to the drive platters. This is in contrast to Linux's fdatasync and fsync
174 * which do, according to recent man pages. F_FULLFSYNC is Apple's equivalent
175 * for flushing buffered data to permanent storage. If F_FULLFSYNC is not
176 * supported by the file system we fall back to F_BARRIERFSYNC or fsync().
177 * This is the same approach taken by sqlite, except sqlite does not issue
178 * an F_BARRIERFSYNC call.
179 */
180 int r;
181
182 r = fcntl(req->file, F_FULLFSYNC);
183 if (r != 0)
184 r = fcntl(req->file, 85 /* F_BARRIERFSYNC */); /* fsync + barrier */
185 if (r != 0)
186 r = fsync(req->file);
187 return r;
188 #else
189 return fsync(req->file);
190 #endif
191 }
192
193
194 static ssize_t uv__fs_fdatasync(uv_fs_t* req) {
195 #if defined(__linux__) || defined(__sun) || defined(__NetBSD__)
196 return fdatasync(req->file);
197 #elif defined(__APPLE__)
198 /* See the comment in uv__fs_fsync. */
199 return uv__fs_fsync(req);
200 #else
201 return fsync(req->file);
202 #endif
203 }
204
205
206 #if defined(__APPLE__) \
207 || defined(_AIX71) \
208 || defined(__DragonFly__) \
209 || defined(__FreeBSD__) \
210 || defined(__HAIKU__) \
211 || defined(__NetBSD__) \
212 || defined(__OpenBSD__) \
213 || defined(__linux__) \
214 || defined(__sun)
215 static struct timespec uv__fs_to_timespec(double time) {
216 struct timespec ts;
217
218 if (uv__isinf(time))
219 return (struct timespec){UTIME_NOW, UTIME_NOW};
220 if (uv__isnan(time))
221 return (struct timespec){UTIME_OMIT, UTIME_OMIT};
222
223 ts.tv_sec = time;
224 ts.tv_nsec = (time - ts.tv_sec) * 1e9;
225
226 /* TODO(bnoordhuis) Remove this. utimesat() has nanosecond resolution but we
227 * stick to microsecond resolution for the sake of consistency with other
228 * platforms. I'm the original author of this compatibility hack but I'm
229 * less convinced it's useful nowadays.
230 */
231 ts.tv_nsec -= ts.tv_nsec % 1000;
232
233 if (ts.tv_nsec < 0) {
234 ts.tv_nsec += 1e9;
235 ts.tv_sec -= 1;
236 }
237 return ts;
238 }
239 #endif
240
241
242 static ssize_t uv__fs_futime(uv_fs_t* req) {
243 #if defined(__APPLE__) \
244 || defined(_AIX71) \
245 || defined(__DragonFly__) \
246 || defined(__FreeBSD__) \
247 || defined(__HAIKU__) \
248 || defined(__NetBSD__) \
249 || defined(__OpenBSD__) \
250 || defined(__linux__) \
251 || defined(__sun)
252 struct timespec ts[2];
253 ts[0] = uv__fs_to_timespec(req->atime);
254 ts[1] = uv__fs_to_timespec(req->mtime);
255 return futimens(req->file, ts);
256 #elif defined(__MVS__)
257 attrib_t atr;
258 memset(&atr, 0, sizeof(atr));
259 atr.att_mtimechg = 1;
260 atr.att_atimechg = 1;
261 atr.att_mtime = req->mtime;
262 atr.att_atime = req->atime;
263 return __fchattr(req->file, &atr, sizeof(atr));
264 #else
265 errno = ENOSYS;
266 return -1;
267 #endif
268 }
269
270
271 static ssize_t uv__fs_mkdtemp(uv_fs_t* req) {
272 return mkdtemp((char*) req->path) ? 0 : -1;
273 }
274
275
276 static int (*uv__mkostemp)(char*, int);
277
278
279 static void uv__mkostemp_initonce(void) {
280 /* z/os doesn't have RTLD_DEFAULT but that's okay
281 * because it doesn't have mkostemp(O_CLOEXEC) either.
282 */
283 #ifdef RTLD_DEFAULT
284 uv__mkostemp = (int (*)(char*, int)) dlsym(RTLD_DEFAULT, "mkostemp");
285
286 /* We don't care about errors, but we do want to clean them up.
287 * If there has been no error, then dlerror() will just return
288 * NULL.
289 */
290 dlerror();
291 #endif /* RTLD_DEFAULT */
292 }
293
294
295 static int uv__fs_mkstemp(uv_fs_t* req) {
296 static uv_once_t once = UV_ONCE_INIT;
297 int r;
298 #ifdef O_CLOEXEC
299 static _Atomic int no_cloexec_support;
300 #endif
301 static const char pattern[] = "XXXXXX";
302 static const size_t pattern_size = sizeof(pattern) - 1;
303 char* path;
304 size_t path_length;
305
306 path = (char*) req->path;
307 path_length = strlen(path);
308
309 /* EINVAL can be returned for 2 reasons:
310 1. The template's last 6 characters were not XXXXXX
311 2. open() didn't support O_CLOEXEC
312 We want to avoid going to the fallback path in case
313 of 1, so it's manually checked before. */
314 if (path_length < pattern_size ||
315 strcmp(path + path_length - pattern_size, pattern)) {
316 errno = EINVAL;
317 r = -1;
318 goto clobber;
319 }
320
321 uv_once(&once, uv__mkostemp_initonce);
322
323 #ifdef O_CLOEXEC
324 if (atomic_load_explicit(&no_cloexec_support, memory_order_relaxed) == 0 &&
325 uv__mkostemp != NULL) {
326 r = uv__mkostemp(path, O_CLOEXEC);
327
328 if (r >= 0)
329 return r;
330
331 /* If mkostemp() returns EINVAL, it means the kernel doesn't
332 support O_CLOEXEC, so we just fallback to mkstemp() below. */
333 if (errno != EINVAL)
334 goto clobber;
335
336 /* We set the static variable so that next calls don't even
337 try to use mkostemp. */
338 atomic_store_explicit(&no_cloexec_support, 1, memory_order_relaxed);
339 }
340 #endif /* O_CLOEXEC */
341
342 if (req->cb != NULL)
343 uv_rwlock_rdlock(&req->loop->cloexec_lock);
344
345 r = mkstemp(path);
346
347 /* In case of failure `uv__cloexec` will leave error in `errno`,
348 * so it is enough to just set `r` to `-1`.
349 */
350 if (r >= 0 && uv__cloexec(r, 1) != 0) {
351 r = uv__close(r);
352 if (r != 0)
353 abort();
354 r = -1;
355 }
356
357 if (req->cb != NULL)
358 uv_rwlock_rdunlock(&req->loop->cloexec_lock);
359
360 clobber:
361 if (r < 0)
362 path[0] = '\0';
363 return r;
364 }
365
366
367 static ssize_t uv__fs_open(uv_fs_t* req) {
368 #ifdef O_CLOEXEC
369 return open(req->path, req->flags | O_CLOEXEC, req->mode);
370 #else /* O_CLOEXEC */
371 int r;
372
373 if (req->cb != NULL)
374 uv_rwlock_rdlock(&req->loop->cloexec_lock);
375
376 r = open(req->path, req->flags, req->mode);
377
378 /* In case of failure `uv__cloexec` will leave error in `errno`,
379 * so it is enough to just set `r` to `-1`.
380 */
381 if (r >= 0 && uv__cloexec(r, 1) != 0) {
382 r = uv__close(r);
383 if (r != 0)
384 abort();
385 r = -1;
386 }
387
388 if (req->cb != NULL)
389 uv_rwlock_rdunlock(&req->loop->cloexec_lock);
390
391 return r;
392 #endif /* O_CLOEXEC */
393 }
394
395
396 static ssize_t uv__preadv_or_pwritev_emul(int fd,
397 const struct iovec* bufs,
398 size_t nbufs,
399 off_t off,
400 int is_pread) {
401 ssize_t total;
402 ssize_t r;
403 size_t i;
404 size_t n;
405 void* p;
406
407 total = 0;
408 for (i = 0; i < (size_t) nbufs; i++) {
409 p = bufs[i].iov_base;
410 n = bufs[i].iov_len;
411
412 do
413 if (is_pread)
414 r = pread(fd, p, n, off);
415 else
416 r = pwrite(fd, p, n, off);
417 while (r == -1 && errno == EINTR);
418
419 if (r == -1) {
420 if (total > 0)
421 return total;
422 return -1;
423 }
424
425 off += r;
426 total += r;
427
428 if ((size_t) r < n)
429 return total;
430 }
431
432 return total;
433 }
434
435
436 #ifdef __linux__
437 typedef int uv__iovcnt;
438 #else
439 typedef size_t uv__iovcnt;
440 #endif
441
442
443 static ssize_t uv__preadv_emul(int fd,
444 const struct iovec* bufs,
445 uv__iovcnt nbufs,
446 off_t off) {
447 return uv__preadv_or_pwritev_emul(fd, bufs, nbufs, off, /*is_pread*/1);
448 }
449
450
451 static ssize_t uv__pwritev_emul(int fd,
452 const struct iovec* bufs,
453 uv__iovcnt nbufs,
454 off_t off) {
455 return uv__preadv_or_pwritev_emul(fd, bufs, nbufs, off, /*is_pread*/0);
456 }
457
458
459 /* The function pointer cache is an uintptr_t because _Atomic void*
460 * doesn't work on macos/ios/etc...
461 */
462 static ssize_t uv__preadv_or_pwritev(int fd,
463 const struct iovec* bufs,
464 size_t nbufs,
465 off_t off,
466 _Atomic uintptr_t* cache,
467 int is_pread) {
468 ssize_t (*f)(int, const struct iovec*, uv__iovcnt, off_t);
469 void* p;
470
471 p = (void*) atomic_load_explicit(cache, memory_order_relaxed);
472 if (p == NULL) {
473 #ifdef RTLD_DEFAULT
474 /* Try _LARGEFILE_SOURCE version of preadv/pwritev first,
475 * then fall back to the plain version, for libcs like musl.
476 */
477 p = dlsym(RTLD_DEFAULT, is_pread ? "preadv64" : "pwritev64");
478 if (p == NULL)
479 p = dlsym(RTLD_DEFAULT, is_pread ? "preadv" : "pwritev");
480 dlerror(); /* Clear errors. */
481 #endif /* RTLD_DEFAULT */
482 if (p == NULL)
483 p = is_pread ? uv__preadv_emul : uv__pwritev_emul;
484 atomic_store_explicit(cache, (uintptr_t) p, memory_order_relaxed);
485 }
486
487 f = p;
488 return f(fd, bufs, nbufs, off);
489 }
490
491
492 static ssize_t uv__preadv(int fd,
493 const struct iovec* bufs,
494 size_t nbufs,
495 off_t off) {
496 static _Atomic uintptr_t cache;
497 return uv__preadv_or_pwritev(fd, bufs, nbufs, off, &cache, /*is_pread*/1);
498 }
499
500
501 static ssize_t uv__pwritev(int fd,
502 const struct iovec* bufs,
503 size_t nbufs,
504 off_t off) {
505 static _Atomic uintptr_t cache;
506 return uv__preadv_or_pwritev(fd, bufs, nbufs, off, &cache, /*is_pread*/0);
507 }
508
509
510 static ssize_t uv__fs_read(uv_fs_t* req) {
511 const struct iovec* bufs;
512 unsigned int iovmax;
513 size_t nbufs;
514 ssize_t r;
515 off_t off;
516 int fd;
517
518 fd = req->file;
519 off = req->off;
520 bufs = (const struct iovec*) req->bufs;
521 nbufs = req->nbufs;
522
523 iovmax = uv__getiovmax();
524 if (nbufs > iovmax)
525 nbufs = iovmax;
526
527 r = 0;
528 if (off < 0) {
529 if (nbufs == 1)
530 r = read(fd, bufs->iov_base, bufs->iov_len);
531 else if (nbufs > 1)
532 r = readv(fd, bufs, nbufs);
533 } else {
534 if (nbufs == 1)
535 r = pread(fd, bufs->iov_base, bufs->iov_len, off);
536 else if (nbufs > 1)
537 r = uv__preadv(fd, bufs, nbufs, off);
538 }
539
540 #ifdef __PASE__
541 /* PASE returns EOPNOTSUPP when reading a directory, convert to EISDIR */
542 if (r == -1 && errno == EOPNOTSUPP) {
543 struct stat buf;
544 ssize_t rc;
545 rc = uv__fstat(fd, &buf);
546 if (rc == 0 && S_ISDIR(buf.st_mode)) {
547 errno = EISDIR;
548 }
549 }
550 #endif
551
552 /* We don't own the buffer list in the synchronous case. */
553 if (req->cb != NULL)
554 if (req->bufs != req->bufsml)
555 uv__free(req->bufs);
556
557 req->bufs = NULL;
558 req->nbufs = 0;
559
560 return r;
561 }
562
563
564 static int uv__fs_scandir_filter(const uv__dirent_t* dent) {
565 return strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0;
566 }
567
568
569 static int uv__fs_scandir_sort(const uv__dirent_t** a, const uv__dirent_t** b) {
570 return strcmp((*a)->d_name, (*b)->d_name);
571 }
572
573
574 static ssize_t uv__fs_scandir(uv_fs_t* req) {
575 uv__dirent_t** dents;
576 int n;
577
578 dents = NULL;
579 n = scandir(req->path, &dents, uv__fs_scandir_filter, uv__fs_scandir_sort);
580
581 /* NOTE: We will use nbufs as an index field */
582 req->nbufs = 0;
583
584 if (n == 0) {
585 /* OS X still needs to deallocate some memory.
586 * Memory was allocated using the system allocator, so use free() here.
587 */
588 free(dents);
589 dents = NULL;
590 } else if (n == -1) {
591 return n;
592 }
593
594 req->ptr = dents;
595
596 return n;
597 }
598
599 static int uv__fs_opendir(uv_fs_t* req) {
600 uv_dir_t* dir;
601
602 dir = uv__malloc(sizeof(*dir));
603 if (dir == NULL)
604 goto error;
605
606 dir->dir = opendir(req->path);
607 if (dir->dir == NULL)
608 goto error;
609
610 req->ptr = dir;
611 return 0;
612
613 error:
614 uv__free(dir);
615 req->ptr = NULL;
616 return -1;
617 }
618
619 static int uv__fs_readdir(uv_fs_t* req) {
620 uv_dir_t* dir;
621 uv_dirent_t* dirent;
622 struct dirent* res;
623 unsigned int dirent_idx;
624 unsigned int i;
625
626 dir = req->ptr;
627 dirent_idx = 0;
628
629 while (dirent_idx < dir->nentries) {
630 /* readdir() returns NULL on end of directory, as well as on error. errno
631 is used to differentiate between the two conditions. */
632 errno = 0;
633 res = readdir(dir->dir);
634
635 if (res == NULL) {
636 if (errno != 0)
637 goto error;
638 break;
639 }
640
641 if (strcmp(res->d_name, ".") == 0 || strcmp(res->d_name, "..") == 0)
642 continue;
643
644 dirent = &dir->dirents[dirent_idx];
645 dirent->name = uv__strdup(res->d_name);
646
647 if (dirent->name == NULL)
648 goto error;
649
650 dirent->type = uv__fs_get_dirent_type(res);
651 ++dirent_idx;
652 }
653
654 return dirent_idx;
655
656 error:
657 for (i = 0; i < dirent_idx; ++i) {
658 uv__free((char*) dir->dirents[i].name);
659 dir->dirents[i].name = NULL;
660 }
661
662 return -1;
663 }
664
665 static int uv__fs_closedir(uv_fs_t* req) {
666 uv_dir_t* dir;
667
668 dir = req->ptr;
669
670 if (dir->dir != NULL) {
671 closedir(dir->dir);
672 dir->dir = NULL;
673 }
674
675 uv__free(req->ptr);
676 req->ptr = NULL;
677 return 0;
678 }
679
680 static int uv__fs_statfs(uv_fs_t* req) {
681 uv_statfs_t* stat_fs;
682 #if defined(__sun) || \
683 defined(__MVS__) || \
684 defined(__NetBSD__) || \
685 defined(__HAIKU__) || \
686 defined(__QNX__)
687 struct statvfs buf;
688
689 if (0 != statvfs(req->path, &buf))
690 #else
691 struct statfs buf;
692
693 if (0 != statfs(req->path, &buf))
694 #endif /* defined(__sun) */
695 return -1;
696
697 stat_fs = uv__malloc(sizeof(*stat_fs));
698 if (stat_fs == NULL) {
699 errno = ENOMEM;
700 return -1;
701 }
702
703 #if defined(__sun) || \
704 defined(__MVS__) || \
705 defined(__OpenBSD__) || \
706 defined(__NetBSD__) || \
707 defined(__HAIKU__) || \
708 defined(__QNX__)
709 stat_fs->f_type = 0; /* f_type is not supported. */
710 #else
711 stat_fs->f_type = buf.f_type;
712 #endif
713 stat_fs->f_bsize = buf.f_bsize;
714 stat_fs->f_blocks = buf.f_blocks;
715 stat_fs->f_bfree = buf.f_bfree;
716 stat_fs->f_bavail = buf.f_bavail;
717 stat_fs->f_files = buf.f_files;
718 stat_fs->f_ffree = buf.f_ffree;
719 req->ptr = stat_fs;
720 return 0;
721 }
722
723 static ssize_t uv__fs_pathmax_size(const char* path) {
724 ssize_t pathmax;
725
726 pathmax = pathconf(path, _PC_PATH_MAX);
727
728 if (pathmax == -1)
729 pathmax = UV__PATH_MAX;
730
731 return pathmax;
732 }
733
734 static ssize_t uv__fs_readlink(uv_fs_t* req) {
735 ssize_t maxlen;
736 ssize_t len;
737 char* buf;
738
739 #if defined(_POSIX_PATH_MAX) || defined(PATH_MAX)
740 maxlen = uv__fs_pathmax_size(req->path);
741 #else
742 /* We may not have a real PATH_MAX. Read size of link. */
743 struct stat st;
744 int ret;
745 ret = uv__lstat(req->path, &st);
746 if (ret != 0)
747 return -1;
748 if (!S_ISLNK(st.st_mode)) {
749 errno = EINVAL;
750 return -1;
751 }
752
753 maxlen = st.st_size;
754
755 /* According to readlink(2) lstat can report st_size == 0
756 for some symlinks, such as those in /proc or /sys. */
757 if (maxlen == 0)
758 maxlen = uv__fs_pathmax_size(req->path);
759 #endif
760
761 buf = uv__malloc(maxlen);
762
763 if (buf == NULL) {
764 errno = ENOMEM;
765 return -1;
766 }
767
768 #if defined(__MVS__)
769 len = os390_readlink(req->path, buf, maxlen);
770 #else
771 len = readlink(req->path, buf, maxlen);
772 #endif
773
774 if (len == -1) {
775 uv__free(buf);
776 return -1;
777 }
778
779 /* Uncommon case: resize to make room for the trailing nul byte. */
780 if (len == maxlen) {
781 buf = uv__reallocf(buf, len + 1);
782
783 if (buf == NULL)
784 return -1;
785 }
786
787 buf[len] = '\0';
788 req->ptr = buf;
789
790 return 0;
791 }
792
793 static ssize_t uv__fs_realpath(uv_fs_t* req) {
794 char* buf;
795 char* tmp;
796
797 #if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L
798 tmp = realpath(req->path, NULL);
799 if (tmp == NULL)
800 return -1;
801 buf = uv__strdup(tmp);
802 free(tmp); /* _Not_ uv__free. */
803 if (buf == NULL) {
804 errno = ENOMEM;
805 return -1;
806 }
807 #else
808 ssize_t len;
809
810 (void)tmp;
811
812 len = uv__fs_pathmax_size(req->path);
813 buf = uv__malloc(len + 1);
814
815 if (buf == NULL) {
816 errno = ENOMEM;
817 return -1;
818 }
819
820 if (realpath(req->path, buf) == NULL) {
821 uv__free(buf);
822 return -1;
823 }
824 #endif
825
826 req->ptr = buf;
827
828 return 0;
829 }
830
831 static ssize_t uv__fs_sendfile_emul(uv_fs_t* req) {
832 struct pollfd pfd;
833 int use_pread;
834 off_t offset;
835 ssize_t nsent;
836 ssize_t nread;
837 ssize_t nwritten;
838 size_t buflen;
839 size_t len;
840 ssize_t n;
841 int in_fd;
842 int out_fd;
843 char buf[8192];
844
845 len = req->bufsml[0].len;
846 in_fd = req->flags;
847 out_fd = req->file;
848 offset = req->off;
849 use_pread = 1;
850
851 /* Here are the rules regarding errors:
852 *
853 * 1. Read errors are reported only if nsent==0, otherwise we return nsent.
854 * The user needs to know that some data has already been sent, to stop
855 * them from sending it twice.
856 *
857 * 2. Write errors are always reported. Write errors are bad because they
858 * mean data loss: we've read data but now we can't write it out.
859 *
860 * We try to use pread() and fall back to regular read() if the source fd
861 * doesn't support positional reads, for example when it's a pipe fd.
862 *
863 * If we get EAGAIN when writing to the target fd, we poll() on it until
864 * it becomes writable again.
865 *
866 * FIXME: If we get a write error when use_pread==1, it should be safe to
867 * return the number of sent bytes instead of an error because pread()
868 * is, in theory, idempotent. However, special files in /dev or /proc
869 * may support pread() but not necessarily return the same data on
870 * successive reads.
871 *
872 * FIXME: There is no way now to signal that we managed to send *some* data
873 * before a write error.
874 */
875 for (nsent = 0; (size_t) nsent < len; ) {
876 buflen = len - nsent;
877
878 if (buflen > sizeof(buf))
879 buflen = sizeof(buf);
880
881 do
882 if (use_pread)
883 nread = pread(in_fd, buf, buflen, offset);
884 else
885 nread = read(in_fd, buf, buflen);
886 while (nread == -1 && errno == EINTR);
887
888 if (nread == 0)
889 goto out;
890
891 if (nread == -1) {
892 if (use_pread && nsent == 0 && (errno == EIO || errno == ESPIPE)) {
893 use_pread = 0;
894 continue;
895 }
896
897 if (nsent == 0)
898 nsent = -1;
899
900 goto out;
901 }
902
903 for (nwritten = 0; nwritten < nread; ) {
904 do
905 n = write(out_fd, buf + nwritten, nread - nwritten);
906 while (n == -1 && errno == EINTR);
907
908 if (n != -1) {
909 nwritten += n;
910 continue;
911 }
912
913 if (errno != EAGAIN && errno != EWOULDBLOCK) {
914 nsent = -1;
915 goto out;
916 }
917
918 pfd.fd = out_fd;
919 pfd.events = POLLOUT;
920 pfd.revents = 0;
921
922 do
923 n = poll(&pfd, 1, -1);
924 while (n == -1 && errno == EINTR);
925
926 if (n == -1 || (pfd.revents & ~POLLOUT) != 0) {
927 errno = EIO;
928 nsent = -1;
929 goto out;
930 }
931 }
932
933 offset += nread;
934 nsent += nread;
935 }
936
937 out:
938 if (nsent != -1)
939 req->off = offset;
940
941 return nsent;
942 }
943
944
945 #ifdef __linux__
946 /* Pre-4.20 kernels have a bug where CephFS uses the RADOS copy-from command
947 * in copy_file_range() when it shouldn't. There is no workaround except to
948 * fall back to a regular copy.
949 */
950 static int uv__is_buggy_cephfs(int fd) {
951 struct statfs s;
952
953 if (-1 == fstatfs(fd, &s))
954 return 0;
955
956 if (s.f_type != /* CephFS */ 0xC36400)
957 return 0;
958
959 return uv__kernel_version() < /* 4.20.0 */ 0x041400;
960 }
961
962
963 static int uv__is_cifs_or_smb(int fd) {
964 struct statfs s;
965
966 if (-1 == fstatfs(fd, &s))
967 return 0;
968
969 switch ((unsigned) s.f_type) {
970 case 0x0000517Bu: /* SMB */
971 case 0xFE534D42u: /* SMB2 */
972 case 0xFF534D42u: /* CIFS */
973 return 1;
974 }
975
976 return 0;
977 }
978
979
980 static ssize_t uv__fs_try_copy_file_range(int in_fd, off_t* off,
981 int out_fd, size_t len) {
982 static _Atomic int no_copy_file_range_support;
983 ssize_t r;
984
985 if (atomic_load_explicit(&no_copy_file_range_support, memory_order_relaxed)) {
986 errno = ENOSYS;
987 return -1;
988 }
989
990 r = uv__fs_copy_file_range(in_fd, off, out_fd, NULL, len, 0);
991
992 if (r != -1)
993 return r;
994
995 switch (errno) {
996 case EACCES:
997 /* Pre-4.20 kernels have a bug where CephFS uses the RADOS
998 * copy-from command when it shouldn't.
999 */
1000 if (uv__is_buggy_cephfs(in_fd))
1001 errno = ENOSYS; /* Use fallback. */
1002 break;
1003 case ENOSYS:
1004 atomic_store_explicit(&no_copy_file_range_support, 1, memory_order_relaxed);
1005 break;
1006 case EPERM:
1007 /* It's been reported that CIFS spuriously fails.
1008 * Consider it a transient error.
1009 */
1010 if (uv__is_cifs_or_smb(out_fd))
1011 errno = ENOSYS; /* Use fallback. */
1012 break;
1013 case ENOTSUP:
1014 case EXDEV:
1015 /* ENOTSUP - it could work on another file system type.
1016 * EXDEV - it will not work when in_fd and out_fd are not on the same
1017 * mounted filesystem (pre Linux 5.3)
1018 */
1019 errno = ENOSYS; /* Use fallback. */
1020 break;
1021 }
1022
1023 return -1;
1024 }
1025
1026 #endif /* __linux__ */
1027
1028
1029 static ssize_t uv__fs_sendfile(uv_fs_t* req) {
1030 int in_fd;
1031 int out_fd;
1032
1033 in_fd = req->flags;
1034 out_fd = req->file;
1035
1036 #if defined(__linux__) || defined(__sun)
1037 {
1038 off_t off;
1039 ssize_t r;
1040 size_t len;
1041 int try_sendfile;
1042
1043 off = req->off;
1044 len = req->bufsml[0].len;
1045 try_sendfile = 1;
1046
1047 #ifdef __linux__
1048 r = uv__fs_try_copy_file_range(in_fd, &off, out_fd, len);
1049 try_sendfile = (r == -1 && errno == ENOSYS);
1050 #endif
1051
1052 if (try_sendfile)
1053 r = sendfile(out_fd, in_fd, &off, len);
1054
1055 /* sendfile() on SunOS returns EINVAL if the target fd is not a socket but
1056 * it still writes out data. Fortunately, we can detect it by checking if
1057 * the offset has been updated.
1058 */
1059 if (r != -1 || off > req->off) {
1060 r = off - req->off;
1061 req->off = off;
1062 return r;
1063 }
1064
1065 if (errno == EINVAL ||
1066 errno == EIO ||
1067 errno == ENOTSOCK ||
1068 errno == EXDEV) {
1069 errno = 0;
1070 return uv__fs_sendfile_emul(req);
1071 }
1072
1073 return -1;
1074 }
1075 /* sendfile() on iOS(arm64) will throw SIGSYS signal cause crash. */
1076 #elif (defined(__APPLE__) && !TARGET_OS_IPHONE) \
1077 || defined(__DragonFly__) \
1078 || defined(__FreeBSD__)
1079 {
1080 off_t len;
1081 ssize_t r;
1082
1083 /* sendfile() on FreeBSD and Darwin returns EAGAIN if the target fd is in
1084 * non-blocking mode and not all data could be written. If a non-zero
1085 * number of bytes have been sent, we don't consider it an error.
1086 */
1087
1088 #if defined(__FreeBSD__) || defined(__DragonFly__)
1089 #if defined(__FreeBSD__)
1090 off_t off;
1091
1092 off = req->off;
1093 r = uv__fs_copy_file_range(in_fd, &off, out_fd, NULL, req->bufsml[0].len, 0);
1094 if (r >= 0) {
1095 r = off - req->off;
1096 req->off = off;
1097 return r;
1098 }
1099 #endif
1100 len = 0;
1101 r = sendfile(in_fd, out_fd, req->off, req->bufsml[0].len, NULL, &len, 0);
1102 #else
1103 /* The darwin sendfile takes len as an input for the length to send,
1104 * so make sure to initialize it with the caller's value. */
1105 len = req->bufsml[0].len;
1106 r = sendfile(in_fd, out_fd, req->off, &len, NULL, 0);
1107 #endif
1108
1109 /*
1110 * The man page for sendfile(2) on DragonFly states that `len` contains
1111 * a meaningful value ONLY in case of EAGAIN and EINTR.
1112 * Nothing is said about it's value in case of other errors, so better
1113 * not depend on the potential wrong assumption that is was not modified
1114 * by the syscall.
1115 */
1116 if (r == 0 || ((errno == EAGAIN || errno == EINTR) && len != 0)) {
1117 req->off += len;
1118 return (ssize_t) len;
1119 }
1120
1121 if (errno == EINVAL ||
1122 errno == EIO ||
1123 errno == ENOTSOCK ||
1124 errno == EXDEV) {
1125 errno = 0;
1126 return uv__fs_sendfile_emul(req);
1127 }
1128
1129 return -1;
1130 }
1131 #else
1132 /* Squelch compiler warnings. */
1133 (void) &in_fd;
1134 (void) &out_fd;
1135
1136 return uv__fs_sendfile_emul(req);
1137 #endif
1138 }
1139
1140
1141 static ssize_t uv__fs_utime(uv_fs_t* req) {
1142 #if defined(__APPLE__) \
1143 || defined(_AIX71) \
1144 || defined(__DragonFly__) \
1145 || defined(__FreeBSD__) \
1146 || defined(__HAIKU__) \
1147 || defined(__NetBSD__) \
1148 || defined(__OpenBSD__) \
1149 || defined(__linux__) \
1150 || defined(__sun)
1151 struct timespec ts[2];
1152 ts[0] = uv__fs_to_timespec(req->atime);
1153 ts[1] = uv__fs_to_timespec(req->mtime);
1154 return utimensat(AT_FDCWD, req->path, ts, 0);
1155 #elif defined(_AIX) && !defined(_AIX71)
1156 struct utimbuf buf;
1157 buf.actime = req->atime;
1158 buf.modtime = req->mtime;
1159 return utime(req->path, &buf);
1160 #elif defined(__MVS__)
1161 attrib_t atr;
1162 memset(&atr, 0, sizeof(atr));
1163 atr.att_mtimechg = 1;
1164 atr.att_atimechg = 1;
1165 atr.att_mtime = req->mtime;
1166 atr.att_atime = req->atime;
1167 return __lchattr((char*) req->path, &atr, sizeof(atr));
1168 #else
1169 errno = ENOSYS;
1170 return -1;
1171 #endif
1172 }
1173
1174
1175 static ssize_t uv__fs_lutime(uv_fs_t* req) {
1176 #if defined(__APPLE__) \
1177 || defined(_AIX71) \
1178 || defined(__DragonFly__) \
1179 || defined(__FreeBSD__) \
1180 || defined(__HAIKU__) \
1181 || defined(__NetBSD__) \
1182 || defined(__OpenBSD__) \
1183 || defined(__linux__) \
1184 || defined(__sun)
1185 struct timespec ts[2];
1186 ts[0] = uv__fs_to_timespec(req->atime);
1187 ts[1] = uv__fs_to_timespec(req->mtime);
1188 return utimensat(AT_FDCWD, req->path, ts, AT_SYMLINK_NOFOLLOW);
1189 #else
1190 errno = ENOSYS;
1191 return -1;
1192 #endif
1193 }
1194
1195
1196 static ssize_t uv__fs_write(uv_fs_t* req) {
1197 const struct iovec* bufs;
1198 size_t nbufs;
1199 ssize_t r;
1200 off_t off;
1201 int fd;
1202
1203 fd = req->file;
1204 off = req->off;
1205 bufs = (const struct iovec*) req->bufs;
1206 nbufs = req->nbufs;
1207
1208 r = 0;
1209 if (off < 0) {
1210 if (nbufs == 1)
1211 r = write(fd, bufs->iov_base, bufs->iov_len);
1212 else if (nbufs > 1)
1213 r = writev(fd, bufs, nbufs);
1214 } else {
1215 if (nbufs == 1)
1216 r = pwrite(fd, bufs->iov_base, bufs->iov_len, off);
1217 else if (nbufs > 1)
1218 r = uv__pwritev(fd, bufs, nbufs, off);
1219 }
1220
1221 return r;
1222 }
1223
1224
1225 static ssize_t uv__fs_copyfile(uv_fs_t* req) {
1226 uv_fs_t fs_req;
1227 uv_file srcfd;
1228 uv_file dstfd;
1229 struct stat src_statsbuf;
1230 struct stat dst_statsbuf;
1231 struct timespec times[2];
1232 int dst_flags;
1233 int result;
1234 int err;
1235 off_t bytes_to_send;
1236 off_t in_offset;
1237 off_t bytes_written;
1238 size_t bytes_chunk;
1239
1240 dstfd = -1;
1241 err = 0;
1242
1243 /* Open the source file. */
1244 srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL);
1245 uv_fs_req_cleanup(&fs_req);
1246
1247 if (srcfd < 0)
1248 return srcfd;
1249
1250 /* Get the source file's mode. */
1251 if (uv__fstat(srcfd, &src_statsbuf)) {
1252 err = UV__ERR(errno);
1253 goto out;
1254 }
1255
1256 dst_flags = O_WRONLY | O_CREAT;
1257
1258 if (req->flags & UV_FS_COPYFILE_EXCL)
1259 dst_flags |= O_EXCL;
1260
1261 /* Open the destination file. */
1262 dstfd = uv_fs_open(NULL,
1263 &fs_req,
1264 req->new_path,
1265 dst_flags,
1266 src_statsbuf.st_mode,
1267 NULL);
1268 uv_fs_req_cleanup(&fs_req);
1269
1270 if (dstfd < 0) {
1271 err = dstfd;
1272 goto out;
1273 }
1274
1275 /* If the file is not being opened exclusively, verify that the source and
1276 destination are not the same file. If they are the same, bail out early. */
1277 if ((req->flags & UV_FS_COPYFILE_EXCL) == 0) {
1278 /* Get the destination file's mode. */
1279 if (uv__fstat(dstfd, &dst_statsbuf)) {
1280 err = UV__ERR(errno);
1281 goto out;
1282 }
1283
1284 /* Check if srcfd and dstfd refer to the same file */
1285 if (src_statsbuf.st_dev == dst_statsbuf.st_dev &&
1286 src_statsbuf.st_ino == dst_statsbuf.st_ino) {
1287 goto out;
1288 }
1289
1290 /* Truncate the file in case the destination already existed. */
1291 if (ftruncate(dstfd, 0) != 0) {
1292 err = UV__ERR(errno);
1293
1294 /* ftruncate() on ceph-fuse fails with EACCES when the file is created
1295 * with read only permissions. Since ftruncate() on a newly created
1296 * file is a meaningless operation anyway, detect that condition
1297 * and squelch the error.
1298 */
1299 if (err != UV_EACCES)
1300 goto out;
1301
1302 if (dst_statsbuf.st_size > 0)
1303 goto out;
1304
1305 err = 0;
1306 }
1307 }
1308
1309 /**
1310 * Change the timestamps of the destination file to match the source file.
1311 */
1312 #if defined(__APPLE__)
1313 times[0] = src_statsbuf.st_atimespec;
1314 times[1] = src_statsbuf.st_mtimespec;
1315 #elif defined(_AIX)
1316 times[0].tv_sec = src_statsbuf.st_atime;
1317 times[0].tv_nsec = src_statsbuf.st_atime_n;
1318 times[1].tv_sec = src_statsbuf.st_mtime;
1319 times[1].tv_nsec = src_statsbuf.st_mtime_n;
1320 #else
1321 times[0] = src_statsbuf.st_atim;
1322 times[1] = src_statsbuf.st_mtim;
1323 #endif
1324
1325 if (futimens(dstfd, times) == -1) {
1326 err = UV__ERR(errno);
1327 goto out;
1328 }
1329
1330 /*
1331 * Change the ownership and permissions of the destination file to match the
1332 * source file.
1333 * `cp -p` does not care about errors here, so we don't either. Reuse the
1334 * `result` variable to silence a -Wunused-result warning.
1335 */
1336 result = fchown(dstfd, src_statsbuf.st_uid, src_statsbuf.st_gid);
1337
1338 if (fchmod(dstfd, src_statsbuf.st_mode) == -1) {
1339 err = UV__ERR(errno);
1340 #ifdef __linux__
1341 /* fchmod() on CIFS shares always fails with EPERM unless the share is
1342 * mounted with "noperm". As fchmod() is a meaningless operation on such
1343 * shares anyway, detect that condition and squelch the error.
1344 */
1345 if (err != UV_EPERM)
1346 goto out;
1347
1348 if (!uv__is_cifs_or_smb(dstfd))
1349 goto out;
1350
1351 err = 0;
1352 #else /* !__linux__ */
1353 goto out;
1354 #endif /* !__linux__ */
1355 }
1356
1357 #ifdef FICLONE
1358 if (req->flags & UV_FS_COPYFILE_FICLONE ||
1359 req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1360 if (ioctl(dstfd, FICLONE, srcfd) == 0) {
1361 /* ioctl() with FICLONE succeeded. */
1362 goto out;
1363 }
1364 /* If an error occurred and force was set, return the error to the caller;
1365 * fall back to sendfile() when force was not set. */
1366 if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1367 err = UV__ERR(errno);
1368 goto out;
1369 }
1370 }
1371 #else
1372 if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1373 err = UV_ENOSYS;
1374 goto out;
1375 }
1376 #endif
1377
1378 bytes_to_send = src_statsbuf.st_size;
1379 in_offset = 0;
1380 while (bytes_to_send != 0) {
1381 bytes_chunk = SSIZE_MAX;
1382 if (bytes_to_send < (off_t) bytes_chunk)
1383 bytes_chunk = bytes_to_send;
1384 uv_fs_sendfile(NULL, &fs_req, dstfd, srcfd, in_offset, bytes_chunk, NULL);
1385 bytes_written = fs_req.result;
1386 uv_fs_req_cleanup(&fs_req);
1387
1388 if (bytes_written < 0) {
1389 err = bytes_written;
1390 break;
1391 }
1392
1393 bytes_to_send -= bytes_written;
1394 in_offset += bytes_written;
1395 }
1396
1397 out:
1398 if (err < 0)
1399 result = err;
1400 else
1401 result = 0;
1402
1403 /* Close the source file. */
1404 err = uv__close_nocheckstdio(srcfd);
1405
1406 /* Don't overwrite any existing errors. */
1407 if (err != 0 && result == 0)
1408 result = err;
1409
1410 /* Close the destination file if it is open. */
1411 if (dstfd >= 0) {
1412 err = uv__close_nocheckstdio(dstfd);
1413
1414 /* Don't overwrite any existing errors. */
1415 if (err != 0 && result == 0)
1416 result = err;
1417
1418 /* Remove the destination file if something went wrong. */
1419 if (result != 0) {
1420 uv_fs_unlink(NULL, &fs_req, req->new_path, NULL);
1421 /* Ignore the unlink return value, as an error already happened. */
1422 uv_fs_req_cleanup(&fs_req);
1423 }
1424 }
1425
1426 if (result == 0)
1427 return 0;
1428
1429 errno = UV__ERR(result);
1430 return -1;
1431 }
1432
1433 static void uv__to_stat(struct stat* src, uv_stat_t* dst) {
1434 dst->st_dev = src->st_dev;
1435 dst->st_mode = src->st_mode;
1436 dst->st_nlink = src->st_nlink;
1437 dst->st_uid = src->st_uid;
1438 dst->st_gid = src->st_gid;
1439 dst->st_rdev = src->st_rdev;
1440 dst->st_ino = src->st_ino;
1441 dst->st_size = src->st_size;
1442 dst->st_blksize = src->st_blksize;
1443 dst->st_blocks = src->st_blocks;
1444
1445 #if defined(__APPLE__)
1446 dst->st_atim.tv_sec = src->st_atimespec.tv_sec;
1447 dst->st_atim.tv_nsec = src->st_atimespec.tv_nsec;
1448 dst->st_mtim.tv_sec = src->st_mtimespec.tv_sec;
1449 dst->st_mtim.tv_nsec = src->st_mtimespec.tv_nsec;
1450 dst->st_ctim.tv_sec = src->st_ctimespec.tv_sec;
1451 dst->st_ctim.tv_nsec = src->st_ctimespec.tv_nsec;
1452 dst->st_birthtim.tv_sec = src->st_birthtimespec.tv_sec;
1453 dst->st_birthtim.tv_nsec = src->st_birthtimespec.tv_nsec;
1454 dst->st_flags = src->st_flags;
1455 dst->st_gen = src->st_gen;
1456 #elif defined(__ANDROID__)
1457 dst->st_atim.tv_sec = src->st_atime;
1458 dst->st_atim.tv_nsec = src->st_atimensec;
1459 dst->st_mtim.tv_sec = src->st_mtime;
1460 dst->st_mtim.tv_nsec = src->st_mtimensec;
1461 dst->st_ctim.tv_sec = src->st_ctime;
1462 dst->st_ctim.tv_nsec = src->st_ctimensec;
1463 dst->st_birthtim.tv_sec = src->st_ctime;
1464 dst->st_birthtim.tv_nsec = src->st_ctimensec;
1465 dst->st_flags = 0;
1466 dst->st_gen = 0;
1467 #elif !defined(_AIX) && \
1468 !defined(__MVS__) && ( \
1469 defined(__DragonFly__) || \
1470 defined(__FreeBSD__) || \
1471 defined(__OpenBSD__) || \
1472 defined(__NetBSD__) || \
1473 defined(_GNU_SOURCE) || \
1474 defined(_BSD_SOURCE) || \
1475 defined(_SVID_SOURCE) || \
1476 defined(_XOPEN_SOURCE) || \
1477 defined(_DEFAULT_SOURCE))
1478 dst->st_atim.tv_sec = src->st_atim.tv_sec;
1479 dst->st_atim.tv_nsec = src->st_atim.tv_nsec;
1480 dst->st_mtim.tv_sec = src->st_mtim.tv_sec;
1481 dst->st_mtim.tv_nsec = src->st_mtim.tv_nsec;
1482 dst->st_ctim.tv_sec = src->st_ctim.tv_sec;
1483 dst->st_ctim.tv_nsec = src->st_ctim.tv_nsec;
1484 # if defined(__FreeBSD__) || \
1485 defined(__NetBSD__)
1486 dst->st_birthtim.tv_sec = src->st_birthtim.tv_sec;
1487 dst->st_birthtim.tv_nsec = src->st_birthtim.tv_nsec;
1488 dst->st_flags = src->st_flags;
1489 dst->st_gen = src->st_gen;
1490 # else
1491 dst->st_birthtim.tv_sec = src->st_ctim.tv_sec;
1492 dst->st_birthtim.tv_nsec = src->st_ctim.tv_nsec;
1493 dst->st_flags = 0;
1494 dst->st_gen = 0;
1495 # endif
1496 #else
1497 dst->st_atim.tv_sec = src->st_atime;
1498 dst->st_atim.tv_nsec = 0;
1499 dst->st_mtim.tv_sec = src->st_mtime;
1500 dst->st_mtim.tv_nsec = 0;
1501 dst->st_ctim.tv_sec = src->st_ctime;
1502 dst->st_ctim.tv_nsec = 0;
1503 dst->st_birthtim.tv_sec = src->st_ctime;
1504 dst->st_birthtim.tv_nsec = 0;
1505 dst->st_flags = 0;
1506 dst->st_gen = 0;
1507 #endif
1508 }
1509
1510
1511 static int uv__fs_statx(int fd,
1512 const char* path,
1513 int is_fstat,
1514 int is_lstat,
1515 uv_stat_t* buf) {
1516 STATIC_ASSERT(UV_ENOSYS != -1);
1517 #ifdef __linux__
1518 static _Atomic int no_statx;
1519 struct uv__statx statxbuf;
1520 int dirfd;
1521 int flags;
1522 int mode;
1523 int rc;
1524
1525 if (atomic_load_explicit(&no_statx, memory_order_relaxed))
1526 return UV_ENOSYS;
1527
1528 dirfd = AT_FDCWD;
1529 flags = 0; /* AT_STATX_SYNC_AS_STAT */
1530 mode = 0xFFF; /* STATX_BASIC_STATS + STATX_BTIME */
1531
1532 if (is_fstat) {
1533 dirfd = fd;
1534 flags |= 0x1000; /* AT_EMPTY_PATH */
1535 }
1536
1537 if (is_lstat)
1538 flags |= AT_SYMLINK_NOFOLLOW;
1539
1540 rc = uv__statx(dirfd, path, flags, mode, &statxbuf);
1541
1542 switch (rc) {
1543 case 0:
1544 break;
1545 case -1:
1546 /* EPERM happens when a seccomp filter rejects the system call.
1547 * Has been observed with libseccomp < 2.3.3 and docker < 18.04.
1548 * EOPNOTSUPP is used on DVS exported filesystems
1549 */
1550 if (errno != EINVAL && errno != EPERM && errno != ENOSYS && errno != EOPNOTSUPP)
1551 return -1;
1552 /* Fall through. */
1553 default:
1554 /* Normally on success, zero is returned and On error, -1 is returned.
1555 * Observed on S390 RHEL running in a docker container with statx not
1556 * implemented, rc might return 1 with 0 set as the error code in which
1557 * case we return ENOSYS.
1558 */
1559 atomic_store_explicit(&no_statx, 1, memory_order_relaxed);
1560 return UV_ENOSYS;
1561 }
1562
1563 uv__statx_to_stat(&statxbuf, buf);
1564
1565 return 0;
1566 #else
1567 return UV_ENOSYS;
1568 #endif /* __linux__ */
1569 }
1570
1571
1572 static int uv__fs_stat(const char *path, uv_stat_t *buf) {
1573 struct stat pbuf;
1574 int ret;
1575
1576 ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 0, buf);
1577 if (ret != UV_ENOSYS)
1578 return ret;
1579
1580 ret = uv__stat(path, &pbuf);
1581 if (ret == 0)
1582 uv__to_stat(&pbuf, buf);
1583
1584 return ret;
1585 }
1586
1587
1588 static int uv__fs_lstat(const char *path, uv_stat_t *buf) {
1589 struct stat pbuf;
1590 int ret;
1591
1592 ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 1, buf);
1593 if (ret != UV_ENOSYS)
1594 return ret;
1595
1596 ret = uv__lstat(path, &pbuf);
1597 if (ret == 0)
1598 uv__to_stat(&pbuf, buf);
1599
1600 return ret;
1601 }
1602
1603
1604 static int uv__fs_fstat(int fd, uv_stat_t *buf) {
1605 struct stat pbuf;
1606 int ret;
1607
1608 ret = uv__fs_statx(fd, "", /* is_fstat */ 1, /* is_lstat */ 0, buf);
1609 if (ret != UV_ENOSYS)
1610 return ret;
1611
1612 ret = uv__fstat(fd, &pbuf);
1613 if (ret == 0)
1614 uv__to_stat(&pbuf, buf);
1615
1616 return ret;
1617 }
1618
1619 static size_t uv__fs_buf_offset(uv_buf_t* bufs, size_t size) {
1620 size_t offset;
1621 /* Figure out which bufs are done */
1622 for (offset = 0; size > 0 && bufs[offset].len <= size; ++offset)
1623 size -= bufs[offset].len;
1624
1625 /* Fix a partial read/write */
1626 if (size > 0) {
1627 bufs[offset].base += size;
1628 bufs[offset].len -= size;
1629 }
1630 return offset;
1631 }
1632
1633 static ssize_t uv__fs_write_all(uv_fs_t* req) {
1634 unsigned int iovmax;
1635 unsigned int nbufs;
1636 uv_buf_t* bufs;
1637 ssize_t total;
1638 ssize_t result;
1639
1640 iovmax = uv__getiovmax();
1641 nbufs = req->nbufs;
1642 bufs = req->bufs;
1643 total = 0;
1644
1645 while (nbufs > 0) {
1646 req->nbufs = nbufs;
1647 if (req->nbufs > iovmax)
1648 req->nbufs = iovmax;
1649
1650 do
1651 result = uv__fs_write(req);
1652 while (result < 0 && errno == EINTR);
1653
1654 if (result <= 0) {
1655 if (total == 0)
1656 total = result;
1657 break;
1658 }
1659
1660 if (req->off >= 0)
1661 req->off += result;
1662
1663 req->nbufs = uv__fs_buf_offset(req->bufs, result);
1664 req->bufs += req->nbufs;
1665 nbufs -= req->nbufs;
1666 total += result;
1667 }
1668
1669 if (bufs != req->bufsml)
1670 uv__free(bufs);
1671
1672 req->bufs = NULL;
1673 req->nbufs = 0;
1674
1675 return total;
1676 }
1677
1678
1679 static void uv__fs_work(struct uv__work* w) {
1680 int retry_on_eintr;
1681 uv_fs_t* req;
1682 ssize_t r;
1683
1684 req = container_of(w, uv_fs_t, work_req);
1685 retry_on_eintr = !(req->fs_type == UV_FS_CLOSE ||
1686 req->fs_type == UV_FS_READ);
1687
1688 do {
1689 errno = 0;
1690
1691 #define X(type, action) \
1692 case UV_FS_ ## type: \
1693 r = action; \
1694 break;
1695
1696 switch (req->fs_type) {
1697 X(ACCESS, access(req->path, req->flags));
1698 X(CHMOD, chmod(req->path, req->mode));
1699 X(CHOWN, chown(req->path, req->uid, req->gid));
1700 X(CLOSE, uv__fs_close(req->file));
1701 X(COPYFILE, uv__fs_copyfile(req));
1702 X(FCHMOD, fchmod(req->file, req->mode));
1703 X(FCHOWN, fchown(req->file, req->uid, req->gid));
1704 X(LCHOWN, lchown(req->path, req->uid, req->gid));
1705 X(FDATASYNC, uv__fs_fdatasync(req));
1706 X(FSTAT, uv__fs_fstat(req->file, &req->statbuf));
1707 X(FSYNC, uv__fs_fsync(req));
1708 X(FTRUNCATE, ftruncate(req->file, req->off));
1709 X(FUTIME, uv__fs_futime(req));
1710 X(LUTIME, uv__fs_lutime(req));
1711 X(LSTAT, uv__fs_lstat(req->path, &req->statbuf));
1712 X(LINK, link(req->path, req->new_path));
1713 X(MKDIR, mkdir(req->path, req->mode));
1714 X(MKDTEMP, uv__fs_mkdtemp(req));
1715 X(MKSTEMP, uv__fs_mkstemp(req));
1716 X(OPEN, uv__fs_open(req));
1717 X(READ, uv__fs_read(req));
1718 X(SCANDIR, uv__fs_scandir(req));
1719 X(OPENDIR, uv__fs_opendir(req));
1720 X(READDIR, uv__fs_readdir(req));
1721 X(CLOSEDIR, uv__fs_closedir(req));
1722 X(READLINK, uv__fs_readlink(req));
1723 X(REALPATH, uv__fs_realpath(req));
1724 X(RENAME, rename(req->path, req->new_path));
1725 X(RMDIR, rmdir(req->path));
1726 X(SENDFILE, uv__fs_sendfile(req));
1727 X(STAT, uv__fs_stat(req->path, &req->statbuf));
1728 X(STATFS, uv__fs_statfs(req));
1729 X(SYMLINK, symlink(req->path, req->new_path));
1730 X(UNLINK, unlink(req->path));
1731 X(UTIME, uv__fs_utime(req));
1732 X(WRITE, uv__fs_write_all(req));
1733 default: abort();
1734 }
1735 #undef X
1736 } while (r == -1 && errno == EINTR && retry_on_eintr);
1737
1738 if (r == -1)
1739 req->result = UV__ERR(errno);
1740 else
1741 req->result = r;
1742
1743 if (r == 0 && (req->fs_type == UV_FS_STAT ||
1744 req->fs_type == UV_FS_FSTAT ||
1745 req->fs_type == UV_FS_LSTAT)) {
1746 req->ptr = &req->statbuf;
1747 }
1748 }
1749
1750
1751 static void uv__fs_done(struct uv__work* w, int status) {
1752 uv_fs_t* req;
1753
1754 req = container_of(w, uv_fs_t, work_req);
1755 uv__req_unregister(req->loop);
1756
1757 if (status == UV_ECANCELED) {
1758 assert(req->result == 0);
1759 req->result = UV_ECANCELED;
1760 }
1761
1762 req->cb(req);
1763 }
1764
1765
1766 void uv__fs_post(uv_loop_t* loop, uv_fs_t* req) {
1767 uv__req_register(loop);
1768 uv__work_submit(loop,
1769 &req->work_req,
1770 UV__WORK_FAST_IO,
1771 uv__fs_work,
1772 uv__fs_done);
1773 }
1774
1775
1776 int uv_fs_access(uv_loop_t* loop,
1777 uv_fs_t* req,
1778 const char* path,
1779 int flags,
1780 uv_fs_cb cb) {
1781 INIT(ACCESS);
1782 PATH;
1783 req->flags = flags;
1784 POST;
1785 }
1786
1787
1788 int uv_fs_chmod(uv_loop_t* loop,
1789 uv_fs_t* req,
1790 const char* path,
1791 int mode,
1792 uv_fs_cb cb) {
1793 INIT(CHMOD);
1794 PATH;
1795 req->mode = mode;
1796 POST;
1797 }
1798
1799
1800 int uv_fs_chown(uv_loop_t* loop,
1801 uv_fs_t* req,
1802 const char* path,
1803 uv_uid_t uid,
1804 uv_gid_t gid,
1805 uv_fs_cb cb) {
1806 INIT(CHOWN);
1807 PATH;
1808 req->uid = uid;
1809 req->gid = gid;
1810 POST;
1811 }
1812
1813
1814 int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1815 INIT(CLOSE);
1816 req->file = file;
1817 if (cb != NULL)
1818 if (uv__iou_fs_close(loop, req))
1819 return 0;
1820 POST;
1821 }
1822
1823
1824 int uv_fs_fchmod(uv_loop_t* loop,
1825 uv_fs_t* req,
1826 uv_file file,
1827 int mode,
1828 uv_fs_cb cb) {
1829 INIT(FCHMOD);
1830 req->file = file;
1831 req->mode = mode;
1832 POST;
1833 }
1834
1835
1836 int uv_fs_fchown(uv_loop_t* loop,
1837 uv_fs_t* req,
1838 uv_file file,
1839 uv_uid_t uid,
1840 uv_gid_t gid,
1841 uv_fs_cb cb) {
1842 INIT(FCHOWN);
1843 req->file = file;
1844 req->uid = uid;
1845 req->gid = gid;
1846 POST;
1847 }
1848
1849
1850 int uv_fs_lchown(uv_loop_t* loop,
1851 uv_fs_t* req,
1852 const char* path,
1853 uv_uid_t uid,
1854 uv_gid_t gid,
1855 uv_fs_cb cb) {
1856 INIT(LCHOWN);
1857 PATH;
1858 req->uid = uid;
1859 req->gid = gid;
1860 POST;
1861 }
1862
1863
1864 int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1865 INIT(FDATASYNC);
1866 req->file = file;
1867 if (cb != NULL)
1868 if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* IORING_FSYNC_DATASYNC */ 1))
1869 return 0;
1870 POST;
1871 }
1872
1873
1874 int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1875 INIT(FSTAT);
1876 req->file = file;
1877 if (cb != NULL)
1878 if (uv__iou_fs_statx(loop, req, /* is_fstat */ 1, /* is_lstat */ 0))
1879 return 0;
1880 POST;
1881 }
1882
1883
1884 int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1885 INIT(FSYNC);
1886 req->file = file;
1887 if (cb != NULL)
1888 if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* no flags */ 0))
1889 return 0;
1890 POST;
1891 }
1892
1893
1894 int uv_fs_ftruncate(uv_loop_t* loop,
1895 uv_fs_t* req,
1896 uv_file file,
1897 int64_t off,
1898 uv_fs_cb cb) {
1899 INIT(FTRUNCATE);
1900 req->file = file;
1901 req->off = off;
1902 if (cb != NULL)
1903 if (uv__iou_fs_ftruncate(loop, req))
1904 return 0;
1905 POST;
1906 }
1907
1908
1909 int uv_fs_futime(uv_loop_t* loop,
1910 uv_fs_t* req,
1911 uv_file file,
1912 double atime,
1913 double mtime,
1914 uv_fs_cb cb) {
1915 INIT(FUTIME);
1916 req->file = file;
1917 req->atime = atime;
1918 req->mtime = mtime;
1919 POST;
1920 }
1921
1922 int uv_fs_lutime(uv_loop_t* loop,
1923 uv_fs_t* req,
1924 const char* path,
1925 double atime,
1926 double mtime,
1927 uv_fs_cb cb) {
1928 INIT(LUTIME);
1929 PATH;
1930 req->atime = atime;
1931 req->mtime = mtime;
1932 POST;
1933 }
1934
1935
1936 int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
1937 INIT(LSTAT);
1938 PATH;
1939 if (cb != NULL)
1940 if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 1))
1941 return 0;
1942 POST;
1943 }
1944
1945
1946 int uv_fs_link(uv_loop_t* loop,
1947 uv_fs_t* req,
1948 const char* path,
1949 const char* new_path,
1950 uv_fs_cb cb) {
1951 INIT(LINK);
1952 PATH2;
1953 if (cb != NULL)
1954 if (uv__iou_fs_link(loop, req))
1955 return 0;
1956 POST;
1957 }
1958
1959
1960 int uv_fs_mkdir(uv_loop_t* loop,
1961 uv_fs_t* req,
1962 const char* path,
1963 int mode,
1964 uv_fs_cb cb) {
1965 INIT(MKDIR);
1966 PATH;
1967 req->mode = mode;
1968 if (cb != NULL)
1969 if (uv__iou_fs_mkdir(loop, req))
1970 return 0;
1971 POST;
1972 }
1973
1974
1975 int uv_fs_mkdtemp(uv_loop_t* loop,
1976 uv_fs_t* req,
1977 const char* tpl,
1978 uv_fs_cb cb) {
1979 INIT(MKDTEMP);
1980 req->path = uv__strdup(tpl);
1981 if (req->path == NULL)
1982 return UV_ENOMEM;
1983 POST;
1984 }
1985
1986
1987 int uv_fs_mkstemp(uv_loop_t* loop,
1988 uv_fs_t* req,
1989 const char* tpl,
1990 uv_fs_cb cb) {
1991 INIT(MKSTEMP);
1992 req->path = uv__strdup(tpl);
1993 if (req->path == NULL)
1994 return UV_ENOMEM;
1995 POST;
1996 }
1997
1998
1999 int uv_fs_open(uv_loop_t* loop,
2000 uv_fs_t* req,
2001 const char* path,
2002 int flags,
2003 int mode,
2004 uv_fs_cb cb) {
2005 INIT(OPEN);
2006 PATH;
2007 req->flags = flags;
2008 req->mode = mode;
2009 if (cb != NULL)
2010 if (uv__iou_fs_open(loop, req))
2011 return 0;
2012 POST;
2013 }
2014
2015
2016 int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
2017 uv_file file,
2018 const uv_buf_t bufs[],
2019 unsigned int nbufs,
2020 int64_t off,
2021 uv_fs_cb cb) {
2022 INIT(READ);
2023
2024 if (bufs == NULL || nbufs == 0)
2025 return UV_EINVAL;
2026
2027 req->off = off;
2028 req->file = file;
2029 req->bufs = (uv_buf_t*) bufs; /* Safe, doesn't mutate |bufs| */
2030 req->nbufs = nbufs;
2031
2032 if (cb == NULL)
2033 goto post;
2034
2035 req->bufs = req->bufsml;
2036 if (nbufs > ARRAY_SIZE(req->bufsml))
2037 req->bufs = uv__malloc(nbufs * sizeof(*bufs));
2038
2039 if (req->bufs == NULL)
2040 return UV_ENOMEM;
2041
2042 memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
2043
2044 if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 1))
2045 return 0;
2046
2047 post:
2048 POST;
2049 }
2050
2051
2052 int uv_fs_scandir(uv_loop_t* loop,
2053 uv_fs_t* req,
2054 const char* path,
2055 int flags,
2056 uv_fs_cb cb) {
2057 INIT(SCANDIR);
2058 PATH;
2059 req->flags = flags;
2060 POST;
2061 }
2062
2063 int uv_fs_opendir(uv_loop_t* loop,
2064 uv_fs_t* req,
2065 const char* path,
2066 uv_fs_cb cb) {
2067 INIT(OPENDIR);
2068 PATH;
2069 POST;
2070 }
2071
2072 int uv_fs_readdir(uv_loop_t* loop,
2073 uv_fs_t* req,
2074 uv_dir_t* dir,
2075 uv_fs_cb cb) {
2076 INIT(READDIR);
2077
2078 if (dir == NULL || dir->dir == NULL || dir->dirents == NULL)
2079 return UV_EINVAL;
2080
2081 req->ptr = dir;
2082 POST;
2083 }
2084
2085 int uv_fs_closedir(uv_loop_t* loop,
2086 uv_fs_t* req,
2087 uv_dir_t* dir,
2088 uv_fs_cb cb) {
2089 INIT(CLOSEDIR);
2090
2091 if (dir == NULL)
2092 return UV_EINVAL;
2093
2094 req->ptr = dir;
2095 POST;
2096 }
2097
2098 int uv_fs_readlink(uv_loop_t* loop,
2099 uv_fs_t* req,
2100 const char* path,
2101 uv_fs_cb cb) {
2102 INIT(READLINK);
2103 PATH;
2104 POST;
2105 }
2106
2107
2108 int uv_fs_realpath(uv_loop_t* loop,
2109 uv_fs_t* req,
2110 const char * path,
2111 uv_fs_cb cb) {
2112 INIT(REALPATH);
2113 PATH;
2114 POST;
2115 }
2116
2117
2118 int uv_fs_rename(uv_loop_t* loop,
2119 uv_fs_t* req,
2120 const char* path,
2121 const char* new_path,
2122 uv_fs_cb cb) {
2123 INIT(RENAME);
2124 PATH2;
2125 if (cb != NULL)
2126 if (uv__iou_fs_rename(loop, req))
2127 return 0;
2128 POST;
2129 }
2130
2131
2132 int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2133 INIT(RMDIR);
2134 PATH;
2135 POST;
2136 }
2137
2138
2139 int uv_fs_sendfile(uv_loop_t* loop,
2140 uv_fs_t* req,
2141 uv_file out_fd,
2142 uv_file in_fd,
2143 int64_t off,
2144 size_t len,
2145 uv_fs_cb cb) {
2146 INIT(SENDFILE);
2147 req->flags = in_fd; /* hack */
2148 req->file = out_fd;
2149 req->off = off;
2150 req->bufsml[0].len = len;
2151 POST;
2152 }
2153
2154
2155 int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2156 INIT(STAT);
2157 PATH;
2158 if (cb != NULL)
2159 if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 0))
2160 return 0;
2161 POST;
2162 }
2163
2164
2165 int uv_fs_symlink(uv_loop_t* loop,
2166 uv_fs_t* req,
2167 const char* path,
2168 const char* new_path,
2169 int flags,
2170 uv_fs_cb cb) {
2171 INIT(SYMLINK);
2172 PATH2;
2173 req->flags = flags;
2174 if (cb != NULL)
2175 if (uv__iou_fs_symlink(loop, req))
2176 return 0;
2177 POST;
2178 }
2179
2180
2181 int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2182 INIT(UNLINK);
2183 PATH;
2184 if (cb != NULL)
2185 if (uv__iou_fs_unlink(loop, req))
2186 return 0;
2187 POST;
2188 }
2189
2190
2191 int uv_fs_utime(uv_loop_t* loop,
2192 uv_fs_t* req,
2193 const char* path,
2194 double atime,
2195 double mtime,
2196 uv_fs_cb cb) {
2197 INIT(UTIME);
2198 PATH;
2199 req->atime = atime;
2200 req->mtime = mtime;
2201 POST;
2202 }
2203
2204
2205 int uv_fs_write(uv_loop_t* loop,
2206 uv_fs_t* req,
2207 uv_file file,
2208 const uv_buf_t bufs[],
2209 unsigned int nbufs,
2210 int64_t off,
2211 uv_fs_cb cb) {
2212 INIT(WRITE);
2213
2214 if (bufs == NULL || nbufs == 0)
2215 return UV_EINVAL;
2216
2217 req->file = file;
2218
2219 req->nbufs = nbufs;
2220 req->bufs = req->bufsml;
2221 if (nbufs > ARRAY_SIZE(req->bufsml))
2222 req->bufs = uv__malloc(nbufs * sizeof(*bufs));
2223
2224 if (req->bufs == NULL)
2225 return UV_ENOMEM;
2226
2227 memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
2228
2229 req->off = off;
2230
2231 if (cb != NULL)
2232 if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 0))
2233 return 0;
2234
2235 POST;
2236 }
2237
2238
2239 void uv_fs_req_cleanup(uv_fs_t* req) {
2240 if (req == NULL)
2241 return;
2242
2243 /* Only necessary for asynchronous requests, i.e., requests with a callback.
2244 * Synchronous ones don't copy their arguments and have req->path and
2245 * req->new_path pointing to user-owned memory. UV_FS_MKDTEMP and
2246 * UV_FS_MKSTEMP are the exception to the rule, they always allocate memory.
2247 */
2248 if (req->path != NULL &&
2249 (req->cb != NULL ||
2250 req->fs_type == UV_FS_MKDTEMP || req->fs_type == UV_FS_MKSTEMP))
2251 uv__free((void*) req->path); /* Memory is shared with req->new_path. */
2252
2253 req->path = NULL;
2254 req->new_path = NULL;
2255
2256 if (req->fs_type == UV_FS_READDIR && req->ptr != NULL)
2257 uv__fs_readdir_cleanup(req);
2258
2259 if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
2260 uv__fs_scandir_cleanup(req);
2261
2262 if (req->bufs != req->bufsml)
2263 uv__free(req->bufs);
2264 req->bufs = NULL;
2265
2266 if (req->fs_type != UV_FS_OPENDIR && req->ptr != &req->statbuf)
2267 uv__free(req->ptr);
2268 req->ptr = NULL;
2269 }
2270
2271
2272 int uv_fs_copyfile(uv_loop_t* loop,
2273 uv_fs_t* req,
2274 const char* path,
2275 const char* new_path,
2276 int flags,
2277 uv_fs_cb cb) {
2278 INIT(COPYFILE);
2279
2280 if (flags & ~(UV_FS_COPYFILE_EXCL |
2281 UV_FS_COPYFILE_FICLONE |
2282 UV_FS_COPYFILE_FICLONE_FORCE)) {
2283 return UV_EINVAL;
2284 }
2285
2286 PATH2;
2287 req->flags = flags;
2288 POST;
2289 }
2290
2291
2292 int uv_fs_statfs(uv_loop_t* loop,
2293 uv_fs_t* req,
2294 const char* path,
2295 uv_fs_cb cb) {
2296 INIT(STATFS);
2297 PATH;
2298 POST;
2299 }
2300
2301 int uv_fs_get_system_error(const uv_fs_t* req) {
2302 return -req->result;
2303 }