d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9f3127941e
freebsd-skq/sys/svr4/svr4_ttold.c
green 140cb4ff83 This is what was "fdfix2.patch," a fix for fd sharing. It's pretty 
far-reaching in fd-land, so you'll want to consult the code for
changes.  The biggest change is that now, you don't use
	fp->f_ops->fo_foo(fp, bar)
but instead
	fo_foo(fp, bar),
which increments and decrements the fp refcount upon entry and exit.
Two new calls, fhold() and fdrop(), are provided.  Each does what it
seems like it should, and if fdrop() brings the refcount to zero, the
fd is freed as well.

Thanks to peter ("to hell with it, it looks ok to me.") for his review.
Thanks to msmith for keeping me from putting locks everywhere :)

Reviewed by:	peter
1999-09-19 17:00:25 +00:00

379 lines
9.0 KiB
C
Raw Blame History

/*
* Copyright (c) 1998 Mark Newton
* Copyright (c) 1994 Christos Zoulas
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/fcntl.h>
#include <sys/ioctl_compat.h>
#include <sys/unistd.h>
#include <sys/termios.h>
#include <sys/tty.h>
#include <sys/socket.h>
#include <sys/mount.h>
#include <net/if.h>
#include <sys/malloc.h>
#include <sys/sysproto.h>
#include <svr4/svr4_types.h>
#include <svr4/svr4_util.h>
#include <svr4/svr4_signal.h>
#include <svr4/svr4_proto.h>
#include <svr4/svr4_stropts.h>
#include <svr4/svr4_ttold.h>
#include <svr4/svr4_ioctl.h>
static void svr4_tchars_to_bsd_tchars __P((const struct svr4_tchars *st,
struct tchars *bt));
static void bsd_tchars_to_svr4_tchars __P((const struct tchars *bt,
struct svr4_tchars *st));
static void svr4_sgttyb_to_bsd_sgttyb __P((const struct svr4_sgttyb *ss,
struct sgttyb *bs));
static void bsd_sgttyb_to_svr4_sgttyb __P((const struct sgttyb *bs,
struct svr4_sgttyb *ss));
static void svr4_ltchars_to_bsd_ltchars __P((const struct svr4_ltchars *sl,
struct ltchars *bl));
static void bsd_ltchars_to_svr4_ltchars __P((const struct ltchars *bl,
struct svr4_ltchars *sl));
#ifdef DEBUG_SVR4
static void print_svr4_sgttyb __P((const char *, struct svr4_sgttyb *));
static void print_svr4_tchars __P((const char *, struct svr4_tchars *));
static void print_svr4_ltchars __P((const char *, struct svr4_ltchars *));
static void
print_svr4_sgttyb(str, ss)
const char *str;
struct svr4_sgttyb *ss;
{
uprintf("%s\nispeed=%o ospeed=%o ", str, ss->sg_ispeed, ss->sg_ospeed);
uprintf("erase=%o kill=%o flags=%o\n", ss->sg_erase, ss->sg_kill,
ss->sg_flags);
}
static void
print_svr4_tchars(str, st)
const char *str;
struct svr4_tchars *st;
{
uprintf("%s\nintrc=%o quitc=%o ", str, st->t_intrc, st->t_quitc);
uprintf("startc=%o stopc=%o eofc=%o brkc=%o\n", st->t_startc,
st->t_stopc, st->t_eofc, st->t_brkc);
}
static void
print_svr4_ltchars(str, sl)
const char *str;
struct svr4_ltchars *sl;
{
uprintf("%s\nsuspc=%o dsuspc=%o ", str, sl->t_suspc, sl->t_dsuspc);
uprintf("rprntc=%o flushc=%o werasc=%o lnextc=%o\n", sl->t_rprntc,
sl->t_flushc, sl->t_werasc, sl->t_lnextc);
}
#endif /* DEBUG_SVR4 */
static void
svr4_tchars_to_bsd_tchars(st, bt)
const struct svr4_tchars *st;
struct tchars *bt;
{
bt->t_intrc = st->t_intrc;
bt->t_quitc = st->t_quitc;
bt->t_startc = st->t_startc;
bt->t_stopc = st->t_stopc;
bt->t_eofc = st->t_eofc;
bt->t_brkc = st->t_brkc;
}
static void
bsd_tchars_to_svr4_tchars(bt, st)
const struct tchars *bt;
struct svr4_tchars *st;
{
st->t_intrc = bt->t_intrc;
st->t_quitc = bt->t_quitc;
st->t_startc = bt->t_startc;
st->t_stopc = bt->t_stopc;
st->t_eofc = bt->t_eofc;
st->t_brkc = bt->t_brkc;
}
static void
svr4_sgttyb_to_bsd_sgttyb(ss, bs)
const struct svr4_sgttyb *ss;
struct sgttyb *bs;
{
bs->sg_ispeed = ss->sg_ispeed;
bs->sg_ospeed = ss->sg_ospeed;
bs->sg_erase = ss->sg_erase;
bs->sg_kill = ss->sg_kill;
bs->sg_flags = ss->sg_flags;
};
static void
bsd_sgttyb_to_svr4_sgttyb(bs, ss)
const struct sgttyb *bs;
struct svr4_sgttyb *ss;
{
ss->sg_ispeed = bs->sg_ispeed;
ss->sg_ospeed = bs->sg_ospeed;
ss->sg_erase = bs->sg_erase;
ss->sg_kill = bs->sg_kill;
ss->sg_flags = bs->sg_flags;
}
static void
svr4_ltchars_to_bsd_ltchars(sl, bl)
const struct svr4_ltchars *sl;
struct ltchars *bl;
{
bl->t_suspc = sl->t_suspc;
bl->t_dsuspc = sl->t_dsuspc;
bl->t_rprntc = sl->t_rprntc;
bl->t_flushc = sl->t_flushc;
bl->t_werasc = sl->t_werasc;
bl->t_lnextc = sl->t_lnextc;
}
static void
bsd_ltchars_to_svr4_ltchars(bl, sl)
const struct ltchars *bl;
struct svr4_ltchars *sl;
{
sl->t_suspc = bl->t_suspc;
sl->t_dsuspc = bl->t_dsuspc;
sl->t_rprntc = bl->t_rprntc;
sl->t_flushc = bl->t_flushc;
sl->t_werasc = bl->t_werasc;
sl->t_lnextc = bl->t_lnextc;
}
int
svr4_ttold_ioctl(fp, p, retval, fd, cmd, data)
struct file *fp;
struct proc *p;
register_t *retval;
int fd;
u_long cmd;
caddr_t data;
{
int error;
*retval = 0;
switch (cmd) {
case SVR4_TIOCGPGRP:
{
pid_t pid;
if ((error = fo_ioctl(fp, TIOCGPGRP, (caddr_t) &pid, p)) != 0)
return error;
DPRINTF(("TIOCGPGRP %d\n", pid));
if ((error = copyout(&pid, data, sizeof(pid))) != 0)
return error;
}
case SVR4_TIOCSPGRP:
{
pid_t pid;
if ((error = copyin(data, &pid, sizeof(pid))) != 0)
return error;
DPRINTF(("TIOCSPGRP %d\n", pid));
return fo_ioctl(fp, TIOCSPGRP, (caddr_t) &pid, p);
}
case SVR4_TIOCGSID:
{
#if defined(TIOCGSID)
pid_t pid;
if ((error = fo_ioctl(fp, TIOCGSID, (caddr_t) &pid, p)) != 0)
return error;
DPRINTF(("TIOCGSID %d\n", pid));
return copyout(&pid, data, sizeof(pid));
#else
uprintf("ioctl(TIOCGSID) for pid %d unsupported\n", p->p_pid);
return EINVAL;
#endif
}
case SVR4_TIOCGETP:
{
struct sgttyb bs;
struct svr4_sgttyb ss;
error = fo_ioctl(fp, TIOCGETP, (caddr_t) &bs, p);
if (error)
return error;
bsd_sgttyb_to_svr4_sgttyb(&bs, &ss);
#ifdef DEBUG_SVR4
print_svr4_sgttyb("SVR4_TIOCGETP", &ss);
#endif /* DEBUG_SVR4 */
return copyout(&ss, data, sizeof(ss));
}
case SVR4_TIOCSETP:
case SVR4_TIOCSETN:
{
struct sgttyb bs;
struct svr4_sgttyb ss;
if ((error = copyin(data, &ss, sizeof(ss))) != 0)
return error;
svr4_sgttyb_to_bsd_sgttyb(&ss, &bs);
#ifdef DEBUG_SVR4
print_svr4_sgttyb("SVR4_TIOCSET{P,N}", &ss);
#endif /* DEBUG_SVR4 */
cmd = (cmd == SVR4_TIOCSETP) ? TIOCSETP : TIOCSETN;
return fo_ioctl(fp, cmd, (caddr_t) &bs, p);
}
case SVR4_TIOCGETC:
{
struct tchars bt;
struct svr4_tchars st;
error = fo_ioctl(fp, TIOCGETC, (caddr_t) &bt, p);
if (error)
return error;
bsd_tchars_to_svr4_tchars(&bt, &st);
#ifdef DEBUG_SVR4
print_svr4_tchars("SVR4_TIOCGETC", &st);
#endif /* DEBUG_SVR4 */
return copyout(&st, data, sizeof(st));
}
case SVR4_TIOCSETC:
{
struct tchars bt;
struct svr4_tchars st;
if ((error = copyin(data, &st, sizeof(st))) != 0)
return error;
svr4_tchars_to_bsd_tchars(&st, &bt);
#ifdef DEBUG_SVR4
print_svr4_tchars("SVR4_TIOCSETC", &st);
#endif /* DEBUG_SVR4 */
return fo_ioctl(fp, TIOCSETC, (caddr_t) &bt, p);
}
case SVR4_TIOCGLTC:
{
struct ltchars bl;
struct svr4_ltchars sl;
error = fo_ioctl(fp, TIOCGLTC, (caddr_t) &bl, p);
if (error)
return error;
bsd_ltchars_to_svr4_ltchars(&bl, &sl);
#ifdef DEBUG_SVR4
print_svr4_ltchars("SVR4_TIOCGLTC", &sl);
#endif /* DEBUG_SVR4 */
return copyout(&sl, data, sizeof(sl));
}
case SVR4_TIOCSLTC:
{
struct ltchars bl;
struct svr4_ltchars sl;
if ((error = copyin(data, &sl, sizeof(sl))) != 0)
return error;
svr4_ltchars_to_bsd_ltchars(&sl, &bl);
#ifdef DEBUG_SVR4
print_svr4_ltchars("SVR4_TIOCSLTC", &sl);
#endif /* DEBUG_SVR4 */
return fo_ioctl(fp, TIOCSLTC, (caddr_t) &bl, p);
}
case SVR4_TIOCLGET:
{
int flags;
if ((error = fo_ioctl(fp, TIOCLGET, (caddr_t) &flags, p)) != 0)
return error;
DPRINTF(("SVR4_TIOCLGET %o\n", flags));
return copyout(&flags, data, sizeof(flags));
}
case SVR4_TIOCLSET:
case SVR4_TIOCLBIS:
case SVR4_TIOCLBIC:
{
int flags;
if ((error = copyin(data, &flags, sizeof(flags))) != 0)
return error;
switch (cmd) {
case SVR4_TIOCLSET:
cmd = TIOCLSET;
break;
case SVR4_TIOCLBIS:
cmd = TIOCLBIS;
break;
case SVR4_TIOCLBIC:
cmd = TIOCLBIC;
break;
}
DPRINTF(("SVR4_TIOCL{SET,BIS,BIC} %o\n", flags));
return fo_ioctl(fp, cmd, (caddr_t) &flags, p);
}
default:
DPRINTF(("Unknown svr4 ttold %lx\n", cmd));
return 0; /* ENOSYS really */
}
}
Reference in New Issue View Git Blame Copy Permalink