自学教程：C++ tty_unlock函数代码示例

static int ptmx_open(struct inode *inode, struct file *filp){	struct tty_struct *tty;	int retval;	int index;	nonseekable_open(inode, filp);	/* We refuse fsnotify events on ptmx, since it's a shared resource */	filp->f_mode |= FMODE_NONOTIFY;	retval = tty_alloc_file(filp);	if (retval)		return retval;	/* find a device that is not in use. */	tty_lock();	index = devpts_new_index(inode);	tty_unlock();	if (index < 0) {		retval = index;		goto err_file;	}	mutex_lock(&tty_mutex);	tty_lock();	tty = tty_init_dev(ptm_driver, index, 1);	mutex_unlock(&tty_mutex);	if (IS_ERR(tty)) {		retval = PTR_ERR(tty);		goto out;	}	set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */	tty_add_file(tty, filp);	retval = devpts_pty_new(inode, tty->link);	if (retval)		goto err_release;	retval = ptm_driver->ops->open(tty, filp);	if (retval)		goto err_release;	tty_unlock();	return 0;err_release:	tty_unlock();	tty_release(inode, filp);	return retval;out:	devpts_kill_index(inode, index);	tty_unlock();err_file:	tty_free_file(filp);	return retval;}

static int briq_panel_open(struct inode *ino, struct file *filep){	tty_lock();	/* enforce single access, vfd_is_open is protected by BKL */	if (vfd_is_open) {		tty_unlock();		return -EBUSY;	}	vfd_is_open = 1;	tty_unlock();	return 0;}

static intptsdev_poll(struct file *fp, int events, struct ucred *active_cred,    struct thread *td){	struct tty *tp = fp->f_data;	struct pts_softc *psc = tty_softc(tp);	int revents = 0;	tty_lock(tp);	if (psc->pts_flags & PTS_FINISHED) {		/* Slave device is not opened. */		tty_unlock(tp);		return ((events & (POLLIN|POLLRDNORM)) | POLLHUP);	}	if (events & (POLLIN|POLLRDNORM)) {		/* See if we can getc something. */		if (ttydisc_getc_poll(tp) ||		    (psc->pts_flags & PTS_PKT && psc->pts_pkt))			revents |= events & (POLLIN|POLLRDNORM);	}	if (events & (POLLOUT|POLLWRNORM)) {		/* See if we can rint something. */		if (ttydisc_rint_poll(tp))			revents |= events & (POLLOUT|POLLWRNORM);	}	/*	 * No need to check for POLLHUP here. This device cannot be used	 * as a callout device, which means we always have a carrier,	 * because the master is.	 */	if (revents == 0) {		/*		 * This code might look misleading, but the naming of		 * poll events on this side is the opposite of the slave		 * device.		 */		if (events & (POLLIN|POLLRDNORM))			selrecord(td, &psc->pts_outpoll);		if (events & (POLLOUT|POLLWRNORM))			selrecord(td, &psc->pts_inpoll);	}	tty_unlock(tp);	return (revents);}

static voidnmdm_task_tty(void *arg, int pending __unused){	struct tty *tp, *otp;	struct nmdmpart *np = arg;	char c;	tp = np->np_tty;	tty_lock(tp);	if (tty_gone(tp)) {		tty_unlock(tp);		return;	}	otp = np->np_other->np_tty;	KASSERT(otp != NULL, ("NULL otp in nmdmstart"));	KASSERT(otp != tp, ("NULL otp == tp nmdmstart"));	if (np->np_other->np_dcd) {		if (!tty_opened(tp)) {			np->np_other->np_dcd = 0;			ttydisc_modem(otp, 0);		}	} else {		if (tty_opened(tp)) {			np->np_other->np_dcd = 1;			ttydisc_modem(otp, 1);		}	}	/* This may happen when we are in detach process. */	if (tty_gone(otp)) {		tty_unlock(otp);		return;	}	while (ttydisc_rint_poll(otp) > 0) {		if (np->np_rate && !np->np_quota)			break;		if (ttydisc_getc(tp, &c, 1) != 1)			break;		np->np_quota--;		ttydisc_rint(otp, c, 0);	}	ttydisc_rint_done(otp);	tty_unlock(tp);}

