sys/compat/common/vfs_syscalls_43.c

   1 /*      $NetBSD: vfs_syscalls_43.c,v 1.50 2009/03/17 00:01:54 dyoung Exp $      */
   2
   3 /*
   4  * Copyright (c) 1989, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  * (c) UNIX System Laboratories, Inc.
   7  * All or some portions of this file are derived from material licensed
   8  * to the University of California by American Telephone and Telegraph
   9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  10  * the permission of UNIX System Laboratories, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)vfs_syscalls.c      8.28 (Berkeley) 12/10/94
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __KERNEL_RCSID(0, "$NetBSD: vfs_syscalls_43.c,v 1.50 2009/03/17 00:01:54 dyoung Exp $");
  41
  42 #if defined(_KERNEL_OPT)
  43 #include "opt_compat_netbsd.h"
  44 #include "fs_union.h"
  45 #endif
  46
  47 #include <sys/param.h>
  48 #include <sys/systm.h>
  49 #include <sys/filedesc.h>
  50 #include <sys/kernel.h>
  51 #include <sys/proc.h>
  52 #include <sys/file.h>
  53 #include <sys/vnode.h>
  54 #include <sys/namei.h>
  55 #include <sys/dirent.h>
  56 #include <sys/socket.h>
  57 #include <sys/socketvar.h>
  58 #include <sys/stat.h>
  59 #include <sys/malloc.h>
  60 #include <sys/ioctl.h>
  61 #include <sys/fcntl.h>
  62 #include <sys/syslog.h>
  63 #include <sys/unistd.h>
  64 #include <sys/resourcevar.h>
  65 #include <sys/sysctl.h>
  66
  67 #include <sys/mount.h>
  68 #include <sys/syscallargs.h>
  69 #include <sys/vfs_syscalls.h>
  70
  71 #include <compat/sys/stat.h>
  72 #include <compat/sys/mount.h>
  73
  74 #include <compat/common/compat_util.h>
  75
  76 static void cvtstat(struct stat *, struct stat43 *);
  77
  78 /*
  79  * Convert from an old to a new stat structure.
  80  */
  81 static void
  82 cvtstat(struct stat *st, struct stat43 *ost)
  83 {
  84
  85         ost->st_dev = st->st_dev;
  86         ost->st_ino = st->st_ino;
  87         ost->st_mode = st->st_mode & 0xffff;
  88         ost->st_nlink = st->st_nlink;
  89         ost->st_uid = st->st_uid;
  90         ost->st_gid = st->st_gid;
  91         ost->st_rdev = st->st_rdev;
  92         if (st->st_size < (quad_t)1 << 32)
  93                 ost->st_size = st->st_size;
  94         else
  95                 ost->st_size = -2;
  96         ost->st_atime = st->st_atime;
  97         ost->st_mtime = st->st_mtime;
  98         ost->st_ctime = st->st_ctime;
  99         ost->st_blksize = st->st_blksize;
 100         ost->st_blocks = st->st_blocks;
 101         ost->st_flags = st->st_flags;
 102         ost->st_gen = st->st_gen;
 103 }
 104
 105 /*
 106  * Get file status; this version follows links.
 107  */
 108 /* ARGSUSED */
 109 int
 110 compat_43_sys_stat(struct lwp *l, const struct compat_43_sys_stat_args *uap, register_t *retval)
 111 {
 112         /* {
 113                 syscallarg(char *) path;
 114                 syscallarg(struct stat43 *) ub;
 115         } */
 116         struct stat sb;
 117         struct stat43 osb;
 118         int error;
 119
 120         error = do_sys_stat(SCARG(uap, path), FOLLOW, &sb);
 121         if (error)
 122                 return (error);
 123         cvtstat(&sb, &osb);
 124         error = copyout((void *)&osb, (void *)SCARG(uap, ub), sizeof (osb));
 125         return (error);
 126 }
 127
 128 /*
 129  * Get file status; this version does not follow links.
 130  */
 131 /* ARGSUSED */
 132 int
 133 compat_43_sys_lstat(struct lwp *l, const struct compat_43_sys_lstat_args *uap, register_t *retval)
 134 {
 135         /* {
 136                 syscallarg(char *) path;
 137                 syscallarg(struct ostat *) ub;
 138         } */
 139         struct vnode *vp, *dvp;
 140         struct stat sb, sb1;
 141         struct stat43 osb;
 142         int error;
 143         struct nameidata nd;
 144         int ndflags;
 145
 146         ndflags = NOFOLLOW | LOCKLEAF | LOCKPARENT | TRYEMULROOT;
 147 again:
 148         NDINIT(&nd, LOOKUP, ndflags, UIO_USERSPACE, SCARG(uap, path));
 149         if ((error = namei(&nd))) {
 150                 if (error == EISDIR && (ndflags & LOCKPARENT) != 0) {
 151                         /*
 152                          * Should only happen on '/'. Retry without LOCKPARENT;
 153                          * this is safe since the vnode won't be a VLNK.
 154                          */
 155                         ndflags &= ~LOCKPARENT;
 156                         goto again;
 157                 }
 158                 return (error);
 159         }
 160         /*
 161          * For symbolic links, always return the attributes of its
 162          * containing directory, except for mode, size, and links.
 163          */
 164         vp = nd.ni_vp;
 165         dvp = nd.ni_dvp;
 166         if (vp->v_type != VLNK) {
 167                 if ((ndflags & LOCKPARENT) != 0) {
 168                         if (dvp == vp)
 169                                 vrele(dvp);
 170                         else
 171                                 vput(dvp);
 172                 }
 173                 error = vn_stat(vp, &sb);
 174                 vput(vp);
 175                 if (error)
 176                         return (error);
 177         } else {
 178                 error = vn_stat(dvp, &sb);
 179                 vput(dvp);
 180                 if (error) {
 181                         vput(vp);
 182                         return (error);
 183                 }
 184                 error = vn_stat(vp, &sb1);
 185                 vput(vp);
 186                 if (error)
 187                         return (error);
 188                 sb.st_mode &= ~S_IFDIR;
 189                 sb.st_mode |= S_IFLNK;
 190                 sb.st_nlink = sb1.st_nlink;
 191                 sb.st_size = sb1.st_size;
 192                 sb.st_blocks = sb1.st_blocks;
 193         }
 194         cvtstat(&sb, &osb);
 195         error = copyout((void *)&osb, (void *)SCARG(uap, ub), sizeof (osb));
 196         return (error);
 197 }
 198
 199 /*
 200  * Return status information about a file descriptor.
 201  */
 202 /* ARGSUSED */
 203 int
 204 compat_43_sys_fstat(struct lwp *l, const struct compat_43_sys_fstat_args *uap, register_t *retval)
 205 {
 206         /* {
 207                 syscallarg(int) fd;
 208                 syscallarg(struct stat43 *) sb;
 209         } */
 210         struct stat ub;
 211         struct stat43 oub;
 212         int error;
 213
 214         error = do_sys_fstat(SCARG(uap, fd), &ub);
 215         if (error == 0) {
 216                 cvtstat(&ub, &oub);
 217                 error = copyout((void *)&oub, (void *)SCARG(uap, sb),
 218                     sizeof (oub));
 219         }
 220
 221         return (error);
 222 }
 223
 224
 225 /*
 226  * Truncate a file given a file descriptor.
 227  */
 228 /* ARGSUSED */
 229 int
 230 compat_43_sys_ftruncate(struct lwp *l, const struct compat_43_sys_ftruncate_args *uap, register_t *retval)
 231 {
 232         /* {
 233                 syscallarg(int) fd;
 234                 syscallarg(long) length;
 235         } */
 236         struct sys_ftruncate_args /* {
 237                 syscallarg(int) fd;
 238                 syscallarg(int) pad;
 239                 syscallarg(off_t) length;
 240         } */ nuap;
 241
 242         SCARG(&nuap, fd) = SCARG(uap, fd);
 243         SCARG(&nuap, length) = SCARG(uap, length);
 244         return (sys_ftruncate(l, &nuap, retval));
 245 }
 246
 247 /*
 248  * Truncate a file given its path name.
 249  */
 250 /* ARGSUSED */
 251 int
 252 compat_43_sys_truncate(struct lwp *l, const struct compat_43_sys_truncate_args *uap, register_t *retval)
 253 {
 254         /* {
 255                 syscallarg(char *) path;
 256                 syscallarg(long) length;
 257         } */
 258         struct sys_truncate_args /* {
 259                 syscallarg(char *) path;
 260                 syscallarg(int) pad;
 261                 syscallarg(off_t) length;
 262         } */ nuap;
 263
 264         SCARG(&nuap, path) = SCARG(uap, path);
 265         SCARG(&nuap, length) = SCARG(uap, length);
 266         return (sys_truncate(l, &nuap, retval));
 267 }
 268
 269
 270 /*
 271  * Reposition read/write file offset.
 272  */
 273 int
 274 compat_43_sys_lseek(struct lwp *l, const struct compat_43_sys_lseek_args *uap, register_t *retval)
 275 {
 276         /* {
 277                 syscallarg(int) fd;
 278                 syscallarg(long) offset;
 279                 syscallarg(int) whence;
 280         } */
 281         struct sys_lseek_args /* {
 282                 syscallarg(int) fd;
 283                 syscallarg(int) pad;
 284                 syscallarg(off_t) offset;
 285                 syscallarg(int) whence;
 286         } */ nuap;
 287         off_t qret;
 288         int error;
 289
 290         SCARG(&nuap, fd) = SCARG(uap, fd);
 291         SCARG(&nuap, offset) = SCARG(uap, offset);
 292         SCARG(&nuap, whence) = SCARG(uap, whence);
 293         error = sys_lseek(l, &nuap, (void *)&qret);
 294         *(long *)retval = qret;
 295         return (error);
 296 }
 297
 298
 299 /*
 300  * Create a file.
 301  */
 302 int
 303 compat_43_sys_creat(struct lwp *l, const struct compat_43_sys_creat_args *uap, register_t *retval)
 304 {
 305         /* {
 306                 syscallarg(char *) path;
 307                 syscallarg(int) mode;
 308         } */
 309         struct sys_open_args /* {
 310                 syscallarg(char *) path;
 311                 syscallarg(int) flags;
 312                 syscallarg(int) mode;
 313         } */ nuap;
 314
 315         SCARG(&nuap, path) = SCARG(uap, path);
 316         SCARG(&nuap, mode) = SCARG(uap, mode);
 317         SCARG(&nuap, flags) = O_WRONLY | O_CREAT | O_TRUNC;
 318         return (sys_open(l, &nuap, retval));
 319 }
 320
 321 /*ARGSUSED*/
 322 int
 323 compat_43_sys_quota(struct lwp *l, const void *v, register_t *retval)
 324 {
 325
 326         return (ENOSYS);
 327 }
 328
 329
 330 /*
 331  * Read a block of directory entries in a file system independent format.
 332  */
 333 int
 334 compat_43_sys_getdirentries(struct lwp *l, const struct compat_43_sys_getdirentries_args *uap, register_t *retval)
 335 {
 336         /* {
 337                 syscallarg(int) fd;
 338                 syscallarg(char *) buf;
 339                 syscallarg(u_int) count;
 340                 syscallarg(long *) basep;
 341         } */
 342         struct vnode *vp;
 343         struct file *fp;
 344         struct uio auio, kuio;
 345         struct iovec aiov, kiov;
 346         struct dirent *dp, *edp;
 347         char *dirbuf;
 348         size_t count = min(MAXBSIZE, (size_t)SCARG(uap, count));
 349
 350         int error, eofflag, readcnt;
 351         long loff;
 352
 353         /* fd_getvnode() will use the descriptor for us */
 354         if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
 355                 return (error);
 356         if ((fp->f_flag & FREAD) == 0) {
 357                 error = EBADF;
 358                 goto out;
 359         }
 360         vp = (struct vnode *)fp->f_data;
 361 unionread:
 362         if (vp->v_type != VDIR) {
 363                 error = EINVAL;
 364                 goto out;
 365         }
 366         aiov.iov_base = SCARG(uap, buf);
 367         aiov.iov_len = count;
 368         auio.uio_iov = &aiov;
 369         auio.uio_iovcnt = 1;
 370         auio.uio_rw = UIO_READ;
 371         auio.uio_resid = count;
 372         KASSERT(l == curlwp);
 373         auio.uio_vmspace = curproc->p_vmspace;
 374         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 375         loff = auio.uio_offset = fp->f_offset;
 376 #       if (BYTE_ORDER != LITTLE_ENDIAN)
 377                 if ((vp->v_mount->mnt_iflag & IMNT_DTYPE) == 0) {
 378                         error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag,
 379                             (off_t **)0, (int *)0);
 380                         fp->f_offset = auio.uio_offset;
 381                 } else
 382 #       endif
 383         {
 384                 kuio = auio;
 385                 kuio.uio_iov = &kiov;
 386                 kiov.iov_len = count;
 387                 dirbuf = malloc(count, M_TEMP, M_WAITOK);
 388                 kiov.iov_base = dirbuf;
 389                 UIO_SETUP_SYSSPACE(&kuio);
 390                 error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
 391                             (off_t **)0, (int *)0);
 392                 fp->f_offset = kuio.uio_offset;
 393                 if (error == 0) {
 394                         readcnt = count - kuio.uio_resid;
 395                         edp = (struct dirent *)&dirbuf[readcnt];
 396                         for (dp = (struct dirent *)dirbuf; dp < edp; ) {
 397 #                               if (BYTE_ORDER == LITTLE_ENDIAN)
 398                                         /*
 399                                          * The expected low byte of
 400                                          * dp->d_namlen is our dp->d_type.
 401                                          * The high MBZ byte of dp->d_namlen
 402                                          * is our dp->d_namlen.
 403                                          */
 404                                         dp->d_type = dp->d_namlen;
 405                                         dp->d_namlen = 0;
 406 #                               else
 407                                         /*
 408                                          * The dp->d_type is the high byte
 409                                          * of the expected dp->d_namlen,
 410                                          * so must be zero'ed.
 411                                          */
 412                                         dp->d_type = 0;
 413 #                               endif
 414                                 if (dp->d_reclen > 0) {
 415                                         dp = (struct dirent *)
 416                                             ((char *)dp + dp->d_reclen);
 417                                 } else {
 418                                         error = EIO;
 419                                         break;
 420                                 }
 421                         }
 422                         if (dp >= edp)
 423                                 error = uiomove(dirbuf, readcnt, &auio);
 424                 }
 425                 free(dirbuf, M_TEMP);
 426         }
 427         VOP_UNLOCK(vp, 0);
 428         if (error)
 429                 goto out;
 430
 431         if ((count == auio.uio_resid) &&
 432             (vp->v_vflag & VV_ROOT) &&
 433             (vp->v_mount->mnt_flag & MNT_UNION)) {
 434                 struct vnode *tvp = vp;
 435                 vp = vp->v_mount->mnt_vnodecovered;
 436                 vref(vp);
 437                 fp->f_data = (void *) vp;
 438                 fp->f_offset = 0;
 439                 vrele(tvp);
 440                 goto unionread;
 441         }
 442         error = copyout((void *)&loff, (void *)SCARG(uap, basep),
 443             sizeof(long));
 444         *retval = count - auio.uio_resid;
 445  out:
 446         fd_putfile(SCARG(uap, fd));
 447         return (error);
 448 }
 449
 450 /*
 451  * sysctl helper routine for vfs.generic.conf lookups.
 452  */
 453 #if defined(COMPAT_09) || defined(COMPAT_43) || defined(COMPAT_44)
 454 static struct sysctllog *compat_clog;
 455
 456 static int
 457 sysctl_vfs_generic_conf(SYSCTLFN_ARGS)
 458 {
 459         struct vfsconf vfc;
 460         extern const char * const mountcompatnames[];
 461         extern int nmountcompatnames;
 462         struct sysctlnode node;
 463         struct vfsops *vfsp;
 464         u_int vfsnum;
 465
 466         if (namelen != 1)
 467                 return (ENOTDIR);
 468         vfsnum = name[0];
 469         if (vfsnum >= nmountcompatnames ||
 470             mountcompatnames[vfsnum] == NULL)
 471                 return (EOPNOTSUPP);
 472         vfsp = vfs_getopsbyname(mountcompatnames[vfsnum]);
 473         if (vfsp == NULL)
 474                 return (EOPNOTSUPP);
 475
 476         vfc.vfc_vfsops = vfsp;
 477         strncpy(vfc.vfc_name, vfsp->vfs_name, sizeof(vfc.vfc_name));
 478         vfc.vfc_typenum = vfsnum;
 479         vfc.vfc_refcount = vfsp->vfs_refcount;
 480         vfc.vfc_flags = 0;
 481         vfc.vfc_mountroot = vfsp->vfs_mountroot;
 482         vfc.vfc_next = NULL;
 483         vfs_delref(vfsp);
 484
 485         node = *rnode;
 486         node.sysctl_data = &vfc;
 487         return (sysctl_lookup(SYSCTLFN_CALL(&node)));
 488 }
 489
 490 /*
 491  * Top level filesystem related information gathering.
 492  */
 493 void
 494 compat_sysctl_init(void)
 495 {
 496         extern int nmountcompatnames;
 497
 498         sysctl_createv(&compat_clog, 0, NULL, NULL,
 499                        CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
 500                        CTLTYPE_INT, "maxtypenum",
 501                        SYSCTL_DESCR("Highest valid filesystem type number"),
 502                        NULL, nmountcompatnames, NULL, 0,
 503                        CTL_VFS, VFS_GENERIC, VFS_MAXTYPENUM, CTL_EOL);
 504         sysctl_createv(&compat_clog, 0, NULL, NULL,
 505                        CTLFLAG_PERMANENT,
 506                        CTLTYPE_STRUCT, "conf",
 507                        SYSCTL_DESCR("Filesystem configuration information"),
 508                        sysctl_vfs_generic_conf, 0, NULL,
 509                        sizeof(struct vfsconf),
 510                        CTL_VFS, VFS_GENERIC, VFS_CONF, CTL_EOL);
 511 }
 512
 513 void
 514 compat_sysctl_fini(void)
 515 {
 516
 517         sysctl_teardown(&compat_clog);
 518 }
 519 #endif