/*===========================================================================* * fetch_name * *===========================================================================*/ int fetch_name(vir_bytes path, size_t len, char *dest) { /* Go get path and put it in 'dest'. */ int r; if (len > PATH_MAX) { /* 'len' includes terminating-nul */ err_code = ENAMETOOLONG; return(EGENERIC); } /* Check name length for validity. */ if (len > SSIZE_MAX) { err_code = EINVAL; return(EGENERIC); } /* String is not contained in the message. Get it from user space. */ r = sys_datacopy_wrapper(who_e, path, VFS_PROC_NR, (vir_bytes) dest, len); if (r != OK) { err_code = EINVAL; return(r); } if (dest[len - 1] != '\0') { err_code = ENAMETOOLONG; return(EGENERIC); } return(OK); }
/*===========================================================================* * fill_statvfs * *===========================================================================*/ static int fill_statvfs(struct vmnt *vmp, endpoint_t endpt, vir_bytes buf_addr, int flags) { /* Fill a statvfs structure in a userspace process. First let the target file * server fill in most fields, or use the cached copy if ST_NOWAIT is given. * Then fill in some remaining fields with local information. Finally, copy * the result to user space. */ struct statvfs buf; if (!(flags & ST_NOWAIT)) { /* Get fresh statistics from the file system. */ if (update_statvfs(vmp, &buf) != OK) return EIO; } else { /* Use the cached statistics. */ memset(&buf, 0, sizeof(buf)); buf.f_flag = vmp->m_stats.f_flag; buf.f_bsize = vmp->m_stats.f_bsize; buf.f_frsize = vmp->m_stats.f_frsize; buf.f_iosize = vmp->m_stats.f_iosize; buf.f_blocks = vmp->m_stats.f_blocks; buf.f_bfree = vmp->m_stats.f_bfree; buf.f_bavail = vmp->m_stats.f_bavail; buf.f_bresvd = vmp->m_stats.f_bresvd; buf.f_files = vmp->m_stats.f_files; buf.f_ffree = vmp->m_stats.f_ffree; buf.f_favail = vmp->m_stats.f_favail; buf.f_fresvd = vmp->m_stats.f_fresvd; buf.f_syncreads = vmp->m_stats.f_syncreads; buf.f_syncwrites = vmp->m_stats.f_syncwrites; buf.f_asyncreads = vmp->m_stats.f_asyncreads; buf.f_asyncwrites = vmp->m_stats.f_asyncwrites; buf.f_namemax = vmp->m_stats.f_namemax; } if (vmp->m_flags & VMNT_READONLY) buf.f_flag |= ST_RDONLY; buf.f_fsid = (unsigned long)vmp->m_dev; buf.f_fsidx.__fsid_val[0] = (long)vmp->m_dev; /* This is what is done on NetBSD */ buf.f_fsidx.__fsid_val[1] = 0; /* Here they convert the FS type name into a number. */ strlcpy(buf.f_fstypename, vmp->m_fstype, sizeof(buf.f_fstypename)); strlcpy(buf.f_mntonname, vmp->m_mount_path, sizeof(buf.f_mntonname)); strlcpy(buf.f_mntfromname, vmp->m_mount_dev, sizeof(buf.f_mntfromname)); return sys_datacopy_wrapper(SELF, (vir_bytes) &buf, endpt, buf_addr, sizeof(buf)); }
/*===========================================================================* * do_getsysinfo * *===========================================================================*/ int do_getsysinfo(void) { vir_bytes src_addr, dst_addr; size_t len, buf_size; int what; what = job_m_in.m_lsys_getsysinfo.what; dst_addr = job_m_in.m_lsys_getsysinfo.where; buf_size = job_m_in.m_lsys_getsysinfo.size; /* Only su may call do_getsysinfo. This call may leak information (and is not * stable enough to be part of the API/ABI). In the future, requests from * non-system processes should be denied. */ if (!super_user) return(EPERM); switch(what) { case SI_PROC_TAB: src_addr = (vir_bytes) fproc; len = sizeof(struct fproc) * NR_PROCS; break; case SI_DMAP_TAB: src_addr = (vir_bytes) dmap; len = sizeof(struct dmap) * NR_DEVICES; break; #if ENABLE_SYSCALL_STATS case SI_CALL_STATS: src_addr = (vir_bytes) calls_stats; len = sizeof(calls_stats); break; #endif default: return(EINVAL); } if (len != buf_size) return(EINVAL); return sys_datacopy_wrapper(SELF, src_addr, who_e, dst_addr, len); }
/*===========================================================================* * do_fcntl * *===========================================================================*/ int do_fcntl(void) { /* Perform the fcntl(fd, cmd, ...) system call. */ register struct filp *f; int new_fd, fl, r = OK, fcntl_req, fcntl_argx; tll_access_t locktype; scratch(fp).file.fd_nr = job_m_in.m_lc_vfs_fcntl.fd; scratch(fp).io.io_buffer = job_m_in.m_lc_vfs_fcntl.arg_ptr; scratch(fp).io.io_nbytes = job_m_in.m_lc_vfs_fcntl.cmd; fcntl_req = job_m_in.m_lc_vfs_fcntl.cmd; fcntl_argx = job_m_in.m_lc_vfs_fcntl.arg_int; /* Is the file descriptor valid? */ locktype = (fcntl_req == F_FREESP) ? VNODE_WRITE : VNODE_READ; if ((f = get_filp(scratch(fp).file.fd_nr, locktype)) == NULL) return(err_code); switch (fcntl_req) { case F_DUPFD: /* This replaces the old dup() system call. */ if (fcntl_argx < 0 || fcntl_argx >= OPEN_MAX) r = EINVAL; else if ((r = get_fd(fp, fcntl_argx, 0, &new_fd, NULL)) == OK) { f->filp_count++; fp->fp_filp[new_fd] = f; r = new_fd; } break; case F_GETFD: /* Get close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */ r = 0; if (FD_ISSET(scratch(fp).file.fd_nr, &fp->fp_cloexec_set)) r = FD_CLOEXEC; break; case F_SETFD: /* Set close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */ if (fcntl_argx & FD_CLOEXEC) FD_SET(scratch(fp).file.fd_nr, &fp->fp_cloexec_set); else FD_CLR(scratch(fp).file.fd_nr, &fp->fp_cloexec_set); break; case F_GETFL: /* Get file status flags (O_NONBLOCK and O_APPEND). */ fl = f->filp_flags & (O_NONBLOCK | O_APPEND | O_ACCMODE); r = fl; break; case F_SETFL: /* Set file status flags (O_NONBLOCK and O_APPEND). */ fl = O_NONBLOCK | O_APPEND; f->filp_flags = (f->filp_flags & ~fl) | (fcntl_argx & fl); break; case F_GETLK: case F_SETLK: case F_SETLKW: /* Set or clear a file lock. */ r = lock_op(f, fcntl_req); break; case F_FREESP: { /* Free a section of a file */ off_t start, end, offset; struct flock flock_arg; /* Check if it's a regular file. */ if (!S_ISREG(f->filp_vno->v_mode)) r = EINVAL; else if (!(f->filp_mode & W_BIT)) r = EBADF; else { /* Copy flock data from userspace. */ r = sys_datacopy_wrapper(who_e, scratch(fp).io.io_buffer, SELF, (vir_bytes) &flock_arg, sizeof(flock_arg)); } if (r != OK) break; /* Convert starting offset to signed. */ offset = (off_t) flock_arg.l_start; /* Figure out starting position base. */ switch(flock_arg.l_whence) { case SEEK_SET: start = 0; break; case SEEK_CUR: start = f->filp_pos; break; case SEEK_END: start = f->filp_vno->v_size; break; default: r = EINVAL; } if (r != OK) break; /* Check for overflow or underflow. */ if (offset > 0 && start + offset < start) r = EINVAL; else if (offset < 0 && start + offset > start) r = EINVAL; else { start += offset; if (start < 0) r = EINVAL; } if (r != OK) break; if (flock_arg.l_len != 0) { if (start >= f->filp_vno->v_size) r = EINVAL; else if ((end = start + flock_arg.l_len) <= start) r = EINVAL; else if (end > f->filp_vno->v_size) end = f->filp_vno->v_size; } else { end = 0; } if (r != OK) break; r = req_ftrunc(f->filp_vno->v_fs_e, f->filp_vno->v_inode_nr,start,end); if (r == OK && flock_arg.l_len == 0) f->filp_vno->v_size = start; break; } case F_GETNOSIGPIPE: r = !!(f->filp_flags & O_NOSIGPIPE); break; case F_SETNOSIGPIPE: if (fcntl_argx) f->filp_flags |= O_NOSIGPIPE; else f->filp_flags &= ~O_NOSIGPIPE; break; case F_FLUSH_FS_CACHE: { struct vnode *vn = f->filp_vno; mode_t mode = f->filp_vno->v_mode; if (!super_user) { r = EPERM; } else if (S_ISBLK(mode)) { /* Block device; flush corresponding device blocks. */ r = req_flush(vn->v_bfs_e, vn->v_sdev); } else if (S_ISREG(mode) || S_ISDIR(mode)) { /* Directory or regular file; flush hosting FS blocks. */ r = req_flush(vn->v_fs_e, vn->v_dev); } else { /* Remaining cases.. Meaning unclear. */ r = ENODEV; } break; } default: r = EINVAL; } unlock_filp(f); return(r); }