Lines Matching refs:req
26 * getting the errno to the right place (req->result or as the return value.)
102 if (req == NULL) \
104 UV_REQ_INIT(req, UV_FS); \
105 req->fs_type = UV_FS_ ## subtype; \
106 req->result = 0; \
107 req->ptr = NULL; \
108 req->loop = loop; \
109 req->path = NULL; \
110 req->new_path = NULL; \
111 req->bufs = NULL; \
112 req->cb = cb; \
120 req->path = path; \
122 req->path = uv__strdup(path); \
123 if (req->path == NULL) \
132 req->path = path; \
133 req->new_path = new_path; \
139 req->path = uv__malloc(path_len + new_path_len); \
140 if (req->path == NULL) \
142 req->new_path = req->path + path_len; \
143 memcpy((void*) req->path, path, path_len); \
144 memcpy((void*) req->new_path, new_path, new_path_len); \
153 uv__req_register(loop, req); \
155 (uv_req_t*)req, \
156 &req->work_req, \
163 uv__fs_work(&req->work_req); \
164 return req->result; \
172 uv__req_register(loop, req); \
174 &req->work_req, \
181 uv__fs_work(&req->work_req); \
182 return req->result; \
201 static ssize_t uv__fs_fsync(uv_fs_t* req) {
213 r = fcntl(req->file, F_FULLFSYNC);
215 r = fcntl(req->file, 85 /* F_BARRIERFSYNC */); /* fsync + barrier */
217 r = fsync(req->file);
220 return fsync(req->file);
225 static ssize_t uv__fs_fdatasync(uv_fs_t* req) {
227 return fdatasync(req->file);
230 return uv__fs_fsync(req);
232 return fsync(req->file);
267 static ssize_t uv__fs_futime(uv_fs_t* req) {
273 ts[0] = uv__fs_to_timespec(req->atime);
274 ts[1] = uv__fs_to_timespec(req->mtime);
275 return futimens(req->file, ts);
283 tv[0] = uv__fs_to_timeval(req->atime);
284 tv[1] = uv__fs_to_timeval(req->mtime);
286 return futimesat(req->file, NULL, tv);
288 return futimes(req->file, tv);
295 atr.att_mtime = req->mtime;
296 atr.att_atime = req->atime;
297 return __fchattr(req->file, &atr, sizeof(atr));
305 static ssize_t uv__fs_mkdtemp(uv_fs_t* req) {
306 return mkdtemp((char*) req->path) ? 0 : -1;
329 static int uv__fs_mkstemp(uv_fs_t* req) {
340 path = (char*) req->path;
376 if (req->cb != NULL)
377 uv_rwlock_rdlock(&req->loop->cloexec_lock);
391 if (req->cb != NULL)
392 uv_rwlock_rdunlock(&req->loop->cloexec_lock);
401 static ssize_t uv__fs_open(uv_fs_t* req) {
403 return open(req->path, req->flags | O_CLOEXEC, req->mode);
407 if (req->cb != NULL)
408 uv_rwlock_rdlock(&req->loop->cloexec_lock);
410 r = open(req->path, req->flags, req->mode);
422 if (req->cb != NULL)
423 uv_rwlock_rdunlock(&req->loop->cloexec_lock);
430 static ssize_t uv__fs_read(uv_fs_t* req) {
438 fd = req->file;
439 off = req->off;
440 bufs = (const struct iovec*) req->bufs;
441 nbufs = req->nbufs;
473 if (req->cb != NULL)
474 if (req->bufs != req->bufsml)
475 uv__free(req->bufs);
477 req->bufs = NULL;
478 req->nbufs = 0;
494 static ssize_t uv__fs_scandir(uv_fs_t* req) {
499 n = scandir(req->path, &dents, uv__fs_scandir_filter, uv__fs_scandir_sort);
502 req->nbufs = 0;
514 req->ptr = dents;
519 static int uv__fs_opendir(uv_fs_t* req) {
526 dir->dir = opendir(req->path);
530 req->ptr = dir;
535 req->ptr = NULL;
539 static int uv__fs_readdir(uv_fs_t* req) {
546 dir = req->ptr;
585 static int uv__fs_closedir(uv_fs_t* req) {
588 dir = req->ptr;
595 uv__free(req->ptr);
596 req->ptr = NULL;
600 static int uv__fs_statfs(uv_fs_t* req) {
609 if (0 != statvfs(req->path, &buf))
613 if (0 != statfs(req->path, &buf))
639 req->ptr = stat_fs;
654 static ssize_t uv__fs_readlink(uv_fs_t* req) {
660 maxlen = uv__fs_pathmax_size(req->path);
665 ret = uv__lstat(req->path, &st);
678 maxlen = uv__fs_pathmax_size(req->path);
689 len = os390_readlink(req->path, buf, maxlen);
691 len = readlink(req->path, buf, maxlen);
708 req->ptr = buf;
713 static ssize_t uv__fs_realpath(uv_fs_t* req) {
717 buf = realpath(req->path, NULL);
723 len = uv__fs_pathmax_size(req->path);
731 if (realpath(req->path, buf) == NULL) {
737 req->ptr = buf;
742 static ssize_t uv__fs_sendfile_emul(uv_fs_t* req) {
756 len = req->bufsml[0].len;
757 in_fd = req->flags;
758 out_fd = req->file;
759 offset = req->off;
850 req->off = offset;
940 static ssize_t uv__fs_sendfile(uv_fs_t* req) {
944 in_fd = req->flags;
945 out_fd = req->file;
954 off = req->off;
955 len = req->bufsml[0].len;
970 if (r != -1 || off > req->off) {
971 r = off - req->off;
972 req->off = off;
981 return uv__fs_sendfile_emul(req);
1000 off = req->off;
1001 r = uv__fs_copy_file_range(in_fd, &off, out_fd, NULL, req->bufsml[0].len, 0);
1003 r = off - req->off;
1004 req->off = off;
1009 r = sendfile(in_fd, out_fd, req->off, req->bufsml[0].len, NULL, &len, 0);
1013 len = req->bufsml[0].len;
1014 r = sendfile(in_fd, out_fd, req->off, &len, NULL, 0);
1025 req->off += len;
1034 return uv__fs_sendfile_emul(req);
1044 return uv__fs_sendfile_emul(req);
1049 static ssize_t uv__fs_utime(uv_fs_t* req) {
1055 ts[0] = uv__fs_to_timespec(req->atime);
1056 ts[1] = uv__fs_to_timespec(req->mtime);
1057 return utimensat(AT_FDCWD, req->path, ts, 0);
1064 tv[0] = uv__fs_to_timeval(req->atime);
1065 tv[1] = uv__fs_to_timeval(req->mtime);
1066 return utimes(req->path, tv);
1070 buf.actime = req->atime;
1071 buf.modtime = req->mtime;
1072 return utime(req->path, &buf);
1078 atr.att_mtime = req->mtime;
1079 atr.att_atime = req->atime;
1080 return __lchattr((char*) req->path, &atr, sizeof(atr));
1088 static ssize_t uv__fs_lutime(uv_fs_t* req) {
1096 ts[0] = uv__fs_to_timespec(req->atime);
1097 ts[1] = uv__fs_to_timespec(req->mtime);
1098 return utimensat(AT_FDCWD, req->path, ts, AT_SYMLINK_NOFOLLOW);
1104 tv[0] = uv__fs_to_timeval(req->atime);
1105 tv[1] = uv__fs_to_timeval(req->mtime);
1106 return lutimes(req->path, tv);
1114 static ssize_t uv__fs_write(uv_fs_t* req) {
1121 fd = req->file;
1122 off = req->off;
1123 bufs = (const struct iovec*) req->bufs;
1124 nbufs = req->nbufs;
1143 static ssize_t uv__fs_copyfile(uv_fs_t* req) {
1161 srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL);
1175 if (req->flags & UV_FS_COPYFILE_EXCL)
1181 req->new_path,
1194 if ((req->flags & UV_FS_COPYFILE_EXCL) == 0) {
1246 if (req->flags & UV_FS_COPYFILE_FICLONE ||
1247 req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1254 if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1260 if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1308 uv_fs_unlink(NULL, &fs_req, req->new_path, NULL);
1521 static ssize_t uv__fs_write_all(uv_fs_t* req) {
1529 nbufs = req->nbufs;
1530 bufs = req->bufs;
1534 req->nbufs = nbufs;
1535 if (req->nbufs > iovmax)
1536 req->nbufs = iovmax;
1539 result = uv__fs_write(req);
1548 if (req->off >= 0)
1549 req->off += result;
1551 req->nbufs = uv__fs_buf_offset(req->bufs, result);
1552 req->bufs += req->nbufs;
1553 nbufs -= req->nbufs;
1557 if (bufs != req->bufsml)
1560 req->bufs = NULL;
1561 req->nbufs = 0;
1569 uv_fs_t* req;
1572 req = container_of(w, uv_fs_t, work_req);
1573 retry_on_eintr = !(req->fs_type == UV_FS_CLOSE ||
1574 req->fs_type == UV_FS_READ);
1584 switch (req->fs_type) {
1585 X(ACCESS, access(req->path, req->flags));
1586 X(CHMOD, chmod(req->path, req->mode));
1587 X(CHOWN, chown(req->path, req->uid, req->gid));
1588 X(CLOSE, uv__fs_close(req->file));
1589 X(COPYFILE, uv__fs_copyfile(req));
1590 X(FCHMOD, fchmod(req->file, req->mode));
1591 X(FCHOWN, fchown(req->file, req->uid, req->gid));
1592 X(LCHOWN, lchown(req->path, req->uid, req->gid));
1593 X(FDATASYNC, uv__fs_fdatasync(req));
1594 X(FSTAT, uv__fs_fstat(req->file, &req->statbuf));
1595 X(FSYNC, uv__fs_fsync(req));
1596 X(FTRUNCATE, ftruncate(req->file, req->off));
1597 X(FUTIME, uv__fs_futime(req));
1598 X(LUTIME, uv__fs_lutime(req));
1599 X(LSTAT, uv__fs_lstat(req->path, &req->statbuf));
1600 X(LINK, link(req->path, req->new_path));
1601 X(MKDIR, mkdir(req->path, req->mode));
1602 X(MKDTEMP, uv__fs_mkdtemp(req));
1603 X(MKSTEMP, uv__fs_mkstemp(req));
1604 X(OPEN, uv__fs_open(req));
1605 X(READ, uv__fs_read(req));
1606 X(SCANDIR, uv__fs_scandir(req));
1607 X(OPENDIR, uv__fs_opendir(req));
1608 X(READDIR, uv__fs_readdir(req));
1609 X(CLOSEDIR, uv__fs_closedir(req));
1610 X(READLINK, uv__fs_readlink(req));
1611 X(REALPATH, uv__fs_realpath(req));
1612 X(RENAME, rename(req->path, req->new_path));
1613 X(RMDIR, rmdir(req->path));
1614 X(SENDFILE, uv__fs_sendfile(req));
1615 X(STAT, uv__fs_stat(req->path, &req->statbuf));
1616 X(STATFS, uv__fs_statfs(req));
1617 X(SYMLINK, symlink(req->path, req->new_path));
1618 X(UNLINK, unlink(req->path));
1619 X(UTIME, uv__fs_utime(req));
1620 X(WRITE, uv__fs_write_all(req));
1627 req->result = UV__ERR(errno);
1629 req->result = r;
1631 if (r == 0 && (req->fs_type == UV_FS_STAT ||
1632 req->fs_type == UV_FS_FSTAT ||
1633 req->fs_type == UV_FS_LSTAT)) {
1634 req->ptr = &req->statbuf;
1640 uv_fs_t* req;
1642 req = container_of(w, uv_fs_t, work_req);
1643 uv__req_unregister(req->loop, req);
1646 assert(req->result == 0);
1647 req->result = UV_ECANCELED;
1650 req->cb(req);
1654 void uv__fs_post(uv_loop_t* loop, uv_fs_t* req) {
1655 uv__req_register(loop, req);
1660 &req->work_req,
1668 uv_fs_t* req,
1674 req->flags = flags;
1680 uv_fs_t* req,
1686 req->mode = mode;
1692 uv_fs_t* req,
1699 req->uid = uid;
1700 req->gid = gid;
1705 int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1707 req->file = file;
1709 if (uv__iou_fs_close(loop, req))
1716 uv_fs_t* req,
1721 req->file = file;
1722 req->mode = mode;
1728 uv_fs_t* req,
1734 req->file = file;
1735 req->uid = uid;
1736 req->gid = gid;
1742 uv_fs_t* req,
1749 req->uid = uid;
1750 req->gid = gid;
1755 int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1757 req->file = file;
1759 if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* IORING_FSYNC_DATASYNC */ 1))
1765 int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1767 req->file = file;
1769 if (uv__iou_fs_statx(loop, req, /* is_fstat */ 1, /* is_lstat */ 0))
1775 int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1777 req->file = file;
1779 if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* no flags */ 0))
1786 uv_fs_t* req,
1791 req->file = file;
1792 req->off = off;
1798 uv_fs_t* req,
1804 req->file = file;
1805 req->atime = atime;
1806 req->mtime = mtime;
1811 uv_fs_t* req,
1818 req->atime = atime;
1819 req->mtime = mtime;
1824 int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
1828 if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 1))
1835 uv_fs_t* req,
1842 if (uv__iou_fs_link(loop, req))
1849 uv_fs_t* req,
1855 req->mode = mode;
1857 if (uv__iou_fs_mkdir(loop, req))
1864 uv_fs_t* req,
1868 req->path = uv__strdup(tpl);
1869 if (req->path == NULL)
1876 uv_fs_t* req,
1880 req->path = uv__strdup(tpl);
1881 if (req->path == NULL)
1888 uv_fs_t* req,
1895 req->flags = flags;
1896 req->mode = mode;
1898 if (uv__iou_fs_open(loop, req))
1904 int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
1915 req->off = off;
1916 req->file = file;
1917 req->bufs = (uv_buf_t*) bufs; /* Safe, doesn't mutate |bufs| */
1918 req->nbufs = nbufs;
1923 req->bufs = req->bufsml;
1924 if (nbufs > ARRAY_SIZE(req->bufsml))
1925 req->bufs = uv__malloc(nbufs * sizeof(*bufs));
1927 if (req->bufs == NULL)
1930 memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
1932 if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 1))
1941 uv_fs_t* req,
1947 req->flags = flags;
1952 uv_fs_t* req,
1961 uv_fs_t* req,
1969 req->ptr = dir;
1974 uv_fs_t* req,
1982 req->ptr = dir;
1987 uv_fs_t* req,
1997 uv_fs_t* req,
2007 uv_fs_t* req,
2014 if (uv__iou_fs_rename(loop, req))
2020 int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2028 uv_fs_t* req,
2035 req->flags = in_fd; /* hack */
2036 req->file = out_fd;
2037 req->off = off;
2038 req->bufsml[0].len = len;
2043 int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2047 if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 0))
2054 uv_fs_t* req,
2061 req->flags = flags;
2063 if (uv__iou_fs_symlink(loop, req))
2069 int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2073 if (uv__iou_fs_unlink(loop, req))
2080 uv_fs_t* req,
2087 req->atime = atime;
2088 req->mtime = mtime;
2094 uv_fs_t* req,
2105 req->file = file;
2107 req->nbufs = nbufs;
2108 req->bufs = req->bufsml;
2109 if (nbufs > ARRAY_SIZE(req->bufsml))
2110 req->bufs = uv__malloc(nbufs * sizeof(*bufs));
2112 if (req->bufs == NULL)
2115 memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
2117 req->off = off;
2120 if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 0))
2127 void uv_fs_req_cleanup(uv_fs_t* req) {
2128 if (req == NULL)
2132 * Synchronous ones don't copy their arguments and have req->path and
2133 * req->new_path pointing to user-owned memory. UV_FS_MKDTEMP and
2136 if (req->path != NULL &&
2137 (req->cb != NULL ||
2138 req->fs_type == UV_FS_MKDTEMP || req->fs_type == UV_FS_MKSTEMP))
2139 uv__free((void*) req->path); /* Memory is shared with req->new_path. */
2141 req->path = NULL;
2142 req->new_path = NULL;
2144 if (req->fs_type == UV_FS_READDIR && req->ptr != NULL)
2145 uv__fs_readdir_cleanup(req);
2147 if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
2148 uv__fs_scandir_cleanup(req);
2150 if (req->bufs != req->bufsml)
2151 uv__free(req->bufs);
2152 req->bufs = NULL;
2154 if (req->fs_type != UV_FS_OPENDIR && req->ptr != &req->statbuf)
2155 uv__free(req->ptr);
2156 req->ptr = NULL;
2161 uv_fs_t* req,
2175 req->flags = flags;
2181 uv_fs_t* req,
2189 int uv_fs_get_system_error(const uv_fs_t* req) {
2190 return -req->result;