static int spk_ttyio_initialise_ldisc(struct spk_synth *synth){	int ret = 0;	struct tty_struct *tty;	struct ktermios tmp_termios;	dev_t dev;	ret = get_dev_to_use(synth, &dev);	if (ret)		return ret;	tty = tty_kopen(dev);	if (IS_ERR(tty))		return PTR_ERR(tty);	if (tty->ops->open)		ret = tty->ops->open(tty, NULL);	else		ret = -ENODEV;	if (ret) {		tty_unlock(tty);		return ret;	}	clear_bit(TTY_HUPPED, &tty->flags);	/* ensure hardware flow control is enabled */	get_termios(tty, &tmp_termios);	if (!(tmp_termios.c_cflag & CRTSCTS)) {		tmp_termios.c_cflag |= CRTSCTS;		tty_set_termios(tty, &tmp_termios);		/*		 * check c_cflag to see if it's updated as tty_set_termios may not return		 * error even when no tty bits are changed by the request.		 */		get_termios(tty, &tmp_termios);		if (!(tmp_termios.c_cflag & CRTSCTS))			pr_warn("speakup: Failed to set hardware flow control/n");	}	tty_unlock(tty);	ret = tty_set_ldisc(tty, N_SPEAKUP);	if (ret)		pr_err("speakup: Failed to set N_SPEAKUP on tty/n");	return ret;}

static int ptmx_open(struct inode *inode, struct file *filp){	struct tty_struct *tty;	int retval;	int index;	nonseekable_open(inode, filp);	/* find a device that is not in use. */	tty_lock();	index = devpts_new_index(inode);	tty_unlock();	if (index < 0)		return index;	mutex_lock(&tty_mutex);	tty_lock();	tty = tty_init_dev(ptm_driver, index, 1);	mutex_unlock(&tty_mutex);	if (IS_ERR(tty)) {		retval = PTR_ERR(tty);		goto out;	}	set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */	tty_add_file(tty, filp);	retval = devpts_pty_new(inode, tty->link);	if (retval)		goto out1;	retval = ptm_driver->ops->open(tty, filp);	if (retval)		goto out2;out1:	tty_unlock();	return retval;out2:	tty_unlock();	tty_release(inode, filp);	return retval;out:	devpts_kill_index(inode, index);	tty_unlock();	return retval;}

int kmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, proc_t p){    int error = 0;    struct tty *tp = km_tty[minor(dev)];    struct winsize *wp;    tty_lock(tp);    switch (cmd) {    case KMIOCSIZE:        wp = (struct winsize *) data;        *wp = tp->t_winsize;        break;    case TIOCSWINSZ:        /*         * Prevent changing of console size --         * * this ensures that login doesn't revert to the         * * termcap-defined size         */        error = EINVAL;        break;        /*         * Bodge in the CLOCAL flag as the km device is always local          */    case TIOCSETA_32:    case TIOCSETAW_32:    case TIOCSETAF_32:        {            struct termios32 *t = (struct termios32 *) data;            t->c_cflag |= CLOCAL;            /*             * No Break              */        }        goto fallthrough;    case TIOCSETA_64:    case TIOCSETAW_64:    case TIOCSETAF_64:        {            struct user_termios *t = (struct user_termios *) data;            t->c_cflag |= CLOCAL;            /*             * No Break              */        } fallthrough:    default:        error = (*linesw[tp->t_line].l_ioctl) (tp, cmd, data, flag, p);        if (ENOTTY != error)            break;        error = ttioctl_locked(tp, cmd, data, flag, p);        break;    }    tty_unlock(tp);    return (error);}

void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty){	/*	 * Prevent flush_to_ldisc() from rescheduling the work for later.  Then	 * kill any delayed work. As this is the final close it does not	 * race with the set_ldisc code path.	 */	tty_unlock();	tty_ldisc_halt(tty);	tty_ldisc_flush_works(tty);	tty_lock();	mutex_lock(&tty->ldisc_mutex);	/*	 * Now kill off the ldisc	 */	tty_ldisc_close(tty, tty->ldisc);	tty_ldisc_put(tty->ldisc);	/* Force an oops if we mess this up */	tty->ldisc = NULL;	/* Ensure the next open requests the N_TTY ldisc */	tty_set_termios_ldisc(tty, N_TTY);	mutex_unlock(&tty->ldisc_mutex);	/* This will need doing differently if we need to lock */	if (o_tty)		tty_ldisc_release(o_tty, NULL);	/* And the memory resources remaining (buffers, termios) will be	   disposed of when the kref hits zero */}

