sys/emulation/linux/linux_util.c

   1 /*
   2  * Copyright (c) 1994 Christos Zoulas
   3  * Copyright (c) 1995 Frank van der Linden
   4  * Copyright (c) 1995 Scott Bartram
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  *      from: svr4_util.c,v 1.5 1995/01/22 23:44:50 christos Exp
  30  * $FreeBSD: src/sys/compat/linux/linux_util.c,v 1.12.2.2 2001/11/05 19:08:23 marcel Exp $
  31  * $DragonFly: src/sys/emulation/linux/linux_util.c,v 1.11 2006/05/06 02:43:11 dillon Exp $
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/proc.h>
  37 #include <sys/nlookup.h>
  38 #include <sys/malloc.h>
  39 #include <sys/vnode.h>
  40
  41 #include "linux_util.h"
  42
  43 const char      linux_emul_path[] = "/compat/linux";
  44
  45 /*
  46  * Search for an alternate path before passing pathname arguments on
  47  * to system calls.
  48  *
  49  * Only signal an error if something really bad happens.  In most cases
  50  * we can just return the untranslated path, eg. name lookup failures.
  51  */
  52 int
  53 linux_copyin_path(char *uname, char **kname, int flags)
  54 {
  55         struct nlookupdata nd, ndroot;
  56         struct vattr vat, vatroot;
  57         struct vnode *vp, *vproot;
  58         char *buf, *cp;
  59         int error, length, dummy;
  60
  61         buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
  62         *kname = buf;
  63
  64         /*
  65          * Don't bother trying to translate if the path is relative.
  66          */
  67         if (fubyte(uname) != '/')
  68                 goto dont_translate;
  69
  70         /*
  71          * The path is absolute.  Prepend the buffer with the emulation
  72          * path and copy in.
  73          */
  74         length = strlen(linux_emul_path);
  75         bcopy(linux_emul_path, buf, length);
  76         error = copyinstr(uname, buf + length, MAXPATHLEN - length, &dummy);
  77         if (error)
  78                 goto done;
  79
  80         switch (flags) {
  81         case LINUX_PATH_CREATE:
  82                 /*
  83                  * Check to see if the parent directory exists in the
  84                  * emulation tree.  Walk the string backwards to find
  85                  * the last '/'.
  86                  */
  87                 cp = buf + strlen(buf);
  88                 while (--cp >= buf) {
  89                         if (*cp == '/')
  90                                 break;
  91                 }
  92                 if (cp < buf)
  93                         goto dont_translate;
  94                 *cp = 0;
  95
  96                 error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_FOLLOW);
  97                 if (error == 0)
  98                         error = nlookup(&nd);
  99                 nlookup_done(&nd);
 100                 if (error)
 101                         goto dont_translate;
 102                 *cp = '/';
 103                 return (0);
 104         case LINUX_PATH_EXISTS:
 105                 error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_FOLLOW);
 106                 if (error == 0)
 107                         error = nlookup(&nd);
 108                 vp = NULL;
 109                 if (error == 0)
 110                         error = cache_vref(nd.nl_ncp, nd.nl_cred, &vp);
 111                 nlookup_done(&nd);
 112                 if (error)
 113                         goto dont_translate;
 114
 115                 /*
 116                  * We now compare the vnode of the linux_root to the one
 117                  * vnode asked. If they resolve to be the same, then we
 118                  * ignore the match so that the real root gets used.
 119                  * This avoids the problem of traversing "../.." to find the
 120                  * root directory and never finding it, because "/" resolves
 121                  * to the emulation root directory. This is expensive :-(
 122                  *
 123                  * The next three function calls should not return errors.
 124                  * If they do something is seriously wrong, eg. the
 125                  * emulation subtree does not exist.  Cross our fingers
 126                  * and return the untranslated path if something happens.
 127                  */
 128                 error = nlookup_init(&ndroot, linux_emul_path, UIO_SYSSPACE,
 129                                         NLC_FOLLOW);
 130                 if (error == 0)
 131                         error = nlookup(&ndroot);
 132                 vproot = NULL;
 133                 if (error == 0) {
 134                         error = cache_vref(ndroot.nl_ncp, ndroot.nl_cred,
 135                                                 &vproot);
 136                 }
 137                 nlookup_done(&ndroot);
 138                 if (error) {
 139                         vrele(vp);
 140                         goto dont_translate;
 141                 }
 142
 143                 error = VOP_GETATTR(vp, &vat);
 144                 if (error == 0) {
 145                         error = VOP_GETATTR(vproot, &vatroot);
 146                         if (error == 0) {
 147                                 if (vat.va_fsid == vatroot.va_fsid &&
 148                                     vat.va_fileid == vatroot.va_fileid)
 149                                         error = ENOENT;
 150                         }
 151                 }
 152                 vrele(vp);
 153                 vrele(vproot);
 154                 if (error)
 155                         goto dont_translate;
 156                 return (0);
 157         default:
 158                 error = EINVAL;
 159                 goto done;
 160         }
 161
 162 dont_translate:
 163         error = copyinstr(uname, buf, MAXPATHLEN, &dummy);
 164 done:
 165         if (error)
 166                 linux_free_path(kname);
 167         return (error);
 168 }
 169
 170 /*
 171  * Smaller version of the above for translating in kernel buffers.  Only
 172  * used in exec_linux_imgact_try().  Only check is path exists.
 173  */
 174 int
 175 linux_translate_path(char *path, int size)
 176 {
 177         struct nlookupdata nd;
 178         char *buf;
 179         int error, length, dummy;
 180
 181         buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 182         length = strlen(linux_emul_path);
 183         bcopy(linux_emul_path, buf, length);
 184         error = copystr(path, buf + length, MAXPATHLEN - length, &dummy);
 185         if (error)
 186                 goto cleanup;
 187
 188         /*
 189          * If this errors, then the path probably doesn't exist.
 190          */
 191         error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_FOLLOW);
 192         if (error == 0)
 193                 error = nlookup(&nd);
 194         nlookup_done(&nd);
 195         if (error) {
 196                 error = 0;
 197                 goto cleanup;
 198         }
 199
 200         /*
 201          * The alternate path does exist.  Return it in the buffer if
 202          * it fits.
 203          */
 204         if (strlen(buf) + 1 <= size)
 205                 error = copystr(buf, path, size, &dummy);
 206
 207 cleanup:
 208
 209         free(buf, M_TEMP);
 210         return (error);
 211 }