The thread/proc pointer argument in the VFS subsystem originally existed
[dragonfly.git] / 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 }