/*===========================================================================* * do_statvfs * *===========================================================================*/ int do_statvfs(void) { /* Perform the statvfs1(name, buf, flags) system call. */ int r, flags; struct vnode *vp; struct vmnt *vmp; char fullpath[PATH_MAX]; struct lookup resolve; vir_bytes vname1, statbuf; size_t vname1_length; vname1 = job_m_in.m_lc_vfs_statvfs1.name; vname1_length = job_m_in.m_lc_vfs_statvfs1.len; statbuf = job_m_in.m_lc_vfs_statvfs1.buf; flags = job_m_in.m_lc_vfs_statvfs1.flags; lookup_init(&resolve, fullpath, PATH_NOFLAGS, &vmp, &vp); resolve.l_vmnt_lock = VMNT_READ; resolve.l_vnode_lock = VNODE_READ; if (fetch_name(vname1, vname1_length, fullpath) != OK) return(err_code); if ((vp = eat_path(&resolve, fp)) == NULL) return(err_code); r = fill_statvfs(vp->v_vmnt, who_e, statbuf, flags); unlock_vnode(vp); unlock_vmnt(vmp); put_vnode(vp); return r; }
int fstatvfs(int fd, struct statvfs *statvfs) { struct stat stat; if (fstat(fd, &stat) < 0) return -1; return fill_statvfs(stat.st_dev, statvfs); }
int statvfs(const char *path, struct statvfs *statvfs) { dev_t device = dev_for_path(path); if (device < 0) return -1; return fill_statvfs(device, statvfs); }
/*===========================================================================* * do_fstatvfs * *===========================================================================*/ int do_fstatvfs(void) { /* Perform the fstatvfs1(fd, buf, flags) system call. */ register struct filp *rfilp; int r, rfd, flags; vir_bytes statbuf; rfd = job_m_in.m_lc_vfs_statvfs1.fd; statbuf = job_m_in.m_lc_vfs_statvfs1.buf; flags = job_m_in.m_lc_vfs_statvfs1.flags; /* Is the file descriptor valid? */ if ((rfilp = get_filp(rfd, VNODE_READ)) == NULL) return(err_code); r = fill_statvfs(rfilp->filp_vno->v_vmnt, who_e, statbuf, flags); unlock_filp(rfilp); return(r); }
/*===========================================================================* * do_getvfsstat * *===========================================================================*/ int do_getvfsstat(void) { /* Perform the getvfsstat(buf, bufsize, flags) system call. */ struct vmnt *vmp; vir_bytes buf; size_t bufsize; int r, flags, count, do_lock; buf = job_m_in.m_lc_vfs_getvfsstat.buf; bufsize = job_m_in.m_lc_vfs_getvfsstat.len; flags = job_m_in.m_lc_vfs_getvfsstat.flags; count = 0; if (buf != 0) { /* We only need to lock target file systems if we are going to query * them. This will only happen if ST_NOWAIT is not given. If we do * not lock, we rely on the VMNT_CANSTAT flag to protect us from * concurrent (un)mount operations. Note that procfs relies on * ST_NOWAIT calls being lock free, as it is a file system itself. */ do_lock = !(flags & ST_NOWAIT); for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) { /* If there is no more space, return the count so far. */ if (bufsize < sizeof(struct statvfs)) break; /* Lock the file system before checking any fields. */ if (do_lock && (r = lock_vmnt(vmp, VMNT_READ)) != OK) return r; /* Obtain information for this file system, if it is in use and * can be reported. File systems that are being (un)mounted * are skipped, as is PFS. The fill call will block only if * ST_NOWAIT was not given. */ if (vmp->m_dev != NO_DEV && (vmp->m_flags & VMNT_CANSTAT)) { if ((r = fill_statvfs(vmp, who_e, buf, flags)) != OK) { if (do_lock) unlock_vmnt(vmp); return r; } count++; buf += sizeof(struct statvfs); bufsize -= sizeof(struct statvfs); } if (do_lock) unlock_vmnt(vmp); } } else { /* Just report a file system count. No need to lock, as above. */ for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; vmp++) { if (vmp->m_dev != NO_DEV && (vmp->m_flags & VMNT_CANSTAT)) count++; } } return count; }