Lines Matching refs:req
26 * getting the errno to the right place (req->result or as the return value.)
103 if (req == NULL) \
105 UV_REQ_INIT(req, UV_FS); \
106 req->fs_type = UV_FS_ ## subtype; \
107 req->result = 0; \
108 req->ptr = NULL; \
109 req->loop = loop; \
110 req->path = NULL; \
111 req->new_path = NULL; \
112 req->bufs = NULL; \
113 req->cb = cb; \
121 req->path = path; \
123 req->path = uv__strdup(path); \
124 if (req->path == NULL) \
133 req->path = path; \
134 req->new_path = new_path; \
140 req->path = uv__malloc(path_len + new_path_len); \
141 if (req->path == NULL) \
143 req->new_path = req->path + path_len; \
144 memcpy((void*) req->path, path, path_len); \
145 memcpy((void*) req->new_path, new_path, new_path_len); \
153 uv__req_register(loop, req); \
155 &req->work_req, \
162 uv__fs_work(&req->work_req); \
163 return req->result; \
181 static ssize_t uv__fs_fsync(uv_fs_t* req) {
193 r = fcntl(req->file, F_FULLFSYNC);
195 r = fcntl(req->file, 85 /* F_BARRIERFSYNC */); /* fsync + barrier */
197 r = fsync(req->file);
200 return fsync(req->file);
205 static ssize_t uv__fs_fdatasync(uv_fs_t* req) {
207 return fdatasync(req->file);
210 return uv__fs_fsync(req);
212 return fsync(req->file);
247 static ssize_t uv__fs_futime(uv_fs_t* req) {
253 ts[0] = uv__fs_to_timespec(req->atime);
254 ts[1] = uv__fs_to_timespec(req->mtime);
255 return futimens(req->file, ts);
264 tv[0] = uv__fs_to_timeval(req->atime);
265 tv[1] = uv__fs_to_timeval(req->mtime);
267 return futimesat(req->file, NULL, tv);
269 return futimes(req->file, tv);
276 atr.att_mtime = req->mtime;
277 atr.att_atime = req->atime;
278 return __fchattr(req->file, &atr, sizeof(atr));
286 static ssize_t uv__fs_mkdtemp(uv_fs_t* req) {
287 return mkdtemp((char*) req->path) ? 0 : -1;
310 static int uv__fs_mkstemp(uv_fs_t* req) {
321 path = (char*) req->path;
356 if (req->cb != NULL)
357 uv_rwlock_rdlock(&req->loop->cloexec_lock);
371 if (req->cb != NULL)
372 uv_rwlock_rdunlock(&req->loop->cloexec_lock);
381 static ssize_t uv__fs_open(uv_fs_t* req) {
383 return open(req->path, req->flags | O_CLOEXEC, req->mode);
387 if (req->cb != NULL)
388 uv_rwlock_rdlock(&req->loop->cloexec_lock);
390 r = open(req->path, req->flags, req->mode);
402 if (req->cb != NULL)
403 uv_rwlock_rdunlock(&req->loop->cloexec_lock);
460 static ssize_t uv__fs_read(uv_fs_t* req) {
468 if (req->nbufs > iovmax)
469 req->nbufs = iovmax;
471 if (req->off < 0) {
472 if (req->nbufs == 1)
473 result = read(req->file, req->bufs[0].base, req->bufs[0].len);
475 result = readv(req->file, (struct iovec*) req->bufs, req->nbufs);
477 if (req->nbufs == 1) {
478 result = pread(req->file, req->bufs[0].base, req->bufs[0].len, req->off);
483 result = preadv(req->file, (struct iovec*) req->bufs, req->nbufs, req->off);
489 result = uv__fs_preadv(req->file, req->bufs, req->nbufs, req->off);
493 result = uv__preadv(req->file,
494 (struct iovec*)req->bufs,
495 req->nbufs,
496 req->off);
508 if (req->bufs != req->bufsml)
509 uv__free(req->bufs);
511 req->bufs = NULL;
512 req->nbufs = 0;
519 rc = fstat(req->file, &buf);
547 static ssize_t uv__fs_scandir(uv_fs_t* req) {
552 n = scandir(req->path, &dents, uv__fs_scandir_filter, uv__fs_scandir_sort);
555 req->nbufs = 0;
567 req->ptr = dents;
572 static int uv__fs_opendir(uv_fs_t* req) {
579 dir->dir = opendir(req->path);
583 req->ptr = dir;
588 req->ptr = NULL;
592 static int uv__fs_readdir(uv_fs_t* req) {
599 dir = req->ptr;
638 static int uv__fs_closedir(uv_fs_t* req) {
641 dir = req->ptr;
648 uv__free(req->ptr);
649 req->ptr = NULL;
653 static int uv__fs_statfs(uv_fs_t* req) {
662 if (0 != statvfs(req->path, &buf))
666 if (0 != statfs(req->path, &buf))
692 req->ptr = stat_fs;
707 static ssize_t uv__fs_readlink(uv_fs_t* req) {
713 maxlen = uv__fs_pathmax_size(req->path);
718 ret = lstat(req->path, &st);
731 maxlen = uv__fs_pathmax_size(req->path);
742 len = os390_readlink(req->path, buf, maxlen);
744 len = readlink(req->path, buf, maxlen);
761 req->ptr = buf;
766 static ssize_t uv__fs_realpath(uv_fs_t* req) {
770 buf = realpath(req->path, NULL);
776 len = uv__fs_pathmax_size(req->path);
784 if (realpath(req->path, buf) == NULL) {
790 req->ptr = buf;
795 static ssize_t uv__fs_sendfile_emul(uv_fs_t* req) {
809 len = req->bufsml[0].len;
810 in_fd = req->flags;
811 out_fd = req->file;
812 offset = req->off;
903 req->off = offset;
1018 static ssize_t uv__fs_sendfile(uv_fs_t* req) {
1022 in_fd = req->flags;
1023 out_fd = req->file;
1032 off = req->off;
1033 len = req->bufsml[0].len;
1048 if (r != -1 || off > req->off) {
1049 r = off - req->off;
1050 req->off = off;
1059 return uv__fs_sendfile_emul(req);
1081 off = req->off;
1082 r = uv__fs_copy_file_range(in_fd, &off, out_fd, NULL, req->bufsml[0].len, 0);
1084 r = off - req->off;
1085 req->off = off;
1090 r = sendfile(in_fd, out_fd, req->off, req->bufsml[0].len, NULL, &len, 0);
1095 req->off,
1096 req->bufsml[0].len,
1103 len = req->bufsml[0].len;
1104 r = sendfile(in_fd, out_fd, req->off, &len, NULL, 0);
1115 req->off += len;
1124 return uv__fs_sendfile_emul(req);
1134 return uv__fs_sendfile_emul(req);
1139 static ssize_t uv__fs_utime(uv_fs_t* req) {
1145 ts[0] = uv__fs_to_timespec(req->atime);
1146 ts[1] = uv__fs_to_timespec(req->mtime);
1147 return utimensat(AT_FDCWD, req->path, ts, 0);
1155 tv[0] = uv__fs_to_timeval(req->atime);
1156 tv[1] = uv__fs_to_timeval(req->mtime);
1157 return utimes(req->path, tv);
1161 buf.actime = req->atime;
1162 buf.modtime = req->mtime;
1163 return utime(req->path, &buf);
1169 atr.att_mtime = req->mtime;
1170 atr.att_atime = req->atime;
1171 return __lchattr((char*) req->path, &atr, sizeof(atr));
1179 static ssize_t uv__fs_lutime(uv_fs_t* req) {
1187 ts[0] = uv__fs_to_timespec(req->atime);
1188 ts[1] = uv__fs_to_timespec(req->mtime);
1189 return utimensat(AT_FDCWD, req->path, ts, AT_SYMLINK_NOFOLLOW);
1196 tv[0] = uv__fs_to_timeval(req->atime);
1197 tv[1] = uv__fs_to_timeval(req->mtime);
1198 return lutimes(req->path, tv);
1206 static ssize_t uv__fs_write(uv_fs_t* req) {
1223 if (req->off < 0) {
1224 if (req->nbufs == 1)
1225 r = write(req->file, req->bufs[0].base, req->bufs[0].len);
1227 r = writev(req->file, (struct iovec*) req->bufs, req->nbufs);
1229 if (req->nbufs == 1) {
1230 r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off);
1234 r = pwritev(req->file, (struct iovec*) req->bufs, req->nbufs, req->off);
1240 r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off);
1244 r = uv__pwritev(req->file,
1245 (struct iovec*) req->bufs,
1246 req->nbufs,
1247 req->off);
1266 static ssize_t uv__fs_copyfile(uv_fs_t* req) {
1284 srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL);
1298 if (req->flags & UV_FS_COPYFILE_EXCL)
1304 req->new_path,
1317 if ((req->flags & UV_FS_COPYFILE_EXCL) == 0) {
1357 if (req->flags & UV_FS_COPYFILE_FICLONE ||
1358 req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1365 if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1371 if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
1419 uv_fs_unlink(NULL, &fs_req, req->new_path, NULL);
1651 static ssize_t uv__fs_write_all(uv_fs_t* req) {
1659 nbufs = req->nbufs;
1660 bufs = req->bufs;
1664 req->nbufs = nbufs;
1665 if (req->nbufs > iovmax)
1666 req->nbufs = iovmax;
1669 result = uv__fs_write(req);
1678 if (req->off >= 0)
1679 req->off += result;
1681 req->nbufs = uv__fs_buf_offset(req->bufs, result);
1682 req->bufs += req->nbufs;
1683 nbufs -= req->nbufs;
1687 if (bufs != req->bufsml)
1690 req->bufs = NULL;
1691 req->nbufs = 0;
1699 uv_fs_t* req;
1702 req = container_of(w, uv_fs_t, work_req);
1703 retry_on_eintr = !(req->fs_type == UV_FS_CLOSE ||
1704 req->fs_type == UV_FS_READ);
1714 switch (req->fs_type) {
1715 X(ACCESS, access(req->path, req->flags));
1716 X(CHMOD, chmod(req->path, req->mode));
1717 X(CHOWN, chown(req->path, req->uid, req->gid));
1718 X(CLOSE, uv__fs_close(req->file));
1719 X(COPYFILE, uv__fs_copyfile(req));
1720 X(FCHMOD, fchmod(req->file, req->mode));
1721 X(FCHOWN, fchown(req->file, req->uid, req->gid));
1722 X(LCHOWN, lchown(req->path, req->uid, req->gid));
1723 X(FDATASYNC, uv__fs_fdatasync(req));
1724 X(FSTAT, uv__fs_fstat(req->file, &req->statbuf));
1725 X(FSYNC, uv__fs_fsync(req));
1726 X(FTRUNCATE, ftruncate(req->file, req->off));
1727 X(FUTIME, uv__fs_futime(req));
1728 X(LUTIME, uv__fs_lutime(req));
1729 X(LSTAT, uv__fs_lstat(req->path, &req->statbuf));
1730 X(LINK, link(req->path, req->new_path));
1731 X(MKDIR, mkdir(req->path, req->mode));
1732 X(MKDTEMP, uv__fs_mkdtemp(req));
1733 X(MKSTEMP, uv__fs_mkstemp(req));
1734 X(OPEN, uv__fs_open(req));
1735 X(READ, uv__fs_read(req));
1736 X(SCANDIR, uv__fs_scandir(req));
1737 X(OPENDIR, uv__fs_opendir(req));
1738 X(READDIR, uv__fs_readdir(req));
1739 X(CLOSEDIR, uv__fs_closedir(req));
1740 X(READLINK, uv__fs_readlink(req));
1741 X(REALPATH, uv__fs_realpath(req));
1742 X(RENAME, rename(req->path, req->new_path));
1743 X(RMDIR, rmdir(req->path));
1744 X(SENDFILE, uv__fs_sendfile(req));
1745 X(STAT, uv__fs_stat(req->path, &req->statbuf));
1746 X(STATFS, uv__fs_statfs(req));
1747 X(SYMLINK, symlink(req->path, req->new_path));
1748 X(UNLINK, unlink(req->path));
1749 X(UTIME, uv__fs_utime(req));
1750 X(WRITE, uv__fs_write_all(req));
1757 req->result = UV__ERR(errno);
1759 req->result = r;
1761 if (r == 0 && (req->fs_type == UV_FS_STAT ||
1762 req->fs_type == UV_FS_FSTAT ||
1763 req->fs_type == UV_FS_LSTAT)) {
1764 req->ptr = &req->statbuf;
1770 uv_fs_t* req;
1772 req = container_of(w, uv_fs_t, work_req);
1773 uv__req_unregister(req->loop, req);
1776 assert(req->result == 0);
1777 req->result = UV_ECANCELED;
1780 req->cb(req);
1785 uv_fs_t* req,
1791 req->flags = flags;
1797 uv_fs_t* req,
1803 req->mode = mode;
1809 uv_fs_t* req,
1816 req->uid = uid;
1817 req->gid = gid;
1822 int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1824 req->file = file;
1830 uv_fs_t* req,
1835 req->file = file;
1836 req->mode = mode;
1842 uv_fs_t* req,
1848 req->file = file;
1849 req->uid = uid;
1850 req->gid = gid;
1856 uv_fs_t* req,
1863 req->uid = uid;
1864 req->gid = gid;
1869 int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1871 req->file = file;
1876 int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1878 req->file = file;
1883 int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
1885 req->file = file;
1891 uv_fs_t* req,
1896 req->file = file;
1897 req->off = off;
1903 uv_fs_t* req,
1909 req->file = file;
1910 req->atime = atime;
1911 req->mtime = mtime;
1916 uv_fs_t* req,
1923 req->atime = atime;
1924 req->mtime = mtime;
1929 int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
1937 uv_fs_t* req,
1948 uv_fs_t* req,
1954 req->mode = mode;
1960 uv_fs_t* req,
1964 req->path = uv__strdup(tpl);
1965 if (req->path == NULL)
1972 uv_fs_t* req,
1976 req->path = uv__strdup(tpl);
1977 if (req->path == NULL)
1984 uv_fs_t* req,
1991 req->flags = flags;
1992 req->mode = mode;
1997 int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
2008 req->file = file;
2010 req->nbufs = nbufs;
2011 req->bufs = req->bufsml;
2012 if (nbufs > ARRAY_SIZE(req->bufsml))
2013 req->bufs = uv__malloc(nbufs * sizeof(*bufs));
2015 if (req->bufs == NULL)
2018 memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
2020 req->off = off;
2026 uv_fs_t* req,
2032 req->flags = flags;
2037 uv_fs_t* req,
2046 uv_fs_t* req,
2054 req->ptr = dir;
2059 uv_fs_t* req,
2067 req->ptr = dir;
2072 uv_fs_t* req,
2082 uv_fs_t* req,
2092 uv_fs_t* req,
2102 int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2110 uv_fs_t* req,
2117 req->flags = in_fd; /* hack */
2118 req->file = out_fd;
2119 req->off = off;
2120 req->bufsml[0].len = len;
2125 int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2133 uv_fs_t* req,
2140 req->flags = flags;
2145 int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
2153 uv_fs_t* req,
2160 req->atime = atime;
2161 req->mtime = mtime;
2167 uv_fs_t* req,
2178 req->file = file;
2180 req->nbufs = nbufs;
2181 req->bufs = req->bufsml;
2182 if (nbufs > ARRAY_SIZE(req->bufsml))
2183 req->bufs = uv__malloc(nbufs * sizeof(*bufs));
2185 if (req->bufs == NULL)
2188 memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
2190 req->off = off;
2195 void uv_fs_req_cleanup(uv_fs_t* req) {
2196 if (req == NULL)
2200 * Synchronous ones don't copy their arguments and have req->path and
2201 * req->new_path pointing to user-owned memory. UV_FS_MKDTEMP and
2204 if (req->path != NULL &&
2205 (req->cb != NULL ||
2206 req->fs_type == UV_FS_MKDTEMP || req->fs_type == UV_FS_MKSTEMP))
2207 uv__free((void*) req->path); /* Memory is shared with req->new_path. */
2209 req->path = NULL;
2210 req->new_path = NULL;
2212 if (req->fs_type == UV_FS_READDIR && req->ptr != NULL)
2213 uv__fs_readdir_cleanup(req);
2215 if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
2216 uv__fs_scandir_cleanup(req);
2218 if (req->bufs != req->bufsml)
2219 uv__free(req->bufs);
2220 req->bufs = NULL;
2222 if (req->fs_type != UV_FS_OPENDIR && req->ptr != &req->statbuf)
2223 uv__free(req->ptr);
2224 req->ptr = NULL;
2229 uv_fs_t* req,
2243 req->flags = flags;
2249 uv_fs_t* req,
2257 int uv_fs_get_system_error(const uv_fs_t* req) {
2258 return -req->result;