ibcs2_stat.c revision 24203
197403Sobrien/* 297403Sobrien * Copyright (c) 1995 Scott Bartram 397403Sobrien * Copyright (c) 1995 Steven Wallace 4132720Skan * All rights reserved. 597403Sobrien * 6132720Skan * Redistribution and use in source and binary forms, with or without 797403Sobrien * modification, are permitted provided that the following conditions 897403Sobrien * are met: 997403Sobrien * 1. Redistributions of source code must retain the above copyright 1097403Sobrien * notice, this list of conditions and the following disclaimer. 11132720Skan * 2. Redistributions in binary form must reproduce the above copyright 1297403Sobrien * notice, this list of conditions and the following disclaimer in the 1397403Sobrien * documentation and/or other materials provided with the distribution. 1497403Sobrien * 3. The name of the author may not be used to endorse or promote products 1597403Sobrien * derived from this software without specific prior written permission 1697403Sobrien * 17132720Skan * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18169691Skan * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19169691Skan * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 2097403Sobrien * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 2197403Sobrien * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 2297403Sobrien * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2397403Sobrien * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2497403Sobrien * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2597403Sobrien * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 2697403Sobrien * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2797403Sobrien */ 2897403Sobrien 2997403Sobrien#include <sys/param.h> 3097403Sobrien#include <sys/systm.h> 31169691Skan#include <sys/namei.h> 3297403Sobrien#include <sys/proc.h> 3397403Sobrien#include <sys/file.h> 34169691Skan#include <sys/stat.h> 35132720Skan#include <sys/filedesc.h> 3697403Sobrien#include <sys/kernel.h> 3797403Sobrien#include <sys/mount.h> 3897403Sobrien#include <sys/malloc.h> 3997403Sobrien#include <sys/vnode.h> 4097403Sobrien#include <sys/sysctl.h> 4197403Sobrien#include <sys/sysproto.h> 4297403Sobrien 4397403Sobrien#include <vm/vm.h> 44102782Skan 45102782Skan#include <i386/ibcs2/ibcs2_types.h> 4697403Sobrien#include <i386/ibcs2/ibcs2_fcntl.h> 47169691Skan#include <i386/ibcs2/ibcs2_signal.h> 48169691Skan#include <i386/ibcs2/ibcs2_stat.h> 49169691Skan#include <i386/ibcs2/ibcs2_statfs.h> 5097403Sobrien#include <i386/ibcs2/ibcs2_proto.h> 5197403Sobrien#include <i386/ibcs2/ibcs2_ustat.h> 52169691Skan#include <i386/ibcs2/ibcs2_util.h> 5397403Sobrien#include <i386/ibcs2/ibcs2_utsname.h> 5497403Sobrien 5597403Sobrienstatic void bsd_stat2ibcs_stat __P((struct stat *, struct ibcs2_stat *)); 5697403Sobrienstatic int cvt_statfs __P((struct statfs *, caddr_t, int)); 57 58static void 59bsd_stat2ibcs_stat(st, st4) 60 struct stat *st; 61 struct ibcs2_stat *st4; 62{ 63 bzero(st4, sizeof(*st4)); 64 st4->st_dev = (ibcs2_dev_t)st->st_dev; 65 st4->st_ino = (ibcs2_ino_t)st->st_ino; 66 st4->st_mode = (ibcs2_mode_t)st->st_mode; 67 st4->st_nlink= (ibcs2_nlink_t)st->st_nlink; 68 st4->st_uid = (ibcs2_uid_t)st->st_uid; 69 st4->st_gid = (ibcs2_gid_t)st->st_gid; 70 st4->st_rdev = (ibcs2_dev_t)st->st_rdev; 71 if (st->st_size < (quad_t)1 << 32) 72 st4->st_size = (ibcs2_off_t)st->st_size; 73 else 74 st4->st_size = -2; 75 st4->st_atim = (ibcs2_time_t)st->st_atime; 76 st4->st_mtim = (ibcs2_time_t)st->st_mtime; 77 st4->st_ctim = (ibcs2_time_t)st->st_ctime; 78} 79 80static int 81cvt_statfs(sp, buf, len) 82 struct statfs *sp; 83 caddr_t buf; 84 int len; 85{ 86 struct ibcs2_statfs ssfs; 87 88 bzero(&ssfs, sizeof ssfs); 89 ssfs.f_fstyp = 0; 90 ssfs.f_bsize = sp->f_bsize; 91 ssfs.f_frsize = 0; 92 ssfs.f_blocks = sp->f_blocks; 93 ssfs.f_bfree = sp->f_bfree; 94 ssfs.f_files = sp->f_files; 95 ssfs.f_ffree = sp->f_ffree; 96 ssfs.f_fname[0] = 0; 97 ssfs.f_fpack[0] = 0; 98 return copyout((caddr_t)&ssfs, buf, len); 99} 100 101int 102ibcs2_statfs(p, uap, retval) 103 struct proc *p; 104 struct ibcs2_statfs_args *uap; 105 int *retval; 106{ 107 register struct mount *mp; 108 register struct statfs *sp; 109 int error; 110 struct nameidata nd; 111 caddr_t sg = stackgap_init(); 112 113 CHECKALTEXIST(p, &sg, SCARG(uap, path)); 114 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p); 115 if (error = namei(&nd)) 116 return (error); 117 mp = nd.ni_vp->v_mount; 118 sp = &mp->mnt_stat; 119 vrele(nd.ni_vp); 120 if (error = VFS_STATFS(mp, sp, p)) 121 return (error); 122 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 123 return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len)); 124} 125 126int 127ibcs2_fstatfs(p, uap, retval) 128 struct proc *p; 129 struct ibcs2_fstatfs_args *uap; 130 int *retval; 131{ 132 struct file *fp; 133 struct mount *mp; 134 register struct statfs *sp; 135 int error; 136 137 if (error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) 138 return (error); 139 mp = ((struct vnode *)fp->f_data)->v_mount; 140 sp = &mp->mnt_stat; 141 if (error = VFS_STATFS(mp, sp, p)) 142 return (error); 143 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 144 return cvt_statfs(sp, (caddr_t)SCARG(uap, buf), SCARG(uap, len)); 145} 146 147int 148ibcs2_stat(p, uap, retval) 149 struct proc *p; 150 struct ibcs2_stat_args *uap; 151 int *retval; 152{ 153 struct stat st; 154 struct ibcs2_stat ibcs2_st; 155 struct stat_args cup; 156 int error; 157 caddr_t sg = stackgap_init(); 158 159 CHECKALTEXIST(p, &sg, SCARG(uap, path)); 160 SCARG(&cup, path) = SCARG(uap, path); 161 SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st)); 162 163 if (error = stat(p, &cup, retval)) 164 return error; 165 166 if (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) 167 return error; 168 bsd_stat2ibcs_stat(&st, &ibcs2_st); 169 return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st), 170 ibcs2_stat_len); 171} 172 173int 174ibcs2_lstat(p, uap, retval) 175 struct proc *p; 176 struct ibcs2_lstat_args *uap; 177 int *retval; 178{ 179 struct stat st; 180 struct ibcs2_stat ibcs2_st; 181 struct lstat_args cup; 182 int error; 183 caddr_t sg = stackgap_init(); 184 185 CHECKALTEXIST(p, &sg, SCARG(uap, path)); 186 SCARG(&cup, path) = SCARG(uap, path); 187 SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(st)); 188 189 if (error = lstat(p, &cup, retval)) 190 return error; 191 192 if (error = copyin(SCARG(&cup, ub), &st, sizeof(st))) 193 return error; 194 bsd_stat2ibcs_stat(&st, &ibcs2_st); 195 return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st), 196 ibcs2_stat_len); 197} 198 199int 200ibcs2_fstat(p, uap, retval) 201 struct proc *p; 202 struct ibcs2_fstat_args *uap; 203 int *retval; 204{ 205 struct stat st; 206 struct ibcs2_stat ibcs2_st; 207 struct fstat_args cup; 208 int error; 209 caddr_t sg = stackgap_init(); 210 211 SCARG(&cup, fd) = SCARG(uap, fd); 212 SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(st)); 213 214 if (error = fstat(p, &cup, retval)) 215 return error; 216 217 if (error = copyin(SCARG(&cup, sb), &st, sizeof(st))) 218 return error; 219 bsd_stat2ibcs_stat(&st, &ibcs2_st); 220 return copyout((caddr_t)&ibcs2_st, (caddr_t)SCARG(uap, st), 221 ibcs2_stat_len); 222} 223 224int 225ibcs2_utssys(p, uap, retval) 226 struct proc *p; 227 struct ibcs2_utssys_args *uap; 228 int *retval; 229{ 230 switch (SCARG(uap, flag)) { 231 case 0: /* uname(2) */ 232 { 233 char machine_name[9], *p; 234 struct ibcs2_utsname sut; 235 bzero(&sut, ibcs2_utsname_len); 236 237 strncpy(sut.sysname, IBCS2_UNAME_SYSNAME, sizeof(sut.sysname)); 238 strncpy(sut.release, IBCS2_UNAME_RELEASE, sizeof(sut.release)); 239 strncpy(sut.version, IBCS2_UNAME_VERSION, sizeof(sut.version)); 240 strncpy(machine_name, hostname, sizeof(machine_name)); 241 p = index(machine_name, '.'); 242 if ( p ) 243 *p = '\0'; 244 strncpy(sut.nodename, machine_name, sizeof(sut.nodename)); 245 strncpy(sut.machine, machine, sizeof(sut.machine)); 246 sut.sysname[sizeof(sut.sysname)-1] = '\0'; 247 sut.release[sizeof(sut.release)-1] = '\0'; 248 sut.version[sizeof(sut.version)-1] = '\0'; 249 sut.nodename[sizeof(sut.nodename)-1] = '\0'; 250 sut.machine[sizeof(sut.machine)-1] = '\0'; 251 252 DPRINTF(("IBCS2 uname: sys=%s rel=%s ver=%s node=%s mach=%s\n", 253 sut.sysname, sut.release, sut.version, sut.nodename, 254 sut.machine)); 255 return copyout((caddr_t)&sut, (caddr_t)SCARG(uap, a1), 256 ibcs2_utsname_len); 257 } 258 259 case 2: /* ustat(2) */ 260 { 261 return ENOSYS; /* XXX - TODO */ 262 } 263 264 default: 265 return ENOSYS; 266 } 267} 268