static intptsdev_kqfilter(struct file *fp, struct knote *kn){	struct tty *tp = fp->f_data;	struct pts_softc *psc = tty_softc(tp);	int error = 0;	tty_lock(tp);	switch (kn->kn_filter) {	case EVFILT_READ:		kn->kn_fop = &pts_kqops_read;		knlist_add(&psc->pts_outpoll.si_note, kn, 1);		break;	case EVFILT_WRITE:		kn->kn_fop = &pts_kqops_write;		knlist_add(&psc->pts_inpoll.si_note, kn, 1);		break;	default:		error = EINVAL;		break;	}	tty_unlock(tp);	return (error);}

void xencons_rx(char *buf, unsigned len){	int           i;	struct tty *tp = xccons;	if (xen_console_up#ifdef DDB	    && !kdb_active#endif		) {		tty_lock(tp);		for (i = 0; i < len; i++) {#ifdef KDB			kdb_alt_break(buf[i], &xc_altbrk);#endif			ttydisc_rint(tp, buf[i], 0);		}		ttydisc_rint_done(tp);		tty_unlock(tp);	} else {		CN_LOCK(cn_mtx);		for (i = 0; i < len; i++)			rbuf[RBUF_MASK(rp++)] = buf[i];		CN_UNLOCK(cn_mtx);	}}

static void pty_close(struct tty_struct *tty, struct file *filp){	BUG_ON(!tty);	if (tty->driver->subtype == PTY_TYPE_MASTER)		WARN_ON(tty->count > 1);	else {		if (tty->count > 2)			return;	}	wake_up_interruptible(&tty->read_wait);	wake_up_interruptible(&tty->write_wait);	tty->packet = 0;	if (!tty->link)		return;	set_bit(TTY_OTHER_CLOSED, &tty->link->flags);	wake_up_interruptible(&tty->link->read_wait);	wake_up_interruptible(&tty->link->write_wait);	if (tty->driver->subtype == PTY_TYPE_MASTER) {		set_bit(TTY_OTHER_CLOSED, &tty->flags);#ifdef CONFIG_UNIX98_PTYS		if (tty->driver == ptm_driver)			devpts_pty_kill(tty->link);#endif		tty_unlock();		tty_vhangup(tty->link);		tty_lock();	}}

/* * cons_cinput * * Driver character input from the polled mode serial console driver calls * this routine to input a character from the serial driver into the tty * line discipline specific input processing receiv interrupt routine, * l_rint(). * * Locks:       Assumes that the tty_lock() is NOT held on the tp, so a *              serial driver should NOT call this function as a result *              of being called from a function which already holds the *              lock; ECHOE will be handled at the line discipline, if *              output echo processing is going to occur. */void cons_cinput(char ch){    struct tty *tp = km_tty[0]; /* XXX */    tty_lock(tp);    (*linesw[tp->t_line].l_rint) (ch, tp);    tty_unlock(tp);}

/*  * One-shot output retry timeout from kmoutput(); re-calls kmoutput() at * intervals until the output queue for the tty is empty, at which point * the timeout is not rescheduled by kmoutput() *  * This function must take the tty_lock() around the kmoutput() call; it * ignores the return value. */static void kmtimeout(void *arg){    struct tty *tp = (struct tty *) arg;    tty_lock(tp);    (void) kmoutput(tp);    tty_unlock(tp);}

static voidbvm_tty_close(struct tty *tp){	tty_lock(tp);	callout_stop(&bvm_timer);	tty_unlock(tp);}

/** *	tty_ldisc_change	-	change line discipline *	@tty: tty to change *	@disc: new line discipine number * *	Change the line discipline of the tty. The tty must have an old *	ldisc attached to, we must handle it properly. Sandix implement *	it quite simple, but please look at linux, see how complex it is! *	XXX tty shoud be locked */int tty_ldisc_change(struct tty_struct *tty, int disc){	int ret;	struct tty_ldisc *old_ldisc, *new_ldisc;	BUG_ON(!tty->ldisc);	if (tty->ldisc->ops->num == disc)		return 0;	tty_lock(tty);	new_ldisc = tty_ldisc_get(tty, disc);	if (IS_ERR(new_ldisc)) {		tty_unlock(tty);		return PTR_ERR(new_ldisc);	}	old_ldisc = tty->ldisc;	/* Close the old one */	tty_ldisc_close(tty, old_ldisc);	/* Set up the new one */	tty->ldisc = new_ldisc;	tty_set_termios_ldisc(tty, disc);	ret = tty_ldisc_open(tty, new_ldisc);	if (ret) {		/* Back to the old one or N_TTY */		tty_ldisc_put(new_ldisc);		tty_ldisc_restore(tty, old_ldisc);	}	/*	 * At this point we hold a reference to the new ldisc and a	 * reference to the old ldisc, or we hold two references to	 * the old ldisc (if it was restored as part of error cleanup	 * above). In either case, releasing a single reference from	 * the old ldisc is correct.	 */	tty_ldisc_put(old_ldisc);	tty_unlock(tty);	return ret;}

static ssize_t r3964_write(struct tty_struct *tty, struct file *file,			   const unsigned char *data, size_t count){	struct r3964_info *pInfo = tty->disc_data;	struct r3964_block_header *pHeader;	struct r3964_client_info *pClient;	unsigned char *new_data;	TRACE_L("write request, %d characters", count);	if (!pInfo)		return -EIO;	if (count > R3964_MTU) {		if (pInfo->flags & R3964_DEBUG) {			TRACE_L(KERN_WARNING "r3964_write: truncating user "				"packet from %u to mtu %d", count, R3964_MTU);		}		count = R3964_MTU;	}	new_data = kmalloc(count + sizeof(struct r3964_block_header),			GFP_KERNEL);	TRACE_M("r3964_write - kmalloc %p", new_data);	if (new_data == NULL) {		if (pInfo->flags & R3964_DEBUG) {			printk(KERN_ERR "r3964_write: no memory/n");		}		return -ENOSPC;	}	pHeader = (struct r3964_block_header *)new_data;	pHeader->data = new_data + sizeof(struct r3964_block_header);	pHeader->length = count;	pHeader->locks = 0;	pHeader->owner = NULL;	tty_lock();	pClient = findClient(pInfo, task_pid(current));	if (pClient) {		pHeader->owner = pClient;	}	memcpy(pHeader->data, data, count);		if (pInfo->flags & R3964_DEBUG) {		dump_block(pHeader->data, count);	}	add_tx_queue(pInfo, pHeader);	trigger_transmit(pInfo);	tty_unlock();	return 0;}

static ssize_t r3964_read(struct tty_struct *tty, struct file *file,			  unsigned char __user * buf, size_t nr){	struct r3964_info *pInfo = tty->disc_data;	struct r3964_client_info *pClient;	struct r3964_message *pMsg;	struct r3964_client_message theMsg;	int ret;	TRACE_L("read()");	tty_lock();	pClient = findClient(pInfo, task_pid(current));	if (pClient) {		pMsg = remove_msg(pInfo, pClient);		if (pMsg == NULL) {			/* no messages available. */			if (file->f_flags & O_NONBLOCK) {				ret = -EAGAIN;				goto unlock;			}			/* block until there is a message: */			wait_event_interruptible_tty(pInfo->read_wait,					(pMsg = remove_msg(pInfo, pClient)));		}		/* If we still haven't got a message, we must have been signalled */		if (!pMsg) {			ret = -EINTR;			goto unlock;		}		/* deliver msg to client process: */		theMsg.msg_id = pMsg->msg_id;		theMsg.arg = pMsg->arg;		theMsg.error_code = pMsg->error_code;		ret = sizeof(struct r3964_client_message);		kfree(pMsg);		TRACE_M("r3964_read - msg kfree %p", pMsg);		if (copy_to_user(buf, &theMsg, ret)) {			ret = -EFAULT;			goto unlock;		}		TRACE_PS("read - return %d", ret);		goto unlock;	}	ret = -EPERM;unlock:	tty_unlock();	return ret;}

int kmwrite(dev_t dev, struct uio *uio, int ioflag){    int ret;    struct tty *tp = km_tty[minor(dev)];    tty_lock(tp);    ret = (*linesw[tp->t_line].l_write) (tp, uio, ioflag);    tty_unlock(tp);    return (ret);}

int tty_close(){	if(!tty_port) return ME_CLOSE;	DEBUG(('M',2,"tty_close"));	fflush(stdin);fflush(stdout);	tty_cooked();	fclose(stdin);fclose(stdout);	tty_unlock(tty_port);	xfree(tty_port);	return ME_OK;}

voiduart_tty_intr(void *arg){	struct uart_softc *sc = arg;	struct tty *tp;	int c, err = 0, pend, sig, xc;	if (sc->sc_leaving)		return;	pend = atomic_readandclear_32(&sc->sc_ttypend);	if (!(pend & SER_INT_MASK))		return;	tp = sc->sc_u.u_tty.tp;	tty_lock(tp);	if (pend & SER_INT_RXREADY) {		while (!uart_rx_empty(sc) && !sc->sc_isquelch) {			xc = uart_rx_peek(sc);			c = xc & 0xff;			if (xc & UART_STAT_FRAMERR)				err |= TRE_FRAMING;			if (xc & UART_STAT_OVERRUN)				err |= TRE_OVERRUN;			if (xc & UART_STAT_PARERR)				err |= TRE_PARITY;			if (ttydisc_rint(tp, c, err) != 0) {				sc->sc_isquelch = 1;				if ((tp->t_termios.c_cflag & CRTS_IFLOW) &&				    !sc->sc_hwiflow)					UART_SETSIG(sc, SER_DRTS);			} else				uart_rx_next(sc);		}	}	if (pend & SER_INT_BREAK)		ttydisc_rint(tp, 0, TRE_BREAK);	if (pend & SER_INT_SIGCHG) {		sig = pend & SER_INT_SIGMASK;		if (sig & SER_DDCD)			ttydisc_modem(tp, sig & SER_DCD);		if (sig & SER_DCTS)			uart_tty_outwakeup(tp);	}	if (pend & SER_INT_TXIDLE)		uart_tty_outwakeup(tp);	ttydisc_rint_done(tp);	tty_unlock(tp);}

int kmclose(dev_t dev, int flag, __unused int mode, __unused proc_t p){    int ret;    struct tty *tp = km_tty[minor(dev)];    tty_lock(tp);    ret = (*linesw[tp->t_line].l_close) (tp, flag);    ttyclose(tp);    tty_unlock(tp);    return (ret);}

static voidmambo_timeout(void *v){	int 	c;	tty_lock(tp);	while ((c = mambo_cngetc(NULL)) != -1)		ttydisc_rint(tp, c, 0);	ttydisc_rint_done(tp);	tty_unlock(tp);	callout_reset(&mambo_callout, polltime, mambo_timeout, NULL);}

void spk_ttyio_release(void){	if (!speakup_tty)		return;	tty_lock(speakup_tty);	if (speakup_tty->ops->close)		speakup_tty->ops->close(speakup_tty, NULL);	tty_ldisc_flush(speakup_tty);	tty_unlock(speakup_tty);	tty_kclose(speakup_tty);}

static voidbvm_timeout(void *v){	struct	tty *tp;	int 	c;	tp = (struct tty *)v;	tty_lock(tp);	while ((c = bvm_cngetc(NULL)) != -1)		ttydisc_rint(tp, c, 0);	ttydisc_rint_done(tp);	tty_unlock(tp);	bvm_timeouthandle = timeout(bvm_timeout, tp, polltime);}

static int get_serial_info(struct tty_struct *tty, struct serial_struct *ss){	struct serial_state *state = tty->driver_data;	tty_lock(tty);	ss->line = tty->index;	ss->port = state->port;	ss->flags = state->tport.flags;	ss->xmit_fifo_size = state->xmit_fifo_size;	ss->baud_base = state->baud_base;	ss->close_delay = state->tport.close_delay;	ss->closing_wait = state->tport.closing_wait;	ss->custom_divisor = state->custom_divisor;	tty_unlock(tty);	return 0;}