Annotation of sys/compat/linux/linux_file64.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: linux_file64.c,v 1.6 2003/08/03 18:08:03 deraadt Exp $ */
2: /* $NetBSD: linux_file64.c,v 1.2 2000/12/12 22:24:56 jdolecek Exp $ */
3:
4: /*-
5: * Copyright (c) 1995, 1998, 2000 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Frank van der Linden and Eric Haszlakiewicz.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: /*
41: * Linux 64bit filesystem calls. Used on 32bit archs, not used on 64bit ones.
42: */
43:
44: #include <sys/param.h>
45: #include <sys/systm.h>
46: #include <sys/namei.h>
47: #include <sys/proc.h>
48: #include <sys/file.h>
49: #include <sys/stat.h>
50: #include <sys/filedesc.h>
51: #include <sys/ioctl.h>
52: #include <sys/kernel.h>
53: #include <sys/mount.h>
54: #include <sys/malloc.h>
55: #include <sys/vnode.h>
56: #include <sys/tty.h>
57: #include <sys/conf.h>
58:
59: #include <sys/syscallargs.h>
60:
61: #include <compat/linux/linux_types.h>
62: #include <compat/linux/linux_signal.h>
63: #include <compat/linux/linux_syscallargs.h>
64: #include <compat/linux/linux_fcntl.h>
65: #include <compat/linux/linux_util.h>
66:
67: #include <machine/linux_machdep.h>
68:
69:
70: void bsd_to_linux_flock64(struct flock *, struct linux_flock64 *);
71: void linux_to_bsd_flock64(struct linux_flock64 *, struct flock *);
72: static void bsd_to_linux_stat(struct stat *, struct linux_stat64 *);
73: static int linux_do_stat64(struct proc *, void *, register_t *, int);
74:
75: /*
76: * Convert a OpenBSD stat structure to a Linux stat structure.
77: * Only the order of the fields and the padding in the structure
78: * is different. linux_fakedev is a machine-dependent function
79: * which optionally converts device driver major/minor numbers
80: * (XXX horrible, but what can you do against code that compares
81: * things against constant major device numbers? sigh)
82: */
83: static void
84: bsd_to_linux_stat(bsp, lsp)
85: struct stat *bsp;
86: struct linux_stat64 *lsp;
87: {
88: lsp->lst_dev = bsp->st_dev;
89: lsp->lst_ino = bsp->st_ino;
90: lsp->lst_mode = (linux_mode_t)bsp->st_mode;
91: if (bsp->st_nlink >= (1 << 15))
92: lsp->lst_nlink = (1 << 15) - 1;
93: else
94: lsp->lst_nlink = (linux_nlink_t)bsp->st_nlink;
95: lsp->lst_uid = bsp->st_uid;
96: lsp->lst_gid = bsp->st_gid;
97: lsp->lst_rdev = linux_fakedev(bsp->st_rdev);
98: lsp->lst_size = bsp->st_size;
99: lsp->lst_blksize = bsp->st_blksize;
100: lsp->lst_blocks = bsp->st_blocks;
101: lsp->lst_atime = bsp->st_atime;
102: lsp->lst_mtime = bsp->st_mtime;
103: lsp->lst_ctime = bsp->st_ctime;
104: #if LINUX_STAT64_HAS_BROKEN_ST_INO
105: lsp->__lst_ino = (linux_ino_t)bsp->st_ino;
106: #endif
107: }
108:
109: /*
110: * The stat functions below are plain sailing. stat and lstat are handled
111: * by one function to avoid code duplication.
112: */
113: int
114: linux_sys_fstat64(p, v, retval)
115: struct proc *p;
116: void *v;
117: register_t *retval;
118: {
119: struct linux_sys_fstat64_args /* {
120: syscallarg(int) fd;
121: syscallarg(linux_stat64 *) sp;
122: } */ *uap = v;
123: struct sys_fstat_args fsa;
124: struct linux_stat64 tmplst;
125: struct stat *st,tmpst;
126: caddr_t sg;
127: int error;
128:
129: sg = stackgap_init(p->p_emul);
130:
131: st = stackgap_alloc(&sg, sizeof (struct stat));
132:
133: SCARG(&fsa, fd) = SCARG(uap, fd);
134: SCARG(&fsa, sb) = st;
135:
136: if ((error = sys_fstat(p, &fsa, retval)))
137: return error;
138:
139: if ((error = copyin(st, &tmpst, sizeof tmpst)))
140: return error;
141:
142: bsd_to_linux_stat(&tmpst, &tmplst);
143:
144: if ((error = copyout(&tmplst, SCARG(uap, sp), sizeof tmplst)))
145: return error;
146:
147: return 0;
148: }
149:
150: static int
151: linux_do_stat64(p, v, retval, dolstat)
152: struct proc *p;
153: void *v;
154: register_t *retval;
155: int dolstat;
156: {
157: struct sys_stat_args sa;
158: struct linux_stat64 tmplst;
159: struct stat *st, tmpst;
160: caddr_t sg;
161: int error;
162: struct linux_sys_stat64_args *uap = v;
163:
164: sg = stackgap_init(p->p_emul);
165: st = stackgap_alloc(&sg, sizeof (struct stat));
166: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
167:
168: SCARG(&sa, ub) = st;
169: SCARG(&sa, path) = SCARG(uap, path);
170:
171: if ((error = (dolstat ? sys_lstat(p, &sa, retval) :
172: sys_stat(p, &sa, retval))))
173: return error;
174:
175: if ((error = copyin(st, &tmpst, sizeof tmpst)))
176: return error;
177:
178: bsd_to_linux_stat(&tmpst, &tmplst);
179:
180: if ((error = copyout(&tmplst, SCARG(uap, sp), sizeof tmplst)))
181: return error;
182:
183: return 0;
184: }
185:
186: int
187: linux_sys_stat64(p, v, retval)
188: struct proc *p;
189: void *v;
190: register_t *retval;
191: {
192: struct linux_sys_stat64_args /* {
193: syscallarg(const char *) path;
194: syscallarg(struct linux_stat64 *) sp;
195: } */ *uap = v;
196:
197: return linux_do_stat64(p, uap, retval, 0);
198: }
199:
200: int
201: linux_sys_lstat64(p, v, retval)
202: struct proc *p;
203: void *v;
204: register_t *retval;
205: {
206: struct linux_sys_lstat64_args /* {
207: syscallarg(char *) path;
208: syscallarg(struct linux_stat64 *) sp;
209: } */ *uap = v;
210:
211: return linux_do_stat64(p, uap, retval, 1);
212: }
213:
214: int
215: linux_sys_truncate64(p, v, retval)
216: struct proc *p;
217: void *v;
218: register_t *retval;
219: {
220: struct linux_sys_truncate64_args /* {
221: syscallarg(char *) path;
222: syscallarg(off_t) length;
223: } */ *uap = v;
224: struct sys_truncate_args ta;
225: caddr_t sg = stackgap_init(p->p_emul);
226:
227: LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
228:
229: SCARG(&ta, path) = SCARG(uap, path);
230: SCARG(&ta, length) = SCARG(uap, length);
231:
232: return sys_truncate(p, &ta, retval);
233: }
234:
235: /*
236: * This is needed due to padding in OpenBSD's sys_ftruncate_args
237: */
238: int
239: linux_sys_ftruncate64(p, v, retval)
240: struct proc *p;
241: void *v;
242: register_t *retval;
243: {
244: struct linux_sys_ftruncate64_args /* {
245: syscallarg(int) fd;
246: syscallarg(off_t) length;
247: } */ *uap = v;
248: struct sys_ftruncate_args fta;
249:
250: SCARG(&fta, fd) = SCARG(uap, fd);
251: SCARG(&fta, length) = SCARG(uap, length);
252:
253: return sys_ftruncate(p, &fta, retval);
254: }
255:
256: /*
257: * The next two functions take care of converting the flock
258: * structure back and forth between Linux and OpenBSD format.
259: * The only difference in the structures is the order of
260: * the fields, and the 'whence' value.
261: */
262: void
263: bsd_to_linux_flock64(struct flock *bfp, struct linux_flock64 *lfp)
264: {
265: lfp->l_start = bfp->l_start;
266: lfp->l_len = bfp->l_len;
267: lfp->l_pid = bfp->l_pid;
268: lfp->l_whence = bfp->l_whence;
269: switch (bfp->l_type) {
270: case F_RDLCK:
271: lfp->l_type = LINUX_F_RDLCK;
272: break;
273: case F_UNLCK:
274: lfp->l_type = LINUX_F_UNLCK;
275: break;
276: case F_WRLCK:
277: lfp->l_type = LINUX_F_WRLCK;
278: break;
279: }
280: }
281:
282: void
283: linux_to_bsd_flock64(struct linux_flock64 *lfp, struct flock *bfp)
284: {
285: bfp->l_start = lfp->l_start;
286: bfp->l_len = lfp->l_len;
287: bfp->l_pid = lfp->l_pid;
288: bfp->l_whence = lfp->l_whence;
289: switch (lfp->l_type) {
290: case LINUX_F_RDLCK:
291: bfp->l_type = F_RDLCK;
292: break;
293: case LINUX_F_UNLCK:
294: bfp->l_type = F_UNLCK;
295: break;
296: case LINUX_F_WRLCK:
297: bfp->l_type = F_WRLCK;
298: break;
299: }
300: }
301:
302: int
303: linux_sys_fcntl64(p, v, retval)
304: struct proc *p;
305: void *v;
306: register_t *retval;
307: {
308: struct linux_sys_fcntl64_args /* {
309: syscallarg(u_int) fd;
310: syscallarg(u_int) cmd;
311: syscallarg(void *) arg;
312: } */ *uap = v;
313: int fd, cmd, error;
314: caddr_t arg, sg;
315: struct linux_flock64 lfl;
316: struct flock *bfp, bfl;
317: struct sys_fcntl_args fca;
318:
319: fd = SCARG(uap, fd);
320: cmd = SCARG(uap, cmd);
321: arg = (caddr_t) SCARG(uap, arg);
322:
323: switch (cmd) {
324: case LINUX_F_GETLK64:
325: sg = stackgap_init(p->p_emul);
326: if ((error = copyin(arg, &lfl, sizeof lfl)))
327: return error;
328: linux_to_bsd_flock64(&lfl, &bfl);
329: bfp = (struct flock *) stackgap_alloc(&sg, sizeof *bfp);
330: SCARG(&fca, fd) = fd;
331: SCARG(&fca, cmd) = F_GETLK;
332: SCARG(&fca, arg) = bfp;
333: if ((error = copyout(&bfl, bfp, sizeof bfl)))
334: return error;
335: if ((error = sys_fcntl(p, &fca, retval)))
336: return error;
337: if ((error = copyin(bfp, &bfl, sizeof bfl)))
338: return error;
339: bsd_to_linux_flock64(&bfl, &lfl);
340: error = copyout(&lfl, arg, sizeof lfl);
341: return (error);
342: case LINUX_F_SETLK64:
343: case LINUX_F_SETLKW64:
344: cmd = (cmd == LINUX_F_SETLK64 ? F_SETLK : F_SETLKW);
345: if ((error = copyin(arg, &lfl, sizeof lfl)))
346: return error;
347: linux_to_bsd_flock64(&lfl, &bfl);
348: sg = stackgap_init(p->p_emul);
349: bfp = (struct flock *) stackgap_alloc(&sg, sizeof *bfp);
350: if ((error = copyout(&bfl, bfp, sizeof bfl)))
351: return error;
352: SCARG(&fca, fd) = fd;
353: SCARG(&fca, cmd) = cmd;
354: SCARG(&fca, arg) = bfp;
355: return (sys_fcntl(p, &fca, retval));
356: default:
357: return (linux_sys_fcntl(p, v, retval));
358: }
359: /* NOTREACHED */
360: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to linux_file64.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / linux