Lines Matching refs:ret
65 int ret = ENOERR;
72 ret = clock_gettime(CLOCK_REALTIME, &stp);
73 if (ret < 0) {
86 ret = clock_gettime(CLOCK_REALTIME, &stp);
87 if (ret < 0) {
97 ret = clock_gettime(CLOCK_REALTIME, &stp);
98 if (ret < 0) {
107 return ret;
112 int ret;
118 ret = fs_getfilep(fd, &file);
119 if (ret < 0) {
124 ret = -ENOMEM;
127 ret = GetFullpath(fd, path, &fullPath);
128 if (ret < 0) {
129 return ret;
134 return ret;
154 int ret;
170 ret = UserIovItemCheck(*iovBuf, iovcnt);
171 if (ret == 0) {
176 *valid_iovcnt = ret;
222 int ret = PollfdToSystem(fds, nfds, &pollFds);
223 if (ret < 0) {
227 ret = poll(fds, nfds, timeout);
232 return ret;
237 int ret;
242 ret = close(sysfd);
243 if (ret < 0) {
248 return ret;
253 int ret;
266 ret = read(fd, buf, nbytes);
267 if (ret < 0) {
270 return ret;
275 int ret;
287 ret = write(sysfd, buf, nbytes);
288 if (ret < 0) {
291 return ret;
344 int ret = vfs_normalize_path(NULL, path, &fullPath);
345 if (ret < 0) {
346 return ret;
397 int ret = UserPathCopy(path, pathRet);
398 if (ret != 0) {
399 return ret;
403 ret = ProcRealProcessDirGet(*pathRet);
404 if (ret != 0) {
405 return ret;
414 int ret;
420 ret = GetPath(path, &pathRet);
421 if (ret != 0) {
428 ret = -EMFILE;
437 ret = do_opendir(pathRet, oflags);
446 ret = do_open(AT_FDCWD, pathRet, oflags, mode);
449 if (ret < 0) {
450 ret = -get_errno();
454 AssociateSystemFd(procFd, ret);
467 return ret;
472 int ret = 0;
476 ret = UserPathCopy(pathname, &pathRet);
477 if (ret != 0) {
484 ret = -EMFILE;
488 ret = open((pathname ? pathRet : NULL), O_CREAT | O_TRUNC | O_WRONLY, mode);
489 if (ret < 0) {
491 ret = -get_errno();
493 AssociateSystemFd(procFd, ret);
494 ret = procFd;
501 return ret;
506 int ret;
511 ret = UserPathCopy(oldpath, &oldpathRet);
512 if (ret != 0) {
518 ret = UserPathCopy(newpath, &newpathRet);
519 if (ret != 0) {
524 ret = link(oldpathRet, newpathRet);
525 if (ret < 0) {
526 ret = -get_errno();
536 return ret;
541 ssize_t ret;
549 ret = UserPathCopy(pathname, &pathRet);
550 if (ret != 0) {
556 ret = ProcRealProcessDirGet(pathRet);
557 if (ret != 0) {
565 ret = -EFAULT;
569 ret = readlink(pathRet, buf, bufsize);
570 if (ret < 0) {
571 ret = -get_errno();
578 return ret;
583 int ret;
588 ret = UserPathCopy(target, &targetRet);
589 if (ret != 0) {
595 ret = UserPathCopy(linkpath, &pathRet);
596 if (ret != 0) {
601 ret = symlink(targetRet, pathRet);
602 if (ret < 0) {
603 ret = -get_errno();
614 return ret;
619 int ret;
623 ret = UserPathCopy(pathname, &pathRet);
624 if (ret != 0) {
629 ret = do_unlink(AT_FDCWD, (pathname ? pathRet : NULL));
630 if (ret < 0) {
631 ret = -get_errno();
638 return ret;
650 int ret;
659 ret = fs_getfilep(sysFd, &file);
660 if (ret < 0) {
664 ret = chdir(file->f_path);
665 if (ret < 0) {
666 ret = -get_errno();
669 return ret;
674 int ret;
678 ret = UserPathCopy(path, &pathRet);
679 if (ret != 0) {
684 ret = chdir(path ? pathRet : NULL);
685 if (ret < 0) {
686 ret = -get_errno();
693 return ret;
706 off64_t ret;
713 ret = _lseek64(fd, offsetHigh, offsetLow, &res, whence);
714 if (ret != 0) {
715 return ret;
733 int ret;
738 ret = NfsMountRef(serverIpAndPath, mountPath, uid, gid);
739 if (ret < 0) {
740 ret = -get_errno();
742 return ret;
749 int ret;
760 ret = UserPathCopy(target, &targetRet);
761 if (ret != 0) {
767 ret = LOS_StrncpyFromUser(fstypeRet, filesystemtype, FILESYSTEM_TYPE_MAX + 1);
768 if (ret < 0) {
770 } else if (ret > FILESYSTEM_TYPE_MAX) {
771 ret = -ENODEV;
776 ret = UserPathCopy(source, &sourceRet);
777 if (ret != 0) {
783 ret = NfsMount(sourceRet, targetRet, 0, 0);
790 ret = UserPathCopy(data, &dataRet);
791 if (ret != 0) {
796 ret = mount(sourceRet, targetRet, (filesystemtype ? fstypeRet : NULL), mountflags, dataRet);
797 if (ret < 0) {
798 ret = -get_errno();
811 return ret;
816 int ret;
824 ret = UserPathCopy(target, &pathRet);
825 if (ret != 0) {
830 ret = umount(target ? pathRet : NULL);
831 if (ret < 0) {
832 ret = -get_errno();
839 return ret;
844 int ret;
848 ret = UserPathCopy(path, &pathRet);
849 if (ret != 0) {
854 ret = access(pathRet, amode);
855 if (ret < 0) {
856 ret = -get_errno();
864 return ret;
869 int ret;
874 ret = UserPathCopy(oldpath, &pathOldRet);
875 if (ret != 0) {
881 ret = UserPathCopy(newpath, &pathNewRet);
882 if (ret != 0) {
887 ret = do_rename(AT_FDCWD, (oldpath ? pathOldRet : NULL), AT_FDCWD,
889 if (ret < 0) {
890 ret = -get_errno();
900 return ret;
905 int ret;
909 ret = UserPathCopy(pathname, &pathRet);
910 if (ret != 0) {
915 ret = do_mkdir(AT_FDCWD, (pathname ? pathRet : NULL), mode);
916 if (ret < 0) {
917 ret = -get_errno();
924 return ret;
929 int ret;
933 ret = UserPathCopy(pathname, &pathRet);
934 if (ret != 0) {
939 ret = do_rmdir(AT_FDCWD, (pathname ? pathRet : NULL));
940 if (ret < 0) {
941 ret = -get_errno();
948 return ret;
984 int ret;
1004 ret = ioctl(fd, req, arg);
1005 if (ret < 0) {
1008 return ret;
1016 int ret = VfsFcntl(fd, cmd, arg);
1017 if (ret == CONTINE_NUTTX_FCNTL) {
1018 ret = fcntl(sysfd, cmd, arg);
1021 if (ret < 0) {
1024 return ret;
1030 int ret;
1043 ret = pipe(pipeFdIntr);
1044 if (ret < 0) {
1058 ret = LOS_ArchCopyToUser(pipefd, pipeFdIntr, sizeof(pipeFdIntr));
1059 if (ret != 0) {
1066 return ret;
1072 int ret;
1086 ret = AllocSpecifiedProcessFd(fd2);
1087 if (ret != OK) {
1088 return ret;
1093 ret = close(sysfd2);
1094 if (ret < 0) {
1149 int ret;
1156 ret = SelectParamCheckCopy(readfds, writefds, exceptfds, &fdsRet);
1157 if (ret != 0) {
1158 return ret;
1171 ret = do_select(nfds, (readfds ? readfdsRet : NULL), (writefds ? writefdsRet : NULL),
1173 if (ret < 0) {
1197 return ret;
1206 int ret;
1211 ret = UserPathCopy(path, &pathRet);
1212 if (ret != 0) {
1220 ret = -get_errno();
1224 ret = ftruncate(fd, length);
1226 if (ret < 0) {
1227 ret = -get_errno();
1234 return ret;
1239 int ret;
1244 ret = UserPathCopy(path, &pathRet);
1245 if (ret != 0) {
1253 ret = -get_errno();
1257 ret = ftruncate64(fd, length);
1259 if (ret < 0) {
1260 ret = -get_errno();
1267 return ret;
1272 int ret;
1277 ret = ftruncate(fd, length);
1278 if (ret < 0) {
1281 return ret;
1286 int ret;
1291 ret = UserPathCopy(path, &pathRet);
1292 if (ret != 0) {
1297 ret = statfs((path ? pathRet : NULL), (buf ? (&bufRet) : NULL));
1298 if (ret < 0) {
1299 ret = -get_errno();
1303 ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct statfs));
1304 if (ret != 0) {
1305 ret = -EFAULT;
1312 return ret;
1317 int ret;
1322 ret = UserPathCopy(path, &pathRet);
1323 if (ret != 0) {
1329 ret = -EINVAL;
1333 ret = statfs((path ? pathRet : NULL), (buf ? (&bufRet) : NULL));
1334 if (ret < 0) {
1335 ret = -get_errno();
1339 ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct statfs));
1340 if (ret != 0) {
1341 ret = -EFAULT;
1348 return ret;
1353 int ret;
1358 ret = UserPathCopy(path, &pathRet);
1359 if (ret != 0) {
1364 ret = stat((path ? pathRet : NULL), (buf ? (&bufRet) : NULL));
1365 if (ret < 0) {
1366 ret = -get_errno();
1370 ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
1371 if (ret != 0) {
1372 ret = -EFAULT;
1379 return ret;
1384 int ret;
1389 ret = UserPathCopy(path, &pathRet);
1390 if (ret != 0) {
1395 ret = stat((path ? pathRet : NULL), (buffer ? (&bufRet) : NULL));
1396 if (ret < 0) {
1397 ret = -get_errno();
1401 ret = LOS_ArchCopyToUser(buffer, &bufRet, sizeof(struct kstat));
1402 if (ret != 0) {
1403 ret = -EFAULT;
1410 return ret;
1415 int ret;
1422 ret = fs_getfilep(fd, &filep);
1423 if (ret < 0) {
1431 ret = stat(filep->f_path, (buf ? (&bufRet) : NULL));
1432 if (ret < 0) {
1436 ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
1437 if (ret != 0) {
1441 return ret;
1451 int ret;
1458 ret = fs_getfilep(fd, &filep);
1459 if (ret < 0) {
1469 ret = file_fsync(filep);
1470 if (ret < 0) {
1473 return ret;
1478 int ret;
1492 ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
1493 if (ret != 0) {
1494 return ret;
1498 ret = -EFAULT;
1502 ret = vfs_readv(fd, iovRet, valid_iovcnt, NULL);
1503 if (ret < 0) {
1504 ret = -get_errno();
1509 return ret;
1514 int ret;
1532 ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
1533 if (ret != 0) {
1534 return ret;
1538 ret = -EFAULT;
1542 ret = writev(sysfd, iovRet, valid_iovcnt);
1543 if (ret < 0) {
1544 ret = -get_errno();
1549 return ret;
1554 int ret;
1564 ret = -EFAULT;
1570 ret = PollfdToSystem(kfds, nfds, &pollFds);
1571 if (ret < 0) {
1572 ret = -get_errno();
1576 ret = poll(kfds, nfds, timeout);
1577 if (ret < 0) {
1578 ret = -get_errno();
1585 ret = -EFAULT;
1594 return ret;
1631 int ret, retVal;
1638 ret = pread64(fd, buf, nbytes, offset);
1639 if (ret < 0) {
1642 return ret;
1651 ret = pread64(fd, (buf ? bufRet : NULL), nbytes, offset);
1652 if (ret < 0) {
1657 retVal = LOS_ArchCopyToUser(buf, bufRet, ret);
1664 return ret;
1669 int ret;
1676 ret = pwrite64(fd, buf, nbytes, offset);
1677 if (ret < 0) {
1680 return ret;
1689 ret = LOS_ArchCopyFromUser(bufRet, buf, nbytes);
1690 if (ret != 0) {
1696 ret = pwrite64(fd, (buf ? bufRet : NULL), nbytes, offset);
1697 if (ret < 0) {
1703 return ret;
1708 char *ret = NULL;
1723 ret = getcwd((buf ? bufRet : NULL), bufLen);
1724 if (ret == NULL) {
1734 ret = buf;
1737 return ret;
1742 int ret, retVal;
1754 ret = sendfile(outfd, infd, (offset ? (&offsetRet) : NULL), count);
1755 if (ret < 0) {
1764 return ret;
1769 int ret;
1774 ret = ftruncate64(fd, length);
1775 if (ret < 0) {
1778 return ret;
1783 int ret;
1798 ret = UserPathCopy(path, &pathRet);
1799 if (ret != 0) {
1800 return ret;
1806 ret = -EMFILE;
1819 ret = do_open(dirfd, (path ? pathRet : NULL), oflags, mode);
1820 if (ret < 0) {
1821 ret = -get_errno();
1825 AssociateSystemFd(procFd, ret);
1838 return ret;
1843 int ret;
1847 ret = UserPathCopy(pathname, &pathRet);
1848 if (ret != 0) {
1858 ret = do_mkdir(dirfd, (pathname ? pathRet : NULL), mode);
1859 if (ret < 0) {
1860 ret = -get_errno();
1867 return ret;
1872 int ret;
1877 ret = UserPathCopy(oldpath, &oldpathRet);
1878 if (ret != 0) {
1884 ret = UserPathCopy(newpath, &newpathRet);
1885 if (ret != 0) {
1900 ret = linkat(olddirfd, oldpathRet, newdirfd, newpathRet, flags);
1901 if (ret < 0) {
1902 ret = -get_errno();
1912 return ret;
1917 int ret;
1922 ret = UserPathCopy(target, &targetRet);
1923 if (ret != 0) {
1929 ret = UserPathCopy(linkpath, &pathRet);
1930 if (ret != 0) {
1940 ret = symlinkat(targetRet, dirfd, pathRet);
1941 if (ret < 0) {
1942 ret = -get_errno();
1953 return ret;
1958 ssize_t ret;
1966 ret = UserPathCopy(pathname, &pathRet);
1967 if (ret != 0) {
1973 ret = ProcRealProcessDirGet(pathRet);
1974 if (ret != 0) {
1987 ret = -EFAULT;
1991 ret = readlinkat(dirfd, pathRet, buf, bufsize);
1992 if (ret < 0) {
1993 ret = -get_errno();
2000 return ret;
2005 int ret;
2009 ret = UserPathCopy(pathname, &pathRet);
2010 if (ret != 0) {
2020 ret = unlinkat(dirfd, (pathname ? pathRet : NULL), flag);
2021 if (ret < 0) {
2022 ret = -get_errno();
2029 return ret;
2034 int ret;
2039 ret = UserPathCopy(oldpath, &pathOldRet);
2040 if (ret != 0) {
2046 ret = UserPathCopy(newpath, &pathNewRet);
2047 if (ret != 0) {
2061 ret = do_rename(oldfd, (oldpath ? pathOldRet : NULL), newdfd, (newpath ? pathNewRet : NULL));
2062 if (ret < 0) {
2063 ret = -get_errno();
2073 return ret;
2078 int ret;
2083 ret = fallocate(fd, mode, offset, len);
2084 if (ret < 0) {
2087 return ret;
2092 int ret;
2097 ret = fallocate64(fd, mode, offset, len);
2098 if (ret < 0) {
2101 return ret;
2109 int ret;
2123 ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
2124 if (ret != 0) {
2125 return ret;
2129 ret = -EFAULT;
2133 ret = preadv(fd, iovRet, valid_iovcnt, offsetflag);
2134 if (ret < 0) {
2135 ret = -get_errno();
2140 return ret;
2147 int ret;
2161 ret = UserIovCopy(&iovRet, iov, iovcnt, &valid_iovcnt);
2162 if (ret != 0) {
2163 return ret;
2167 ret = -EFAULT;
2171 ret = pwritev(fd, iovRet, valid_iovcnt, offsetflag);
2172 if (ret < 0) {
2173 ret = -get_errno();
2178 return ret;
2184 int ret;
2192 ret = UserPathCopy(dev, &devRet);
2193 if (ret != 0) {
2198 ret = format((dev ? devRet : NULL), sectors, option);
2199 if (ret < 0) {
2200 ret = -get_errno();
2207 return ret;
2213 int ret;
2219 ret = fstat64(fd, (buf ? (&bufRet) : NULL));
2220 if (ret < 0) {
2224 ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
2225 if (ret != 0) {
2229 return ret;
2237 int ret = VfsFcntl(fd, cmd, arg);
2238 if (ret == CONTINE_NUTTX_FCNTL) {
2239 ret = fcntl64(sysfd, cmd, arg);
2242 if (ret < 0) {
2245 return ret;
2259 int ret = do_readdir(fd, &de_knl, count);
2260 if (ret < 0) {
2261 return ret;
2264 int cpy_ret = LOS_ArchCopyToUser(de_user, de_knl, ret);
2270 return ret;
2278 int ret;
2285 ret = UserPathCopy(path, &pathRet);
2286 if (ret != 0) {
2287 result = (char *)(intptr_t)ret;
2298 ret = LOS_ArchCopyToUser(resolved_path, resolved_pathRet, strlen(resolved_pathRet) + 1);
2299 if (ret != 0) {
2317 int ret;
2325 ret = CheckNewAttrTime(&attr, times);
2327 if (ret < 0) {
2331 ret = GetFullpathNull(fd, path, &filePath);
2332 if (ret < 0) {
2336 ret = chattr(filePath, &attr);
2337 if (ret < 0) {
2338 ret = -get_errno();
2343 return ret;
2348 int ret;
2352 ret = UserPathCopy(pathname, &pathRet);
2353 if (ret != 0) {
2358 ret = chmod(pathRet, mode);
2359 if (ret < 0) {
2360 ret = -get_errno();
2367 return ret;
2372 int ret;
2381 ret = UserPathCopy(path, &pathRet);
2382 if (ret != 0) {
2392 ret = vfs_normalize_pathat(fd, pathRet, &fullpath);
2393 if (ret < 0) {
2397 ret = chattr(fullpath, &attr);
2398 if (ret < 0) {
2399 ret = -get_errno();
2406 return ret;
2411 int ret;
2424 ret = fs_getfilep(sysFd, &file);
2425 if (ret < 0) {
2429 ret = chattr(file->f_path, &attr);
2430 if (ret < 0) {
2434 return ret;
2439 int ret;
2445 ret = GetFullpath(fd, path, &fullpath);
2446 if (ret < 0) {
2459 ret = chattr(fullpath, &attr);
2460 if (ret < 0) {
2461 ret = -get_errno();
2467 return ret;
2472 int ret;
2483 ret = fs_getfilep(sysFd, &file);
2484 if (ret < 0) {
2496 ret = chattr(file->f_path, &attr);
2497 if (ret < 0) {
2498 ret = -get_errno();
2501 return ret;
2506 int ret;
2510 ret = UserPathCopy(pathname, &pathRet);
2511 if (ret != 0) {
2516 ret = chown(pathRet, owner, group);
2517 if (ret < 0) {
2518 ret = -get_errno();
2525 return ret;
2530 int ret;
2536 ret = UserPathCopy(path, &pathRet);
2537 if (ret != 0) {
2547 ret = vfs_normalize_pathat(dirfd, pathRet, &fullpath);
2548 if (ret < 0) {
2552 ret = stat(fullpath, &bufRet);
2553 if (ret < 0) {
2554 ret = -get_errno();
2558 ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct kstat));
2559 if (ret != 0) {
2560 ret = -EFAULT;
2572 return ret;
2577 int ret;
2582 ret = GetFullpath(fd, filename, &fullDirectory);
2583 if (ret < 0) {
2587 ret = statfs(fullDirectory, &fsBuf);
2588 if (ret != 0) {
2589 ret = -get_errno();
2594 ret = -EROFS;
2598 ret = stat(fullDirectory, &buf);
2599 if (ret != 0) {
2600 ret = -get_errno();
2605 ret = -EACCES;
2611 return ret;
2616 int ret;
2623 ret = fs_getfilep(fd, &filep);
2624 if (ret < 0) {
2625 ret = -get_errno();
2626 return ret;
2629 ret = statfs(filep->f_path, &bufRet);
2630 if (ret < 0) {
2631 ret = -get_errno();
2632 return ret;
2635 ret = LOS_ArchCopyToUser(buf, &bufRet, sizeof(struct statfs));
2636 if (ret != 0) {
2637 ret = -EFAULT;
2640 return ret;
2645 int ret;
2648 ret = -EINVAL;
2649 return ret;
2652 ret = SysFstatfs(fd, buf);
2654 return ret;
2694 int ret;
2716 ret = -EFAULT;
2718 return ret;
2723 ret = do_select(nfds, readfds, writefds, exceptfds, (struct timeval *)timeout, UserPoll);
2724 if (ret < 0) {
2726 ret = -get_errno();
2728 return ret;
2737 return ret;
2742 int ret;
2745 ret = epoll_create1(flags);
2746 if (ret < 0) {
2747 ret = -get_errno();
2748 return ret;
2751 procFd = AllocAndAssocProcessFd((INTPTR)(ret), MIN_START_FD);
2753 epoll_close(ret);
2773 int ret;
2781 ret = -EBADF;
2785 ret = epoll_ctl(epfd, op, fd, ev);
2786 if (ret < 0) {
2787 ret = -EBADF;
2793 return (ret == -1) ? -get_errno() : ret;
2798 int ret = 0;
2805 ret = -EBADF;
2809 ret = epoll_wait(epfd, evs, maxevents, timeout);
2810 if (ret < 0) {
2811 ret = -get_errno();
2816 return (ret == -1) ? -get_errno() : ret;
2823 int ret = 0;
2828 ret = LOS_ArchCopyFromUser(&setl, mask, sizeof(sigset_t));
2829 if (ret != 0) {
2839 ret = -EBADF;
2844 ret = epoll_wait(epfd, evs, maxevents, timeout);
2845 if (ret < 0) {
2846 ret = -get_errno();
2853 return (ret == -1) ? -get_errno() : ret;
2859 int ret;
2863 ret = UserPathCopy(path, &pathRet);
2864 if (ret != 0) {
2869 ret = chroot(path ? pathRet : NULL);
2870 if (ret < 0) {
2871 ret = -get_errno();
2877 return ret;