vfs_extattr.c (89173) | vfs_extattr.c (89306) |
---|---|
1/* 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. --- 22 unchanged lines hidden (view full) --- 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)vfs_syscalls.c 8.13 (Berkeley) 4/15/94 | 1/* 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. --- 22 unchanged lines hidden (view full) --- 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 * 38 * @(#)vfs_syscalls.c 8.13 (Berkeley) 4/15/94 |
39 * $FreeBSD: head/sys/kern/vfs_extattr.c 89173 2002-01-10 01:59:30Z iedowse $ | 39 * $FreeBSD: head/sys/kern/vfs_extattr.c 89306 2002-01-13 11:58:06Z alfred $ |
40 */ 41 42/* For 4.3 integer FS ID compatibility */ 43#include "opt_compat.h" 44#include "opt_ffs.h" 45 46#include <sys/param.h> 47#include <sys/systm.h> --- 401 unchanged lines hidden (view full) --- 449 450 if (olddp->v_usecount == 1) 451 return; 452 sx_slock(&allproc_lock); 453 LIST_FOREACH(p, &allproc, p_list) { 454 fdp = p->p_fd; 455 if (fdp == NULL) 456 continue; | 40 */ 41 42/* For 4.3 integer FS ID compatibility */ 43#include "opt_compat.h" 44#include "opt_ffs.h" 45 46#include <sys/param.h> 47#include <sys/systm.h> --- 401 unchanged lines hidden (view full) --- 449 450 if (olddp->v_usecount == 1) 451 return; 452 sx_slock(&allproc_lock); 453 LIST_FOREACH(p, &allproc, p_list) { 454 fdp = p->p_fd; 455 if (fdp == NULL) 456 continue; |
457 FILEDESC_LOCK(fdp); |
|
457 if (fdp->fd_cdir == olddp) { | 458 if (fdp->fd_cdir == olddp) { |
458 vrele(fdp->fd_cdir); | |
459 VREF(newdp); 460 fdp->fd_cdir = newdp; | 459 VREF(newdp); 460 fdp->fd_cdir = newdp; |
461 FILEDESC_UNLOCK(fdp); 462 vrele(olddp); 463 FILEDESC_LOCK(fdp); |
|
461 } 462 if (fdp->fd_rdir == olddp) { | 464 } 465 if (fdp->fd_rdir == olddp) { |
463 vrele(fdp->fd_rdir); | |
464 VREF(newdp); 465 fdp->fd_rdir = newdp; | 466 VREF(newdp); 467 fdp->fd_rdir = newdp; |
466 } | 468 FILEDESC_UNLOCK(fdp); 469 vrele(olddp); 470 } else 471 FILEDESC_UNLOCK(fdp); |
467 } 468 sx_sunlock(&allproc_lock); 469 if (rootvnode == olddp) { 470 vrele(rootvnode); 471 VREF(newdp); 472 rootvnode = newdp; 473 } 474} --- 322 unchanged lines hidden (view full) --- 797 struct mount *mp; 798 register struct statfs *sp; 799 int error; 800 struct statfs sb; 801 802 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 803 return (error); 804 mp = ((struct vnode *)fp->f_data)->v_mount; | 472 } 473 sx_sunlock(&allproc_lock); 474 if (rootvnode == olddp) { 475 vrele(rootvnode); 476 VREF(newdp); 477 rootvnode = newdp; 478 } 479} --- 322 unchanged lines hidden (view full) --- 802 struct mount *mp; 803 register struct statfs *sp; 804 int error; 805 struct statfs sb; 806 807 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 808 return (error); 809 mp = ((struct vnode *)fp->f_data)->v_mount; |
810 fdrop(fp, td); |
|
805 if (mp == NULL) 806 return (EBADF); 807 sp = &mp->mnt_stat; 808 error = VFS_STATFS(mp, sp, td); 809 if (error) 810 return (error); 811 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 812 if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { --- 85 unchanged lines hidden (view full) --- 898int 899fchdir(td, uap) 900 struct thread *td; 901 struct fchdir_args /* { 902 syscallarg(int) fd; 903 } */ *uap; 904{ 905 register struct filedesc *fdp = td->td_proc->p_fd; | 811 if (mp == NULL) 812 return (EBADF); 813 sp = &mp->mnt_stat; 814 error = VFS_STATFS(mp, sp, td); 815 if (error) 816 return (error); 817 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 818 if (suser_xxx(td->td_proc->p_ucred, 0, 0)) { --- 85 unchanged lines hidden (view full) --- 904int 905fchdir(td, uap) 906 struct thread *td; 907 struct fchdir_args /* { 908 syscallarg(int) fd; 909 } */ *uap; 910{ 911 register struct filedesc *fdp = td->td_proc->p_fd; |
906 struct vnode *vp, *tdp; | 912 struct vnode *vp, *tdp, *vpold; |
907 struct mount *mp; 908 struct file *fp; 909 int error; 910 911 if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0) 912 return (error); 913 vp = (struct vnode *)fp->f_data; 914 VREF(vp); | 913 struct mount *mp; 914 struct file *fp; 915 int error; 916 917 if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0) 918 return (error); 919 vp = (struct vnode *)fp->f_data; 920 VREF(vp); |
921 fdrop(fp, td); |
|
915 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 916 if (vp->v_type != VDIR) 917 error = ENOTDIR; 918 else 919 error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); 920 while (!error && (mp = vp->v_mountedhere) != NULL) { 921 if (vfs_busy(mp, 0, 0, td)) 922 continue; --- 4 unchanged lines hidden (view full) --- 927 vput(vp); 928 vp = tdp; 929 } 930 if (error) { 931 vput(vp); 932 return (error); 933 } 934 VOP_UNLOCK(vp, 0, td); | 922 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 923 if (vp->v_type != VDIR) 924 error = ENOTDIR; 925 else 926 error = VOP_ACCESS(vp, VEXEC, td->td_proc->p_ucred, td); 927 while (!error && (mp = vp->v_mountedhere) != NULL) { 928 if (vfs_busy(mp, 0, 0, td)) 929 continue; --- 4 unchanged lines hidden (view full) --- 934 vput(vp); 935 vp = tdp; 936 } 937 if (error) { 938 vput(vp); 939 return (error); 940 } 941 VOP_UNLOCK(vp, 0, td); |
935 vrele(fdp->fd_cdir); | 942 FILEDESC_LOCK(fdp); 943 vpold = fdp->fd_cdir; |
936 fdp->fd_cdir = vp; | 944 fdp->fd_cdir = vp; |
945 FILEDESC_UNLOCK(fdp); 946 vrele(vpold); |
|
937 return (0); 938} 939 940/* 941 * Change current working directory (``.''). 942 */ 943#ifndef _SYS_SYSPROTO_H_ 944struct chdir_args { --- 6 unchanged lines hidden (view full) --- 951 struct thread *td; 952 struct chdir_args /* { 953 syscallarg(char *) path; 954 } */ *uap; 955{ 956 register struct filedesc *fdp = td->td_proc->p_fd; 957 int error; 958 struct nameidata nd; | 947 return (0); 948} 949 950/* 951 * Change current working directory (``.''). 952 */ 953#ifndef _SYS_SYSPROTO_H_ 954struct chdir_args { --- 6 unchanged lines hidden (view full) --- 961 struct thread *td; 962 struct chdir_args /* { 963 syscallarg(char *) path; 964 } */ *uap; 965{ 966 register struct filedesc *fdp = td->td_proc->p_fd; 967 int error; 968 struct nameidata nd; |
969 struct vnode *vp; |
|
959 960 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, 961 SCARG(uap, path), td); 962 if ((error = change_dir(&nd, td)) != 0) 963 return (error); 964 NDFREE(&nd, NDF_ONLY_PNBUF); | 970 971 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, 972 SCARG(uap, path), td); 973 if ((error = change_dir(&nd, td)) != 0) 974 return (error); 975 NDFREE(&nd, NDF_ONLY_PNBUF); |
965 vrele(fdp->fd_cdir); | 976 FILEDESC_LOCK(fdp); 977 vp = fdp->fd_cdir; |
966 fdp->fd_cdir = nd.ni_vp; | 978 fdp->fd_cdir = nd.ni_vp; |
979 FILEDESC_UNLOCK(fdp); 980 vrele(vp); |
|
967 return (0); 968} 969 970/* 971 * Helper function for raised chroot(2) security function: Refuse if 972 * any filedescriptors are open directories. 973 */ 974static int 975chroot_refuse_vdir_fds(fdp) 976 struct filedesc *fdp; 977{ 978 struct vnode *vp; 979 struct file *fp; | 981 return (0); 982} 983 984/* 985 * Helper function for raised chroot(2) security function: Refuse if 986 * any filedescriptors are open directories. 987 */ 988static int 989chroot_refuse_vdir_fds(fdp) 990 struct filedesc *fdp; 991{ 992 struct vnode *vp; 993 struct file *fp; |
994 struct thread *td = curthread; |
|
980 int error; 981 int fd; 982 | 995 int error; 996 int fd; 997 |
998 FILEDESC_LOCK(fdp); |
|
983 for (fd = 0; fd < fdp->fd_nfiles ; fd++) { 984 error = getvnode(fdp, fd, &fp); 985 if (error) 986 continue; 987 vp = (struct vnode *)fp->f_data; | 999 for (fd = 0; fd < fdp->fd_nfiles ; fd++) { 1000 error = getvnode(fdp, fd, &fp); 1001 if (error) 1002 continue; 1003 vp = (struct vnode *)fp->f_data; |
1004 fdrop(fp, td); |
|
988 if (vp->v_type != VDIR) 989 continue; | 1005 if (vp->v_type != VDIR) 1006 continue; |
1007 FILEDESC_UNLOCK(fdp); |
|
990 return(EPERM); 991 } | 1008 return(EPERM); 1009 } |
1010 FILEDESC_UNLOCK(fdp); |
|
992 return (0); 993} 994 995/* 996 * This sysctl determines if we will allow a process to chroot(2) if it 997 * has a directory open: 998 * 0: disallowed for all processes. 999 * 1: allowed for processes that were not already chroot(2)'ed. --- 19 unchanged lines hidden (view full) --- 1019 struct thread *td; 1020 struct chroot_args /* { 1021 syscallarg(char *) path; 1022 } */ *uap; 1023{ 1024 register struct filedesc *fdp = td->td_proc->p_fd; 1025 int error; 1026 struct nameidata nd; | 1011 return (0); 1012} 1013 1014/* 1015 * This sysctl determines if we will allow a process to chroot(2) if it 1016 * has a directory open: 1017 * 0: disallowed for all processes. 1018 * 1: allowed for processes that were not already chroot(2)'ed. --- 19 unchanged lines hidden (view full) --- 1038 struct thread *td; 1039 struct chroot_args /* { 1040 syscallarg(char *) path; 1041 } */ *uap; 1042{ 1043 register struct filedesc *fdp = td->td_proc->p_fd; 1044 int error; 1045 struct nameidata nd; |
1046 struct vnode *vp; |
|
1027 1028 error = suser_xxx(0, td->td_proc, PRISON_ROOT); 1029 if (error) 1030 return (error); | 1047 1048 error = suser_xxx(0, td->td_proc, PRISON_ROOT); 1049 if (error) 1050 return (error); |
1051 FILEDESC_LOCK(fdp); |
|
1031 if (chroot_allow_open_directories == 0 || | 1052 if (chroot_allow_open_directories == 0 || |
1032 (chroot_allow_open_directories == 1 && fdp->fd_rdir != rootvnode)) | 1053 (chroot_allow_open_directories == 1 && fdp->fd_rdir != rootvnode)) { 1054 FILEDESC_UNLOCK(fdp); |
1033 error = chroot_refuse_vdir_fds(fdp); | 1055 error = chroot_refuse_vdir_fds(fdp); |
1056 } else 1057 FILEDESC_UNLOCK(fdp); |
|
1034 if (error) 1035 return (error); 1036 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, 1037 SCARG(uap, path), td); 1038 if ((error = change_dir(&nd, td)) != 0) 1039 return (error); 1040 NDFREE(&nd, NDF_ONLY_PNBUF); | 1058 if (error) 1059 return (error); 1060 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, 1061 SCARG(uap, path), td); 1062 if ((error = change_dir(&nd, td)) != 0) 1063 return (error); 1064 NDFREE(&nd, NDF_ONLY_PNBUF); |
1041 vrele(fdp->fd_rdir); | 1065 FILEDESC_LOCK(fdp); 1066 vp = fdp->fd_rdir; |
1042 fdp->fd_rdir = nd.ni_vp; 1043 if (!fdp->fd_jdir) { 1044 fdp->fd_jdir = nd.ni_vp; 1045 VREF(fdp->fd_jdir); 1046 } | 1067 fdp->fd_rdir = nd.ni_vp; 1068 if (!fdp->fd_jdir) { 1069 fdp->fd_jdir = nd.ni_vp; 1070 VREF(fdp->fd_jdir); 1071 } |
1072 FILEDESC_UNLOCK(fdp); 1073 vrele(vp); |
|
1047 return (0); 1048} 1049 1050/* 1051 * Common routine for chroot and chdir. 1052 */ 1053static int 1054change_dir(ndp, td) --- 53 unchanged lines hidden (view full) --- 1108 oflags = SCARG(uap, flags); 1109 if ((oflags & O_ACCMODE) == O_ACCMODE) 1110 return (EINVAL); 1111 flags = FFLAGS(oflags); 1112 error = falloc(td, &nfp, &indx); 1113 if (error) 1114 return (error); 1115 fp = nfp; | 1074 return (0); 1075} 1076 1077/* 1078 * Common routine for chroot and chdir. 1079 */ 1080static int 1081change_dir(ndp, td) --- 53 unchanged lines hidden (view full) --- 1135 oflags = SCARG(uap, flags); 1136 if ((oflags & O_ACCMODE) == O_ACCMODE) 1137 return (EINVAL); 1138 flags = FFLAGS(oflags); 1139 error = falloc(td, &nfp, &indx); 1140 if (error) 1141 return (error); 1142 fp = nfp; |
1143 FILEDESC_LOCK(fdp); |
|
1116 cmode = ((SCARG(uap, mode) &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT; | 1144 cmode = ((SCARG(uap, mode) &~ fdp->fd_cmask) & ALLPERMS) &~ S_ISTXT; |
1145 FILEDESC_UNLOCK(fdp); |
|
1117 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); 1118 td->td_dupfd = -indx - 1; /* XXX check for fdopen */ 1119 /* 1120 * Bump the ref count to prevent another process from closing 1121 * the descriptor while we are blocked in vn_open() 1122 */ 1123 fhold(fp); 1124 error = vn_open(&nd, &flags, cmode); --- 14 unchanged lines hidden (view full) --- 1139 dupfdopen(td, fdp, indx, td->td_dupfd, flags, error)) == 0) { 1140 td->td_retval[0] = indx; 1141 return (0); 1142 } 1143 /* 1144 * Clean up the descriptor, but only if another thread hadn't 1145 * replaced or closed it. 1146 */ | 1146 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), td); 1147 td->td_dupfd = -indx - 1; /* XXX check for fdopen */ 1148 /* 1149 * Bump the ref count to prevent another process from closing 1150 * the descriptor while we are blocked in vn_open() 1151 */ 1152 fhold(fp); 1153 error = vn_open(&nd, &flags, cmode); --- 14 unchanged lines hidden (view full) --- 1168 dupfdopen(td, fdp, indx, td->td_dupfd, flags, error)) == 0) { 1169 td->td_retval[0] = indx; 1170 return (0); 1171 } 1172 /* 1173 * Clean up the descriptor, but only if another thread hadn't 1174 * replaced or closed it. 1175 */ |
1176 FILEDESC_LOCK(fdp); |
|
1147 if (fdp->fd_ofiles[indx] == fp) { 1148 fdp->fd_ofiles[indx] = NULL; | 1177 if (fdp->fd_ofiles[indx] == fp) { 1178 fdp->fd_ofiles[indx] = NULL; |
1179 FILEDESC_UNLOCK(fdp); |
|
1149 fdrop(fp, td); | 1180 fdrop(fp, td); |
1150 } | 1181 } else 1182 FILEDESC_UNLOCK(fdp); |
1151 1152 if (error == ERESTART) 1153 error = EINTR; 1154 return (error); 1155 } 1156 td->td_dupfd = 0; 1157 NDFREE(&nd, NDF_ONLY_PNBUF); 1158 vp = nd.ni_vp; 1159 1160 /* 1161 * There should be 2 references on the file, one from the descriptor 1162 * table, and one for us. 1163 * 1164 * Handle the case where someone closed the file (via its file 1165 * descriptor) while we were blocked. The end result should look 1166 * like opening the file succeeded but it was immediately closed. 1167 */ | 1183 1184 if (error == ERESTART) 1185 error = EINTR; 1186 return (error); 1187 } 1188 td->td_dupfd = 0; 1189 NDFREE(&nd, NDF_ONLY_PNBUF); 1190 vp = nd.ni_vp; 1191 1192 /* 1193 * There should be 2 references on the file, one from the descriptor 1194 * table, and one for us. 1195 * 1196 * Handle the case where someone closed the file (via its file 1197 * descriptor) while we were blocked. The end result should look 1198 * like opening the file succeeded but it was immediately closed. 1199 */ |
1200 FILEDESC_LOCK(fdp); 1201 FILE_LOCK(fp); |
|
1168 if (fp->f_count == 1) { 1169 KASSERT(fdp->fd_ofiles[indx] != fp, 1170 ("Open file descriptor lost all refs")); | 1202 if (fp->f_count == 1) { 1203 KASSERT(fdp->fd_ofiles[indx] != fp, 1204 ("Open file descriptor lost all refs")); |
1205 FILEDESC_UNLOCK(fdp); 1206 FILE_UNLOCK(fp); |
|
1171 VOP_UNLOCK(vp, 0, td); 1172 vn_close(vp, flags & FMASK, fp->f_cred, td); 1173 fdrop(fp, td); 1174 td->td_retval[0] = indx; 1175 return 0; 1176 } 1177 1178 fp->f_data = (caddr_t)vp; 1179 fp->f_flag = flags & FMASK; 1180 fp->f_ops = &vnops; 1181 fp->f_type = (vp->v_type == VFIFO ? DTYPE_FIFO : DTYPE_VNODE); | 1207 VOP_UNLOCK(vp, 0, td); 1208 vn_close(vp, flags & FMASK, fp->f_cred, td); 1209 fdrop(fp, td); 1210 td->td_retval[0] = indx; 1211 return 0; 1212 } 1213 1214 fp->f_data = (caddr_t)vp; 1215 fp->f_flag = flags & FMASK; 1216 fp->f_ops = &vnops; 1217 fp->f_type = (vp->v_type == VFIFO ? DTYPE_FIFO : DTYPE_VNODE); |
1218 FILEDESC_UNLOCK(fdp); 1219 FILE_UNLOCK(fp); |
|
1182 VOP_UNLOCK(vp, 0, td); 1183 if (flags & (O_EXLOCK | O_SHLOCK)) { 1184 lf.l_whence = SEEK_SET; 1185 lf.l_start = 0; 1186 lf.l_len = 0; 1187 if (flags & O_EXLOCK) 1188 lf.l_type = F_WRLCK; 1189 else --- 24 unchanged lines hidden (view full) --- 1214 /* 1215 * Release our private reference, leaving the one associated with 1216 * the descriptor table intact. 1217 */ 1218 fdrop(fp, td); 1219 td->td_retval[0] = indx; 1220 return (0); 1221bad: | 1220 VOP_UNLOCK(vp, 0, td); 1221 if (flags & (O_EXLOCK | O_SHLOCK)) { 1222 lf.l_whence = SEEK_SET; 1223 lf.l_start = 0; 1224 lf.l_len = 0; 1225 if (flags & O_EXLOCK) 1226 lf.l_type = F_WRLCK; 1227 else --- 24 unchanged lines hidden (view full) --- 1252 /* 1253 * Release our private reference, leaving the one associated with 1254 * the descriptor table intact. 1255 */ 1256 fdrop(fp, td); 1257 td->td_retval[0] = indx; 1258 return (0); 1259bad: |
1260 FILEDESC_LOCK(fdp); |
|
1222 if (fdp->fd_ofiles[indx] == fp) { 1223 fdp->fd_ofiles[indx] = NULL; | 1261 if (fdp->fd_ofiles[indx] == fp) { 1262 fdp->fd_ofiles[indx] = NULL; |
1263 FILEDESC_UNLOCK(fdp); |
|
1224 fdrop(fp, td); | 1264 fdrop(fp, td); |
1225 } 1226 fdrop(fp, td); | 1265 } else 1266 FILEDESC_UNLOCK(fdp); |
1227 return (error); 1228} 1229 1230#ifdef COMPAT_43 1231/* 1232 * Create a file. 1233 */ 1234#ifndef _SYS_SYSPROTO_H_ --- 67 unchanged lines hidden (view full) --- 1302 if ((error = namei(&nd)) != 0) 1303 return (error); 1304 vp = nd.ni_vp; 1305 if (vp != NULL) { 1306 vrele(vp); 1307 error = EEXIST; 1308 } else { 1309 VATTR_NULL(&vattr); | 1267 return (error); 1268} 1269 1270#ifdef COMPAT_43 1271/* 1272 * Create a file. 1273 */ 1274#ifndef _SYS_SYSPROTO_H_ --- 67 unchanged lines hidden (view full) --- 1342 if ((error = namei(&nd)) != 0) 1343 return (error); 1344 vp = nd.ni_vp; 1345 if (vp != NULL) { 1346 vrele(vp); 1347 error = EEXIST; 1348 } else { 1349 VATTR_NULL(&vattr); |
1350 FILEDESC_LOCK(td->td_proc->p_fd); |
|
1310 vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; | 1351 vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; |
1352 FILEDESC_UNLOCK(td->td_proc->p_fd); |
|
1311 vattr.va_rdev = SCARG(uap, dev); 1312 whiteout = 0; 1313 1314 switch (SCARG(uap, mode) & S_IFMT) { 1315 case S_IFMT: /* used by badsect to flag bad sectors */ 1316 vattr.va_type = VBAD; 1317 break; 1318 case S_IFCHR: --- 74 unchanged lines hidden (view full) --- 1393 NDFREE(&nd, NDF_ONLY_PNBUF); 1394 vput(nd.ni_dvp); 1395 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1396 return (error); 1397 goto restart; 1398 } 1399 VATTR_NULL(&vattr); 1400 vattr.va_type = VFIFO; | 1353 vattr.va_rdev = SCARG(uap, dev); 1354 whiteout = 0; 1355 1356 switch (SCARG(uap, mode) & S_IFMT) { 1357 case S_IFMT: /* used by badsect to flag bad sectors */ 1358 vattr.va_type = VBAD; 1359 break; 1360 case S_IFCHR: --- 74 unchanged lines hidden (view full) --- 1435 NDFREE(&nd, NDF_ONLY_PNBUF); 1436 vput(nd.ni_dvp); 1437 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1438 return (error); 1439 goto restart; 1440 } 1441 VATTR_NULL(&vattr); 1442 vattr.va_type = VFIFO; |
1443 FILEDESC_LOCK(td->td_proc->p_fd); |
|
1401 vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; | 1444 vattr.va_mode = (SCARG(uap, mode) & ALLPERMS) &~ td->td_proc->p_fd->fd_cmask; |
1445 FILEDESC_UNLOCK(td->td_proc->p_fd); |
|
1402 VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); 1403 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); 1404 if (error == 0) 1405 vput(nd.ni_vp); 1406 NDFREE(&nd, NDF_ONLY_PNBUF); 1407 vput(nd.ni_dvp); 1408 vn_finished_write(mp); 1409 return (error); --- 98 unchanged lines hidden (view full) --- 1508 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 1509 NDFREE(&nd, NDF_ONLY_PNBUF); 1510 vput(nd.ni_dvp); 1511 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1512 return (error); 1513 goto restart; 1514 } 1515 VATTR_NULL(&vattr); | 1446 VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); 1447 error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); 1448 if (error == 0) 1449 vput(nd.ni_vp); 1450 NDFREE(&nd, NDF_ONLY_PNBUF); 1451 vput(nd.ni_dvp); 1452 vn_finished_write(mp); 1453 return (error); --- 98 unchanged lines hidden (view full) --- 1552 if (vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) { 1553 NDFREE(&nd, NDF_ONLY_PNBUF); 1554 vput(nd.ni_dvp); 1555 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 1556 return (error); 1557 goto restart; 1558 } 1559 VATTR_NULL(&vattr); |
1560 FILEDESC_LOCK(td->td_proc->p_fd); |
|
1516 vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_fd->fd_cmask; | 1561 vattr.va_mode = ACCESSPERMS &~ td->td_proc->p_fd->fd_cmask; |
1562 FILEDESC_UNLOCK(td->td_proc->p_fd); |
|
1517 VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); 1518 error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path); 1519 NDFREE(&nd, NDF_ONLY_PNBUF); 1520 if (error == 0) 1521 vput(nd.ni_vp); 1522 vput(nd.ni_dvp); 1523 vn_finished_write(mp); 1524 ASSERT_VOP_UNLOCKED(nd.ni_dvp, "symlink"); --- 128 unchanged lines hidden (view full) --- 1653 register struct lseek_args /* { 1654 syscallarg(int) fd; 1655 syscallarg(int) pad; 1656 syscallarg(off_t) offset; 1657 syscallarg(int) whence; 1658 } */ *uap; 1659{ 1660 struct ucred *cred = td->td_proc->p_ucred; | 1563 VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); 1564 error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr, path); 1565 NDFREE(&nd, NDF_ONLY_PNBUF); 1566 if (error == 0) 1567 vput(nd.ni_vp); 1568 vput(nd.ni_dvp); 1569 vn_finished_write(mp); 1570 ASSERT_VOP_UNLOCKED(nd.ni_dvp, "symlink"); --- 128 unchanged lines hidden (view full) --- 1699 register struct lseek_args /* { 1700 syscallarg(int) fd; 1701 syscallarg(int) pad; 1702 syscallarg(off_t) offset; 1703 syscallarg(int) whence; 1704 } */ *uap; 1705{ 1706 struct ucred *cred = td->td_proc->p_ucred; |
1661 register struct filedesc *fdp = td->td_proc->p_fd; | |
1662 register struct file *fp; | 1707 register struct file *fp; |
1663 struct vattr vattr; | |
1664 struct vnode *vp; | 1708 struct vnode *vp; |
1709 struct vattr vattr; |
|
1665 off_t offset; 1666 int error, noneg; 1667 | 1710 off_t offset; 1711 int error, noneg; 1712 |
1668 if ((u_int)SCARG(uap, fd) >= fdp->fd_nfiles || 1669 (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) | 1713 fp = ffind_hold(td, uap->fd); 1714 if (fp == NULL) |
1670 return (EBADF); | 1715 return (EBADF); |
1671 if (fp->f_type != DTYPE_VNODE) | 1716 if (fp->f_type != DTYPE_VNODE) { 1717 fdrop(fp, td); |
1672 return (ESPIPE); | 1718 return (ESPIPE); |
1719 } |
|
1673 vp = (struct vnode *)fp->f_data; 1674 noneg = (vp->v_type != VCHR); 1675 offset = SCARG(uap, offset); 1676 switch (SCARG(uap, whence)) { 1677 case L_INCR: 1678 if (noneg && 1679 (fp->f_offset < 0 || 1680 (offset > 0 && fp->f_offset > OFF_MAX - offset))) --- 8 unchanged lines hidden (view full) --- 1689 (vattr.va_size > OFF_MAX || 1690 (offset > 0 && vattr.va_size > OFF_MAX - offset))) 1691 return (EOVERFLOW); 1692 offset += vattr.va_size; 1693 break; 1694 case L_SET: 1695 break; 1696 default: | 1720 vp = (struct vnode *)fp->f_data; 1721 noneg = (vp->v_type != VCHR); 1722 offset = SCARG(uap, offset); 1723 switch (SCARG(uap, whence)) { 1724 case L_INCR: 1725 if (noneg && 1726 (fp->f_offset < 0 || 1727 (offset > 0 && fp->f_offset > OFF_MAX - offset))) --- 8 unchanged lines hidden (view full) --- 1736 (vattr.va_size > OFF_MAX || 1737 (offset > 0 && vattr.va_size > OFF_MAX - offset))) 1738 return (EOVERFLOW); 1739 offset += vattr.va_size; 1740 break; 1741 case L_SET: 1742 break; 1743 default: |
1744 fdrop(fp, td); |
|
1697 return (EINVAL); 1698 } 1699 if (noneg && offset < 0) 1700 return (EINVAL); 1701 fp->f_offset = offset; 1702 *(off_t *)(td->td_retval) = fp->f_offset; | 1745 return (EINVAL); 1746 } 1747 if (noneg && offset < 0) 1748 return (EINVAL); 1749 fp->f_offset = offset; 1750 *(off_t *)(td->td_retval) = fp->f_offset; |
1751 fdrop(fp, td); |
|
1703 return (0); 1704} 1705 1706#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 1707/* 1708 * Reposition read/write file offset. 1709 */ 1710#ifndef _SYS_SYSPROTO_H_ --- 591 unchanged lines hidden (view full) --- 2302 syscallarg(int) flags; 2303 } */ *uap; 2304{ 2305 struct file *fp; 2306 int error; 2307 2308 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2309 return (error); | 1752 return (0); 1753} 1754 1755#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 1756/* 1757 * Reposition read/write file offset. 1758 */ 1759#ifndef _SYS_SYSPROTO_H_ --- 591 unchanged lines hidden (view full) --- 2351 syscallarg(int) flags; 2352 } */ *uap; 2353{ 2354 struct file *fp; 2355 int error; 2356 2357 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2358 return (error); |
2310 return setfflags(td, (struct vnode *) fp->f_data, SCARG(uap, flags)); | 2359 error = setfflags(td, (struct vnode *) fp->f_data, SCARG(uap, flags)); 2360 fdrop(fp, td); 2361 return (error); |
2311} 2312 2313/* 2314 * Common implementation code for chmod(), lchmod() and fchmod(). 2315 */ 2316static int 2317setfmode(td, vp, mode) 2318 struct thread *td; --- 90 unchanged lines hidden (view full) --- 2409fchmod(td, uap) 2410 struct thread *td; 2411 register struct fchmod_args /* { 2412 syscallarg(int) fd; 2413 syscallarg(int) mode; 2414 } */ *uap; 2415{ 2416 struct file *fp; | 2362} 2363 2364/* 2365 * Common implementation code for chmod(), lchmod() and fchmod(). 2366 */ 2367static int 2368setfmode(td, vp, mode) 2369 struct thread *td; --- 90 unchanged lines hidden (view full) --- 2460fchmod(td, uap) 2461 struct thread *td; 2462 register struct fchmod_args /* { 2463 syscallarg(int) fd; 2464 syscallarg(int) mode; 2465 } */ *uap; 2466{ 2467 struct file *fp; |
2468 struct vnode *vp; |
|
2417 int error; 2418 2419 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2420 return (error); | 2469 int error; 2470 2471 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2472 return (error); |
2421 return setfmode(td, (struct vnode *)fp->f_data, SCARG(uap, mode)); | 2473 vp = (struct vnode *)fp->f_data; 2474 error = setfmode(td, (struct vnode *)fp->f_data, SCARG(uap, mode)); 2475 fdrop(fp, td); 2476 return (error); |
2422} 2423 2424/* 2425 * Common implementation for chown(), lchown(), and fchown() 2426 */ 2427static int 2428setfown(td, vp, uid, gid) 2429 struct thread *td; --- 98 unchanged lines hidden (view full) --- 2528 struct thread *td; 2529 register struct fchown_args /* { 2530 syscallarg(int) fd; 2531 syscallarg(int) uid; 2532 syscallarg(int) gid; 2533 } */ *uap; 2534{ 2535 struct file *fp; | 2477} 2478 2479/* 2480 * Common implementation for chown(), lchown(), and fchown() 2481 */ 2482static int 2483setfown(td, vp, uid, gid) 2484 struct thread *td; --- 98 unchanged lines hidden (view full) --- 2583 struct thread *td; 2584 register struct fchown_args /* { 2585 syscallarg(int) fd; 2586 syscallarg(int) uid; 2587 syscallarg(int) gid; 2588 } */ *uap; 2589{ 2590 struct file *fp; |
2591 struct vnode *vp; |
|
2536 int error; 2537 2538 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2539 return (error); | 2592 int error; 2593 2594 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2595 return (error); |
2540 return setfown(td, (struct vnode *)fp->f_data, | 2596 vp = (struct vnode *)fp->f_data; 2597 error = setfown(td, (struct vnode *)fp->f_data, |
2541 SCARG(uap, uid), SCARG(uap, gid)); | 2598 SCARG(uap, uid), SCARG(uap, gid)); |
2599 fdrop(fp, td); 2600 return (error); |
|
2542} 2543 2544/* 2545 * Common implementation code for utimes(), lutimes(), and futimes(). 2546 */ 2547static int 2548getutimes(usrtvp, tsp) 2549 const struct timeval *usrtvp; --- 137 unchanged lines hidden (view full) --- 2687 struct timeval *usrtvp; 2688 int error; 2689 2690 usrtvp = SCARG(uap, tptr); 2691 if ((error = getutimes(usrtvp, ts)) != 0) 2692 return (error); 2693 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2694 return (error); | 2601} 2602 2603/* 2604 * Common implementation code for utimes(), lutimes(), and futimes(). 2605 */ 2606static int 2607getutimes(usrtvp, tsp) 2608 const struct timeval *usrtvp; --- 137 unchanged lines hidden (view full) --- 2746 struct timeval *usrtvp; 2747 int error; 2748 2749 usrtvp = SCARG(uap, tptr); 2750 if ((error = getutimes(usrtvp, ts)) != 0) 2751 return (error); 2752 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2753 return (error); |
2695 return setutimes(td, (struct vnode *)fp->f_data, ts, usrtvp == NULL); | 2754 error = setutimes(td, (struct vnode *)fp->f_data, ts, usrtvp == NULL); 2755 fdrop(fp, td); 2756 return (error); |
2696} 2697 2698/* 2699 * Truncate a file given its path name. 2700 */ 2701#ifndef _SYS_SYSPROTO_H_ 2702struct truncate_args { 2703 char *path; --- 68 unchanged lines hidden (view full) --- 2772 struct vnode *vp; 2773 struct file *fp; 2774 int error; 2775 2776 if (uap->length < 0) 2777 return(EINVAL); 2778 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2779 return (error); | 2757} 2758 2759/* 2760 * Truncate a file given its path name. 2761 */ 2762#ifndef _SYS_SYSPROTO_H_ 2763struct truncate_args { 2764 char *path; --- 68 unchanged lines hidden (view full) --- 2833 struct vnode *vp; 2834 struct file *fp; 2835 int error; 2836 2837 if (uap->length < 0) 2838 return(EINVAL); 2839 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2840 return (error); |
2780 if ((fp->f_flag & FWRITE) == 0) | 2841 if ((fp->f_flag & FWRITE) == 0) { 2842 fdrop(fp, td); |
2781 return (EINVAL); | 2843 return (EINVAL); |
2844 } |
|
2782 vp = (struct vnode *)fp->f_data; | 2845 vp = (struct vnode *)fp->f_data; |
2783 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) | 2846 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) { 2847 fdrop(fp, td); |
2784 return (error); | 2848 return (error); |
2849 } |
|
2785 VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); 2786 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 2787 if (vp->v_type == VDIR) 2788 error = EISDIR; 2789 else if ((error = vn_writechk(vp)) == 0) { 2790 VATTR_NULL(&vattr); 2791 vattr.va_size = SCARG(uap, length); 2792 error = VOP_SETATTR(vp, &vattr, fp->f_cred, td); 2793 } 2794 VOP_UNLOCK(vp, 0, td); 2795 vn_finished_write(mp); | 2850 VOP_LEASE(vp, td, td->td_proc->p_ucred, LEASE_WRITE); 2851 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 2852 if (vp->v_type == VDIR) 2853 error = EISDIR; 2854 else if ((error = vn_writechk(vp)) == 0) { 2855 VATTR_NULL(&vattr); 2856 vattr.va_size = SCARG(uap, length); 2857 error = VOP_SETATTR(vp, &vattr, fp->f_cred, td); 2858 } 2859 VOP_UNLOCK(vp, 0, td); 2860 vn_finished_write(mp); |
2861 fdrop(fp, td); |
|
2796 return (error); 2797} 2798 2799#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 2800/* 2801 * Truncate a file given its path name. 2802 */ 2803#ifndef _SYS_SYSPROTO_H_ --- 74 unchanged lines hidden (view full) --- 2878 vm_object_t obj; 2879 int error; 2880 2881 GIANT_REQUIRED; 2882 2883 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2884 return (error); 2885 vp = (struct vnode *)fp->f_data; | 2862 return (error); 2863} 2864 2865#if defined(COMPAT_43) || defined(COMPAT_SUNOS) 2866/* 2867 * Truncate a file given its path name. 2868 */ 2869#ifndef _SYS_SYSPROTO_H_ --- 74 unchanged lines hidden (view full) --- 2944 vm_object_t obj; 2945 int error; 2946 2947 GIANT_REQUIRED; 2948 2949 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 2950 return (error); 2951 vp = (struct vnode *)fp->f_data; |
2886 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) | 2952 if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) != 0) { 2953 fdrop(fp, td); |
2887 return (error); | 2954 return (error); |
2955 } |
|
2888 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 2889 if (VOP_GETVOBJECT(vp, &obj) == 0) { 2890 vm_object_page_clean(obj, 0, 0, 0); 2891 } 2892 error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, td); 2893#ifdef SOFTUPDATES 2894 if (error == 0 && vp->v_mount && (vp->v_mount->mnt_flag & MNT_SOFTDEP)) 2895 error = softdep_fsync(vp); 2896#endif 2897 2898 VOP_UNLOCK(vp, 0, td); 2899 vn_finished_write(mp); | 2956 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 2957 if (VOP_GETVOBJECT(vp, &obj) == 0) { 2958 vm_object_page_clean(obj, 0, 0, 0); 2959 } 2960 error = VOP_FSYNC(vp, fp->f_cred, MNT_WAIT, td); 2961#ifdef SOFTUPDATES 2962 if (error == 0 && vp->v_mount && (vp->v_mount->mnt_flag & MNT_SOFTDEP)) 2963 error = softdep_fsync(vp); 2964#endif 2965 2966 VOP_UNLOCK(vp, 0, td); 2967 vn_finished_write(mp); |
2968 fdrop(fp, td); |
|
2900 return (error); 2901} 2902 2903/* 2904 * Rename files. Source and destination must either both be directories, 2905 * or both not be directories. If target is a directory, it must be empty. 2906 */ 2907#ifndef _SYS_SYSPROTO_H_ --- 155 unchanged lines hidden (view full) --- 3063 NDFREE(&nd, NDF_ONLY_PNBUF); 3064 vput(nd.ni_dvp); 3065 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 3066 return (error); 3067 goto restart; 3068 } 3069 VATTR_NULL(&vattr); 3070 vattr.va_type = VDIR; | 2969 return (error); 2970} 2971 2972/* 2973 * Rename files. Source and destination must either both be directories, 2974 * or both not be directories. If target is a directory, it must be empty. 2975 */ 2976#ifndef _SYS_SYSPROTO_H_ --- 155 unchanged lines hidden (view full) --- 3132 NDFREE(&nd, NDF_ONLY_PNBUF); 3133 vput(nd.ni_dvp); 3134 if ((error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH)) != 0) 3135 return (error); 3136 goto restart; 3137 } 3138 VATTR_NULL(&vattr); 3139 vattr.va_type = VDIR; |
3140 FILEDESC_LOCK(td->td_proc->p_fd); |
|
3071 vattr.va_mode = (mode & ACCESSPERMS) &~ td->td_proc->p_fd->fd_cmask; | 3141 vattr.va_mode = (mode & ACCESSPERMS) &~ td->td_proc->p_fd->fd_cmask; |
3142 FILEDESC_UNLOCK(td->td_proc->p_fd); |
|
3072 VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); 3073 error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); 3074 NDFREE(&nd, NDF_ONLY_PNBUF); 3075 vput(nd.ni_dvp); 3076 if (!error) 3077 vput(nd.ni_vp); 3078 vn_finished_write(mp); 3079 ASSERT_VOP_UNLOCKED(nd.ni_dvp, "mkdir"); --- 105 unchanged lines hidden (view full) --- 3185 int error, eofflag, readcnt; 3186 long loff; 3187 3188 /* XXX arbitrary sanity limit on `count'. */ 3189 if (SCARG(uap, count) > 64 * 1024) 3190 return (EINVAL); 3191 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 3192 return (error); | 3143 VOP_LEASE(nd.ni_dvp, td, td->td_proc->p_ucred, LEASE_WRITE); 3144 error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr); 3145 NDFREE(&nd, NDF_ONLY_PNBUF); 3146 vput(nd.ni_dvp); 3147 if (!error) 3148 vput(nd.ni_vp); 3149 vn_finished_write(mp); 3150 ASSERT_VOP_UNLOCKED(nd.ni_dvp, "mkdir"); --- 105 unchanged lines hidden (view full) --- 3256 int error, eofflag, readcnt; 3257 long loff; 3258 3259 /* XXX arbitrary sanity limit on `count'. */ 3260 if (SCARG(uap, count) > 64 * 1024) 3261 return (EINVAL); 3262 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 3263 return (error); |
3193 if ((fp->f_flag & FREAD) == 0) | 3264 if ((fp->f_flag & FREAD) == 0) { 3265 fdrop(fp, td); |
3194 return (EBADF); | 3266 return (EBADF); |
3267 } |
|
3195 vp = (struct vnode *)fp->f_data; 3196unionread: | 3268 vp = (struct vnode *)fp->f_data; 3269unionread: |
3197 if (vp->v_type != VDIR) | 3270 if (vp->v_type != VDIR) { 3271 fdrop(fp, td); |
3198 return (EINVAL); | 3272 return (EINVAL); |
3273 } |
|
3199 aiov.iov_base = SCARG(uap, buf); 3200 aiov.iov_len = SCARG(uap, count); 3201 auio.uio_iov = &aiov; 3202 auio.uio_iovcnt = 1; 3203 auio.uio_rw = UIO_READ; 3204 auio.uio_segflg = UIO_USERSPACE; 3205 auio.uio_td = td; 3206 auio.uio_resid = SCARG(uap, count); --- 46 unchanged lines hidden (view full) --- 3253 } 3254 } 3255 if (dp >= edp) 3256 error = uiomove(dirbuf, readcnt, &auio); 3257 } 3258 FREE(dirbuf, M_TEMP); 3259 } 3260 VOP_UNLOCK(vp, 0, td); | 3274 aiov.iov_base = SCARG(uap, buf); 3275 aiov.iov_len = SCARG(uap, count); 3276 auio.uio_iov = &aiov; 3277 auio.uio_iovcnt = 1; 3278 auio.uio_rw = UIO_READ; 3279 auio.uio_segflg = UIO_USERSPACE; 3280 auio.uio_td = td; 3281 auio.uio_resid = SCARG(uap, count); --- 46 unchanged lines hidden (view full) --- 3328 } 3329 } 3330 if (dp >= edp) 3331 error = uiomove(dirbuf, readcnt, &auio); 3332 } 3333 FREE(dirbuf, M_TEMP); 3334 } 3335 VOP_UNLOCK(vp, 0, td); |
3261 if (error) | 3336 if (error) { 3337 fdrop(fp, td); |
3262 return (error); | 3338 return (error); |
3339 } |
|
3263 if (SCARG(uap, count) == auio.uio_resid) { 3264 if (union_dircheckp) { 3265 error = union_dircheckp(td, &vp, fp); 3266 if (error == -1) 3267 goto unionread; | 3340 if (SCARG(uap, count) == auio.uio_resid) { 3341 if (union_dircheckp) { 3342 error = union_dircheckp(td, &vp, fp); 3343 if (error == -1) 3344 goto unionread; |
3268 if (error) | 3345 if (error) { 3346 fdrop(fp, td); |
3269 return (error); | 3347 return (error); |
3348 } |
|
3270 } 3271 if ((vp->v_flag & VROOT) && 3272 (vp->v_mount->mnt_flag & MNT_UNION)) { 3273 struct vnode *tvp = vp; 3274 vp = vp->v_mount->mnt_vnodecovered; 3275 VREF(vp); 3276 fp->f_data = (caddr_t) vp; 3277 fp->f_offset = 0; 3278 vrele(tvp); 3279 goto unionread; 3280 } 3281 } 3282 error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), 3283 sizeof(long)); | 3349 } 3350 if ((vp->v_flag & VROOT) && 3351 (vp->v_mount->mnt_flag & MNT_UNION)) { 3352 struct vnode *tvp = vp; 3353 vp = vp->v_mount->mnt_vnodecovered; 3354 VREF(vp); 3355 fp->f_data = (caddr_t) vp; 3356 fp->f_offset = 0; 3357 vrele(tvp); 3358 goto unionread; 3359 } 3360 } 3361 error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), 3362 sizeof(long)); |
3363 fdrop(fp, td); |
|
3284 td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; 3285 return (error); 3286} 3287#endif /* COMPAT_43 */ 3288 3289/* 3290 * Read a block of directory entries in a file system independent format. 3291 */ --- 19 unchanged lines hidden (view full) --- 3311 struct file *fp; 3312 struct uio auio; 3313 struct iovec aiov; 3314 long loff; 3315 int error, eofflag; 3316 3317 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 3318 return (error); | 3364 td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; 3365 return (error); 3366} 3367#endif /* COMPAT_43 */ 3368 3369/* 3370 * Read a block of directory entries in a file system independent format. 3371 */ --- 19 unchanged lines hidden (view full) --- 3391 struct file *fp; 3392 struct uio auio; 3393 struct iovec aiov; 3394 long loff; 3395 int error, eofflag; 3396 3397 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 3398 return (error); |
3319 if ((fp->f_flag & FREAD) == 0) | 3399 if ((fp->f_flag & FREAD) == 0) { 3400 fdrop(fp, td); |
3320 return (EBADF); | 3401 return (EBADF); |
3402 } |
|
3321 vp = (struct vnode *)fp->f_data; 3322unionread: | 3403 vp = (struct vnode *)fp->f_data; 3404unionread: |
3323 if (vp->v_type != VDIR) | 3405 if (vp->v_type != VDIR) { 3406 fdrop(fp, td); |
3324 return (EINVAL); | 3407 return (EINVAL); |
3408 } |
|
3325 aiov.iov_base = SCARG(uap, buf); 3326 aiov.iov_len = SCARG(uap, count); 3327 auio.uio_iov = &aiov; 3328 auio.uio_iovcnt = 1; 3329 auio.uio_rw = UIO_READ; 3330 auio.uio_segflg = UIO_USERSPACE; 3331 auio.uio_td = td; 3332 auio.uio_resid = SCARG(uap, count); 3333 /* vn_lock(vp, LK_SHARED | LK_RETRY, td); */ 3334 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 3335 loff = auio.uio_offset = fp->f_offset; 3336 error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL, NULL); 3337 fp->f_offset = auio.uio_offset; 3338 VOP_UNLOCK(vp, 0, td); | 3409 aiov.iov_base = SCARG(uap, buf); 3410 aiov.iov_len = SCARG(uap, count); 3411 auio.uio_iov = &aiov; 3412 auio.uio_iovcnt = 1; 3413 auio.uio_rw = UIO_READ; 3414 auio.uio_segflg = UIO_USERSPACE; 3415 auio.uio_td = td; 3416 auio.uio_resid = SCARG(uap, count); 3417 /* vn_lock(vp, LK_SHARED | LK_RETRY, td); */ 3418 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 3419 loff = auio.uio_offset = fp->f_offset; 3420 error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, NULL, NULL); 3421 fp->f_offset = auio.uio_offset; 3422 VOP_UNLOCK(vp, 0, td); |
3339 if (error) | 3423 if (error) { 3424 fdrop(fp, td); |
3340 return (error); | 3425 return (error); |
3426 } |
|
3341 if (SCARG(uap, count) == auio.uio_resid) { 3342 if (union_dircheckp) { 3343 error = union_dircheckp(td, &vp, fp); 3344 if (error == -1) 3345 goto unionread; | 3427 if (SCARG(uap, count) == auio.uio_resid) { 3428 if (union_dircheckp) { 3429 error = union_dircheckp(td, &vp, fp); 3430 if (error == -1) 3431 goto unionread; |
3346 if (error) | 3432 if (error) { 3433 fdrop(fp, td); |
3347 return (error); | 3434 return (error); |
3435 } |
|
3348 } 3349 if ((vp->v_flag & VROOT) && 3350 (vp->v_mount->mnt_flag & MNT_UNION)) { 3351 struct vnode *tvp = vp; 3352 vp = vp->v_mount->mnt_vnodecovered; 3353 VREF(vp); 3354 fp->f_data = (caddr_t) vp; 3355 fp->f_offset = 0; 3356 vrele(tvp); 3357 goto unionread; 3358 } 3359 } 3360 if (SCARG(uap, basep) != NULL) { 3361 error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), 3362 sizeof(long)); 3363 } 3364 td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; | 3436 } 3437 if ((vp->v_flag & VROOT) && 3438 (vp->v_mount->mnt_flag & MNT_UNION)) { 3439 struct vnode *tvp = vp; 3440 vp = vp->v_mount->mnt_vnodecovered; 3441 VREF(vp); 3442 fp->f_data = (caddr_t) vp; 3443 fp->f_offset = 0; 3444 vrele(tvp); 3445 goto unionread; 3446 } 3447 } 3448 if (SCARG(uap, basep) != NULL) { 3449 error = copyout((caddr_t)&loff, (caddr_t)SCARG(uap, basep), 3450 sizeof(long)); 3451 } 3452 td->td_retval[0] = SCARG(uap, count) - auio.uio_resid; |
3453 fdrop(fp, td); |
|
3365 return (error); 3366} 3367#ifndef _SYS_SYSPROTO_H_ 3368struct getdents_args { 3369 int fd; 3370 char *buf; 3371 size_t count; 3372}; --- 29 unchanged lines hidden (view full) --- 3402umask(td, uap) 3403 struct thread *td; 3404 struct umask_args /* { 3405 syscallarg(int) newmask; 3406 } */ *uap; 3407{ 3408 register struct filedesc *fdp; 3409 | 3454 return (error); 3455} 3456#ifndef _SYS_SYSPROTO_H_ 3457struct getdents_args { 3458 int fd; 3459 char *buf; 3460 size_t count; 3461}; --- 29 unchanged lines hidden (view full) --- 3491umask(td, uap) 3492 struct thread *td; 3493 struct umask_args /* { 3494 syscallarg(int) newmask; 3495 } */ *uap; 3496{ 3497 register struct filedesc *fdp; 3498 |
3499 FILEDESC_LOCK(td->td_proc->p_fd); |
|
3410 fdp = td->td_proc->p_fd; 3411 td->td_retval[0] = fdp->fd_cmask; 3412 fdp->fd_cmask = SCARG(uap, newmask) & ALLPERMS; | 3500 fdp = td->td_proc->p_fd; 3501 td->td_retval[0] = fdp->fd_cmask; 3502 fdp->fd_cmask = SCARG(uap, newmask) & ALLPERMS; |
3503 FILEDESC_UNLOCK(td->td_proc->p_fd); |
|
3413 return (0); 3414} 3415 3416/* 3417 * Void all references to file by ripping underlying filesystem 3418 * away from vnode. 3419 */ 3420#ifndef _SYS_SYSPROTO_H_ --- 39 unchanged lines hidden (view full) --- 3460 vn_finished_write(mp); 3461out: 3462 vrele(vp); 3463 return (error); 3464} 3465 3466/* 3467 * Convert a user file descriptor to a kernel file entry. | 3504 return (0); 3505} 3506 3507/* 3508 * Void all references to file by ripping underlying filesystem 3509 * away from vnode. 3510 */ 3511#ifndef _SYS_SYSPROTO_H_ --- 39 unchanged lines hidden (view full) --- 3551 vn_finished_write(mp); 3552out: 3553 vrele(vp); 3554 return (error); 3555} 3556 3557/* 3558 * Convert a user file descriptor to a kernel file entry. |
3559 * The file entry is locked upon returning. |
|
3468 */ 3469int 3470getvnode(fdp, fd, fpp) 3471 struct filedesc *fdp; 3472 int fd; 3473 struct file **fpp; 3474{ | 3560 */ 3561int 3562getvnode(fdp, fd, fpp) 3563 struct filedesc *fdp; 3564 int fd; 3565 struct file **fpp; 3566{ |
3567 int error; |
|
3475 struct file *fp; 3476 | 3568 struct file *fp; 3569 |
3477 if ((u_int)fd >= fdp->fd_nfiles || 3478 (fp = fdp->fd_ofiles[fd]) == NULL) 3479 return (EBADF); 3480 if (fp->f_type != DTYPE_VNODE && fp->f_type != DTYPE_FIFO) 3481 return (EINVAL); | 3570 fp = NULL; 3571 if (fdp == NULL) 3572 error = EBADF; 3573 else { 3574 FILEDESC_LOCK(fdp); 3575 if ((u_int)fd >= fdp->fd_nfiles || 3576 (fp = fdp->fd_ofiles[fd]) == NULL) 3577 error = EBADF; 3578 else if (fp->f_type != DTYPE_VNODE && fp->f_type != DTYPE_FIFO) { 3579 fp = NULL; 3580 error = EINVAL; 3581 } else { 3582 fhold(fp); 3583 error = 0; 3584 } 3585 FILEDESC_UNLOCK(fdp); 3586 } |
3482 *fpp = fp; | 3587 *fpp = fp; |
3483 return (0); | 3588 return (error); |
3484} 3485/* 3486 * Get (NFS) file handle 3487 */ 3488#ifndef _SYS_SYSPROTO_H_ 3489struct getfh_args { 3490 char *fname; 3491 fhandle_t *fhp; --- 184 unchanged lines hidden (view full) --- 3676 type |= F_WAIT; 3677 VOP_UNLOCK(vp, 0, td); 3678 if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) != 0) { 3679 /* 3680 * The lock request failed. Normally close the 3681 * descriptor but handle the case where someone might 3682 * have dup()d or close()d it when we weren't looking. 3683 */ | 3589} 3590/* 3591 * Get (NFS) file handle 3592 */ 3593#ifndef _SYS_SYSPROTO_H_ 3594struct getfh_args { 3595 char *fname; 3596 fhandle_t *fhp; --- 184 unchanged lines hidden (view full) --- 3781 type |= F_WAIT; 3782 VOP_UNLOCK(vp, 0, td); 3783 if ((error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, type)) != 0) { 3784 /* 3785 * The lock request failed. Normally close the 3786 * descriptor but handle the case where someone might 3787 * have dup()d or close()d it when we weren't looking. 3788 */ |
3789 FILEDESC_LOCK(fdp); |
|
3684 if (fdp->fd_ofiles[indx] == fp) { 3685 fdp->fd_ofiles[indx] = NULL; | 3790 if (fdp->fd_ofiles[indx] == fp) { 3791 fdp->fd_ofiles[indx] = NULL; |
3792 FILEDESC_UNLOCK(fdp); |
|
3686 fdrop(fp, td); | 3793 fdrop(fp, td); |
3687 } | 3794 } else 3795 FILEDESC_UNLOCK(fdp); |
3688 /* 3689 * release our private reference 3690 */ 3691 fdrop(fp, td); 3692 return(error); 3693 } 3694 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 3695 fp->f_flag |= FHASLOCK; --- 294 unchanged lines hidden (view full) --- 3990 return (error); 3991 3992 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 3993 return (error); 3994 3995 error = extattr_set_vp((struct vnode *)fp->f_data, 3996 SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), 3997 SCARG(uap, iovcnt), td); | 3796 /* 3797 * release our private reference 3798 */ 3799 fdrop(fp, td); 3800 return(error); 3801 } 3802 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 3803 fp->f_flag |= FHASLOCK; --- 294 unchanged lines hidden (view full) --- 4098 return (error); 4099 4100 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 4101 return (error); 4102 4103 error = extattr_set_vp((struct vnode *)fp->f_data, 4104 SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), 4105 SCARG(uap, iovcnt), td); |
4106 fdrop(fp, td); |
|
3998 3999 return (error); 4000} 4001 4002/* 4003 * extattr_get_vp(): Get a named extended attribute on a file or directory 4004 * 4005 * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace", --- 97 unchanged lines hidden (view full) --- 4103 4104 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 4105 return (error); 4106 4107 error = extattr_get_vp((struct vnode *)fp->f_data, 4108 SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), 4109 SCARG(uap, iovcnt), td); 4110 | 4107 4108 return (error); 4109} 4110 4111/* 4112 * extattr_get_vp(): Get a named extended attribute on a file or directory 4113 * 4114 * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace", --- 97 unchanged lines hidden (view full) --- 4212 4213 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 4214 return (error); 4215 4216 error = extattr_get_vp((struct vnode *)fp->f_data, 4217 SCARG(uap, attrnamespace), attrname, SCARG(uap, iovp), 4218 SCARG(uap, iovcnt), td); 4219 |
4220 fdrop(fp, td); |
|
4111 return (error); 4112} 4113 4114/* 4115 * extattr_delete_vp(): Delete a named extended attribute on a file or 4116 * directory 4117 * 4118 * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace", --- 49 unchanged lines hidden (view full) --- 4168} 4169 4170int 4171extattr_delete_fd(td, uap) 4172 struct thread *td; 4173 struct extattr_delete_fd_args *uap; 4174{ 4175 struct file *fp; | 4221 return (error); 4222} 4223 4224/* 4225 * extattr_delete_vp(): Delete a named extended attribute on a file or 4226 * directory 4227 * 4228 * Arguments: unlocked vnode "vp", attribute namespace "attrnamespace", --- 49 unchanged lines hidden (view full) --- 4278} 4279 4280int 4281extattr_delete_fd(td, uap) 4282 struct thread *td; 4283 struct extattr_delete_fd_args *uap; 4284{ 4285 struct file *fp; |
4286 struct vnode *vp; |
|
4176 char attrname[EXTATTR_MAXNAMELEN]; 4177 int error; 4178 4179 error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, 4180 NULL); 4181 if (error) 4182 return (error); 4183 4184 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 4185 return (error); | 4287 char attrname[EXTATTR_MAXNAMELEN]; 4288 int error; 4289 4290 error = copyinstr(SCARG(uap, attrname), attrname, EXTATTR_MAXNAMELEN, 4291 NULL); 4292 if (error) 4293 return (error); 4294 4295 if ((error = getvnode(td->td_proc->p_fd, SCARG(uap, fd), &fp)) != 0) 4296 return (error); |
4297 vp = (struct vnode *)fp->f_data; |
|
4186 4187 error = extattr_delete_vp((struct vnode *)fp->f_data, 4188 SCARG(uap, attrnamespace), attrname, td); 4189 | 4298 4299 error = extattr_delete_vp((struct vnode *)fp->f_data, 4300 SCARG(uap, attrnamespace), attrname, td); 4301 |
4302 fdrop(fp, td); |
|
4190 return (error); 4191} | 4303 return (error); 4304} |