This source file includes following definitions.
- svr4_to_bsd_cmd
- svr4_to_bsd_flags
- bsd_to_svr4_flags
- bsd_to_svr4_flock
- svr4_to_bsd_flock
- bsd_to_svr3_flock
- svr3_to_bsd_flock
- fd_truncate
- svr4_sys_open
- svr4_sys_open64
- svr4_sys_creat
- svr4_sys_creat64
- svr4_sys_llseek
- svr4_sys_access
- svr4_sys_pread
- svr4_sys_pread64
- svr4_sys_pwrite
- svr4_sys_pwrite64
- svr4_sys_fcntl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/namei.h>
35 #include <sys/proc.h>
36 #include <sys/file.h>
37 #include <sys/stat.h>
38 #include <sys/vnode.h>
39 #include <sys/filedesc.h>
40 #include <sys/ioctl.h>
41 #include <sys/kernel.h>
42 #include <sys/mount.h>
43 #include <sys/malloc.h>
44 #include <sys/poll.h>
45 #include <sys/syscallargs.h>
46
47 #include <compat/svr4/svr4_types.h>
48 #include <compat/svr4/svr4_signal.h>
49 #include <compat/svr4/svr4_syscallargs.h>
50 #include <compat/svr4/svr4_util.h>
51 #include <compat/svr4/svr4_fcntl.h>
52
53 static u_long svr4_to_bsd_cmd(u_long);
54 static int svr4_to_bsd_flags(int);
55 static int bsd_to_svr4_flags(int);
56 static void bsd_to_svr4_flock(struct flock *, struct svr4_flock *);
57 static void svr4_to_bsd_flock(struct svr4_flock *, struct flock *);
58 static void bsd_to_svr3_flock(struct flock *, struct svr4_flock_svr3 *);
59 static void svr3_to_bsd_flock(struct svr4_flock_svr3 *, struct flock *);
60 static int fd_truncate(struct proc *, int, struct flock *, register_t *);
61
62 static u_long
63 svr4_to_bsd_cmd(cmd)
64 u_long cmd;
65 {
66 switch (cmd) {
67 case SVR4_F_DUPFD:
68 return F_DUPFD;
69 case SVR4_F_GETFD:
70 return F_GETFD;
71 case SVR4_F_SETFD:
72 return F_SETFD;
73 case SVR4_F_GETFL:
74 return F_GETFL;
75 case SVR4_F_SETFL:
76 return F_SETFL;
77 case SVR4_F_GETLK:
78 case SVR4_F_GETLK_SVR3:
79 return F_GETLK;
80 case SVR4_F_SETLK:
81 return F_SETLK;
82 case SVR4_F_SETLKW:
83 return F_SETLKW;
84 default:
85 return -1;
86 }
87 }
88
89
90 static int
91 svr4_to_bsd_flags(l)
92 int l;
93 {
94 int r = 0;
95 r |= (l & SVR4_O_RDONLY) ? O_RDONLY : 0;
96 r |= (l & SVR4_O_WRONLY) ? O_WRONLY : 0;
97 r |= (l & SVR4_O_RDWR) ? O_RDWR : 0;
98 r |= (l & SVR4_O_NDELAY) ? O_NONBLOCK : 0;
99 r |= (l & SVR4_O_APPEND) ? O_APPEND : 0;
100 #if 0
101
102 r |= (l & SVR4_O_RAIOSIG) ? O_ASYNC : 0;
103 #endif
104 r |= (l & SVR4_O_SYNC) ? O_FSYNC : 0;
105 r |= (l & SVR4_O_RSYNC) ? O_RSYNC : 0;
106 r |= (l & SVR4_O_DSYNC) ? O_DSYNC : 0;
107 r |= (l & SVR4_O_NONBLOCK) ? O_NONBLOCK : 0;
108 r |= (l & SVR4_O_PRIV) ? O_EXLOCK : 0;
109 r |= (l & SVR4_O_CREAT) ? O_CREAT : 0;
110 r |= (l & SVR4_O_TRUNC) ? O_TRUNC : 0;
111 r |= (l & SVR4_O_EXCL) ? O_EXCL : 0;
112 r |= (l & SVR4_O_NOCTTY) ? O_NOCTTY : 0;
113 return r;
114 }
115
116
117 static int
118 bsd_to_svr4_flags(l)
119 int l;
120 {
121 int r = 0;
122 r |= (l & O_RDONLY) ? SVR4_O_RDONLY : 0;
123 r |= (l & O_WRONLY) ? SVR4_O_WRONLY : 0;
124 r |= (l & O_RDWR) ? SVR4_O_RDWR : 0;
125 r |= (l & O_NDELAY) ? SVR4_O_NONBLOCK : 0;
126 r |= (l & O_APPEND) ? SVR4_O_APPEND : 0;
127 #if 0
128
129 r |= (l & O_ASYNC) ? SVR4_O_RAIOSIG : 0;
130 #endif
131 r |= (l & O_FSYNC) ? SVR4_O_SYNC : 0;
132 r |= (l & O_RSYNC) ? SVR4_O_RSYNC : 0;
133 r |= (l & O_DSYNC) ? SVR4_O_DSYNC : 0;
134 r |= (l & O_NONBLOCK) ? SVR4_O_NONBLOCK : 0;
135 r |= (l & O_EXLOCK) ? SVR4_O_PRIV : 0;
136 r |= (l & O_CREAT) ? SVR4_O_CREAT : 0;
137 r |= (l & O_TRUNC) ? SVR4_O_TRUNC : 0;
138 r |= (l & O_EXCL) ? SVR4_O_EXCL : 0;
139 r |= (l & O_NOCTTY) ? SVR4_O_NOCTTY : 0;
140 return r;
141 }
142
143 static void
144 bsd_to_svr4_flock(iflp, oflp)
145 struct flock *iflp;
146 struct svr4_flock *oflp;
147 {
148 switch (iflp->l_type) {
149 case F_RDLCK:
150 oflp->l_type = SVR4_F_RDLCK;
151 break;
152 case F_WRLCK:
153 oflp->l_type = SVR4_F_WRLCK;
154 break;
155 case F_UNLCK:
156 oflp->l_type = SVR4_F_UNLCK;
157 break;
158 default:
159 oflp->l_type = -1;
160 break;
161 }
162
163 oflp->l_whence = (short) iflp->l_whence;
164 oflp->l_start = (svr4_off_t) iflp->l_start;
165 oflp->l_len = (svr4_off_t) iflp->l_len;
166 oflp->l_sysid = 0;
167 oflp->l_pid = (svr4_pid_t) iflp->l_pid;
168 }
169
170 static void
171 svr4_to_bsd_flock(iflp, oflp)
172 struct svr4_flock *iflp;
173 struct flock *oflp;
174 {
175 switch (iflp->l_type) {
176 case SVR4_F_RDLCK:
177 oflp->l_type = F_RDLCK;
178 break;
179 case SVR4_F_WRLCK:
180 oflp->l_type = F_WRLCK;
181 break;
182 case SVR4_F_UNLCK:
183 oflp->l_type = F_UNLCK;
184 break;
185 default:
186 oflp->l_type = -1;
187 break;
188 }
189
190 oflp->l_whence = iflp->l_whence;
191 oflp->l_start = (off_t) iflp->l_start;
192 oflp->l_len = (off_t) iflp->l_len;
193 oflp->l_pid = (pid_t) iflp->l_pid;
194 }
195
196 static void
197 bsd_to_svr3_flock(iflp, oflp)
198 struct flock *iflp;
199 struct svr4_flock_svr3 *oflp;
200 {
201 switch (iflp->l_type) {
202 case F_RDLCK:
203 oflp->l_type = SVR4_F_RDLCK;
204 break;
205 case F_WRLCK:
206 oflp->l_type = SVR4_F_WRLCK;
207 break;
208 case F_UNLCK:
209 oflp->l_type = SVR4_F_UNLCK;
210 break;
211 default:
212 oflp->l_type = -1;
213 break;
214 }
215
216 oflp->l_whence = (short) iflp->l_whence;
217 oflp->l_start = (svr4_off_t) iflp->l_start;
218 oflp->l_len = (svr4_off_t) iflp->l_len;
219 oflp->l_sysid = 0;
220 oflp->l_pid = (svr4_pid_t) iflp->l_pid;
221 }
222
223
224 static void
225 svr3_to_bsd_flock(iflp, oflp)
226 struct svr4_flock_svr3 *iflp;
227 struct flock *oflp;
228 {
229 switch (iflp->l_type) {
230 case SVR4_F_RDLCK:
231 oflp->l_type = F_RDLCK;
232 break;
233 case SVR4_F_WRLCK:
234 oflp->l_type = F_WRLCK;
235 break;
236 case SVR4_F_UNLCK:
237 oflp->l_type = F_UNLCK;
238 break;
239 default:
240 oflp->l_type = -1;
241 break;
242 }
243
244 oflp->l_whence = iflp->l_whence;
245 oflp->l_start = (off_t) iflp->l_start;
246 oflp->l_len = (off_t) iflp->l_len;
247 oflp->l_pid = (pid_t) iflp->l_pid;
248 }
249
250 static int
251 fd_truncate(p, fd, flp, retval)
252 struct proc *p;
253 int fd;
254 struct flock *flp;
255 register_t *retval;
256 {
257 struct filedesc *fdp = p->p_fd;
258 struct file *fp;
259 off_t start, length;
260 struct vnode *vp;
261 struct vattr vattr;
262 int error;
263 struct sys_ftruncate_args ft;
264
265
266
267
268 if ((fp = fd_getfile(fdp, fd)) == NULL)
269 return EBADF;
270
271 vp = (struct vnode *)fp->f_data;
272 if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO)
273 return ESPIPE;
274
275 FREF(fp);
276
277 if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) != 0)
278 goto out;
279
280 length = vattr.va_size;
281
282 switch (flp->l_whence) {
283 case SEEK_CUR:
284 start = fp->f_offset + flp->l_start;
285 break;
286
287 case SEEK_END:
288 start = flp->l_start + length;
289 break;
290
291 case SEEK_SET:
292 start = flp->l_start;
293 break;
294
295 default:
296 error = EINVAL;
297 goto out;
298 }
299
300 if (start + flp->l_len < length) {
301
302 error = EINVAL;
303 goto out;
304 }
305
306 SCARG(&ft, fd) = fd;
307 SCARG(&ft, length) = start;
308
309 error = sys_ftruncate(p, &ft, retval);
310 out:
311 FRELE(fp);
312 return (error);
313 }
314
315 int
316 svr4_sys_open(p, v, retval)
317 register struct proc *p;
318 void *v;
319 register_t *retval;
320 {
321 struct svr4_sys_open_args *uap = v;
322 int error;
323 struct sys_open_args cup;
324
325 caddr_t sg = stackgap_init(p->p_emul);
326
327 SCARG(&cup, flags) = svr4_to_bsd_flags(SCARG(uap, flags));
328
329 if (SCARG(&cup, flags) & O_CREAT)
330 SVR4_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
331 else
332 SVR4_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
333
334 SCARG(&cup, path) = SCARG(uap, path);
335 SCARG(&cup, mode) = SCARG(uap, mode);
336 error = sys_open(p, &cup, retval);
337
338 if (error)
339 return error;
340
341 if (!(SCARG(&cup, flags) & O_NOCTTY) && SESS_LEADER(p) &&
342 !(p->p_flag & P_CONTROLT)) {
343 struct filedesc *fdp = p->p_fd;
344 struct file *fp;
345
346 if ((fp = fd_getfile(fdp, *retval)) == NULL)
347 return (EBADF);
348 FREF(fp);
349
350 if (fp->f_type == DTYPE_VNODE)
351 (fp->f_ops->fo_ioctl) (fp, TIOCSCTTY, (caddr_t) 0, p);
352 FRELE(fp);
353 }
354 return 0;
355 }
356
357 int
358 svr4_sys_open64(p, v, retval)
359 register struct proc *p;
360 void *v;
361 register_t *retval;
362 {
363 return svr4_sys_open(p, v, retval);
364 }
365
366 int
367 svr4_sys_creat(p, v, retval)
368 register struct proc *p;
369 void *v;
370 register_t *retval;
371 {
372 struct svr4_sys_creat_args *uap = v;
373 struct sys_open_args cup;
374
375 caddr_t sg = stackgap_init(p->p_emul);
376 SVR4_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
377
378 SCARG(&cup, path) = SCARG(uap, path);
379 SCARG(&cup, mode) = SCARG(uap, mode);
380 SCARG(&cup, flags) = O_WRONLY | O_CREAT | O_TRUNC;
381
382 return sys_open(p, &cup, retval);
383 }
384
385 int
386 svr4_sys_creat64(p, v, retval)
387 register struct proc *p;
388 void *v;
389 register_t *retval;
390 {
391 return (svr4_sys_creat(p, v, retval));
392 }
393
394 int
395 svr4_sys_llseek(p, v, retval)
396 register struct proc *p;
397 void *v;
398 register_t *retval;
399 {
400 struct svr4_sys_llseek_args *uap = v;
401 struct sys_lseek_args ap;
402
403 SCARG(&ap, fd) = SCARG(uap, fd);
404
405 #if BYTE_ORDER == BIG_ENDIAN
406 SCARG(&ap, offset) = (((long long) SCARG(uap, offset1)) << 32) |
407 SCARG(uap, offset2);
408 #else
409 SCARG(&ap, offset) = (((long long) SCARG(uap, offset2)) << 32) |
410 SCARG(uap, offset1);
411 #endif
412 SCARG(&ap, whence) = SCARG(uap, whence);
413
414 return sys_lseek(p, &ap, retval);
415 }
416
417 int
418 svr4_sys_access(p, v, retval)
419 register struct proc *p;
420 void *v;
421 register_t *retval;
422 {
423 struct svr4_sys_access_args *uap = v;
424 struct sys_access_args cup;
425
426 caddr_t sg = stackgap_init(p->p_emul);
427 SVR4_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
428
429 SCARG(&cup, path) = SCARG(uap, path);
430 SCARG(&cup, flags) = SCARG(uap, flags);
431
432 return sys_access(p, &cup, retval);
433 }
434
435 int
436 svr4_sys_pread(p, v, retval)
437 register struct proc *p;
438 void *v;
439 register_t *retval;
440 {
441 struct svr4_sys_pread_args *uap = v;
442 struct sys_pread_args pra;
443
444 SCARG(&pra, fd) = SCARG(uap, fd);
445 SCARG(&pra, buf) = SCARG(uap, buf);
446 SCARG(&pra, nbyte) = SCARG(uap, nbyte);
447 SCARG(&pra, offset) = SCARG(uap, off);
448
449 return (sys_pread(p, &pra, retval));
450 }
451
452 int
453 svr4_sys_pread64(p, v, retval)
454 register struct proc *p;
455 void *v;
456 register_t *retval;
457 {
458 struct svr4_sys_pread64_args *uap = v;
459 struct sys_pread_args pra;
460
461 SCARG(&pra, fd) = SCARG(uap, fd);
462 SCARG(&pra, buf) = SCARG(uap, buf);
463 SCARG(&pra, nbyte) = SCARG(uap, nbyte);
464 SCARG(&pra, offset) = SCARG(uap, off);
465
466 return (sys_pread(p, &pra, retval));
467 }
468
469 int
470 svr4_sys_pwrite(p, v, retval)
471 register struct proc *p;
472 void *v;
473 register_t *retval;
474 {
475 struct svr4_sys_pwrite_args *uap = v;
476 struct sys_pwrite_args pwa;
477
478 SCARG(&pwa, fd) = SCARG(uap, fd);
479 SCARG(&pwa, buf) = SCARG(uap, buf);
480 SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
481 SCARG(&pwa, offset) = SCARG(uap, off);
482
483 return (sys_pwrite(p, &pwa, retval));
484 }
485
486 int
487 svr4_sys_pwrite64(p, v, retval)
488 register struct proc *p;
489 void *v;
490 register_t *retval;
491 {
492 struct svr4_sys_pwrite64_args *uap = v;
493 struct sys_pwrite_args pwa;
494
495 SCARG(&pwa, fd) = SCARG(uap, fd);
496 SCARG(&pwa, buf) = SCARG(uap, buf);
497 SCARG(&pwa, nbyte) = SCARG(uap, nbyte);
498 SCARG(&pwa, offset) = SCARG(uap, off);
499
500 return (sys_pwrite(p, &pwa, retval));
501 }
502
503 int
504 svr4_sys_fcntl(p, v, retval)
505 register struct proc *p;
506 void *v;
507 register_t *retval;
508 {
509 struct svr4_sys_fcntl_args *uap = v;
510 int error;
511 struct sys_fcntl_args fa;
512
513 SCARG(&fa, fd) = SCARG(uap, fd);
514 SCARG(&fa, cmd) = svr4_to_bsd_cmd(SCARG(uap, cmd));
515
516 switch (SCARG(&fa, cmd)) {
517 case F_DUPFD:
518 case F_GETFD:
519 case F_SETFD:
520 SCARG(&fa, arg) = SCARG(uap, arg);
521 return sys_fcntl(p, &fa, retval);
522
523 case F_GETFL:
524 SCARG(&fa, arg) = SCARG(uap, arg);
525 error = sys_fcntl(p, &fa, retval);
526 if (error)
527 return error;
528 *retval = bsd_to_svr4_flags(*retval);
529 return error;
530
531 case F_SETFL:
532 {
533
534
535
536
537 register_t flags;
538 int cmd;
539
540 cmd = SCARG(&fa, cmd);
541
542 SCARG(&fa, cmd) = F_GETFL;
543 if ((error = sys_fcntl(p, &fa, &flags)) != 0)
544 return error;
545 flags &= O_ASYNC;
546 flags |= svr4_to_bsd_flags((u_long) SCARG(uap, arg));
547 SCARG(&fa, cmd) = cmd;
548 SCARG(&fa, arg) = (void *) flags;
549 return sys_fcntl(p, &fa, retval);
550 }
551
552 case F_GETLK:
553 if (SCARG(uap, cmd) == SVR4_F_GETLK_SVR3) {
554 struct svr4_flock_svr3 ifl;
555 struct flock *flp, fl;
556 caddr_t sg = stackgap_init(p->p_emul);
557
558 flp = stackgap_alloc(&sg, sizeof(*flp));
559 error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&ifl,
560 sizeof ifl);
561 if (error)
562 return error;
563 svr3_to_bsd_flock(&ifl, &fl);
564
565 error = copyout(&fl, flp, sizeof fl);
566 if (error)
567 return error;
568
569 SCARG(&fa, fd) = SCARG(uap, fd);
570 SCARG(&fa, cmd) = F_GETLK;
571 SCARG(&fa, arg) = (void *)flp;
572 error = sys_fcntl(p, &fa, retval);
573 if (error)
574 return error;
575
576 error = copyin(flp, &fl, sizeof fl);
577 if (error)
578 return error;
579
580 bsd_to_svr3_flock(&fl, &ifl);
581
582 return copyout((caddr_t)&ifl, (caddr_t)SCARG(uap, arg),
583 sizeof ifl);
584 }
585
586 case F_SETLK:
587 case F_SETLKW:
588 {
589 struct svr4_flock ifl;
590 struct flock *flp, fl;
591 caddr_t sg = stackgap_init(p->p_emul);
592
593 flp = stackgap_alloc(&sg, sizeof(struct flock));
594 SCARG(&fa, arg) = (void *) flp;
595
596 error = copyin(SCARG(uap, arg), &ifl, sizeof ifl);
597 if (error)
598 return error;
599
600 svr4_to_bsd_flock(&ifl, &fl);
601
602 error = copyout(&fl, flp, sizeof fl);
603 if (error)
604 return error;
605
606 error = sys_fcntl(p, &fa, retval);
607 if (error || SCARG(&fa, cmd) != F_GETLK)
608 return error;
609
610 error = copyin(flp, &fl, sizeof fl);
611 if (error)
612 return error;
613
614 bsd_to_svr4_flock(&fl, &ifl);
615
616 return copyout(&ifl, SCARG(uap, arg), sizeof ifl);
617 }
618 case -1:
619 switch (SCARG(uap, cmd)) {
620 case SVR4_F_DUP2FD:
621 {
622 struct sys_dup2_args du;
623
624 SCARG(&du, from) = SCARG(uap, fd);
625 SCARG(&du, to) = (int)SCARG(uap, arg);
626 error = sys_dup2(p, &du, retval);
627 if (error)
628 return error;
629 *retval = SCARG(&du, to);
630 return 0;
631 }
632 case SVR4_F_FREESP:
633 {
634 struct svr4_flock ifl;
635 struct flock fl;
636
637 error = copyin(SCARG(uap, arg), &ifl,
638 sizeof ifl);
639 if (error)
640 return error;
641 svr4_to_bsd_flock(&ifl, &fl);
642 return fd_truncate(p, SCARG(uap, fd), &fl,
643 retval);
644 }
645
646 default:
647 return ENOSYS;
648 }
649
650 default:
651 return ENOSYS;
652 }
653 }