Update.
[glibc.git] / hurd / hurdioctl.c
blob073c15edcca18cc5aec27794e36a4a9820129009
1 /* ioctl commands which must be done in the C library.
2 Copyright (C) 1994, 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
20 #include <hurd.h>
21 #include <hurd/fd.h>
22 #include <sys/ioctl.h>
23 #include <hurd/ioctl.h>
27 /* Symbol set of ioctl handler lists. If there are user-registered
28 handlers, one of these lists will contain them. The other lists are
29 handlers built into the library. */
30 symbol_set_define (_hurd_ioctl_handler_lists)
32 /* Look up REQUEST in the set of handlers. */
33 ioctl_handler_t
34 _hurd_lookup_ioctl_handler (int request)
36 void *const *ptr;
37 const struct ioctl_handler *h;
39 /* Mask off the type bits, so that we see requests in a single group as a
40 contiguous block of values. */
41 request = _IOC_NOTYPE (request);
43 for (ptr = symbol_set_first_element (_hurd_ioctl_handler_lists);
44 !symbol_set_end_p (_hurd_ioctl_handler_lists, ptr);
45 ++ptr)
46 for (h = *ptr; h != NULL; h = h->next)
47 if (request >= h->first_request && request <= h->last_request)
48 return h->handler;
50 return NULL;
53 #include <fcntl.h>
55 /* Find out how many bytes may be read from FD without blocking. */
57 static int
58 fioctl (int fd,
59 int request,
60 int *arg)
62 error_t err;
64 *(volatile int *) arg = *arg;
66 switch (request)
68 default:
69 err = ENOTTY;
70 break;
72 case FIONREAD:
74 mach_msg_type_number_t navail;
75 err = HURD_DPORT_USE (fd, __io_readable (port, &navail));
76 if (!err)
77 *arg = (int) navail;
79 break;
81 case FIONBIO:
82 err = HURD_DPORT_USE (fd, (*arg ?
83 __io_set_some_openmodes :
84 __io_clear_some_openmodes)
85 (port, O_NONBLOCK));
86 break;
88 case FIOASYNC:
89 err = HURD_DPORT_USE (fd, (*arg ?
90 __io_set_some_openmodes :
91 __io_clear_some_openmodes)
92 (port, O_ASYNC));
93 break;
95 case FIOSETOWN:
96 err = HURD_DPORT_USE (fd, __io_mod_owner (port, *arg));
97 break;
99 case FIOGETOWN:
100 err = HURD_DPORT_USE (fd, __io_get_owner (port, arg));
101 break;
104 return err ? __hurd_dfail (fd, err) : 0;
107 _HURD_HANDLE_IOCTLS (fioctl, FIOGETOWN, FIONREAD);
110 static int
111 fioclex (int fd,
112 int request)
114 int flag;
116 switch (request)
118 default:
119 return __hurd_fail (ENOTTY);
120 case FIOCLEX:
121 flag = FD_CLOEXEC;
122 break;
123 case FIONCLEX:
124 flag = 0;
125 break;
128 return __fcntl (fd, F_SETFD, flag);
130 _HURD_HANDLE_IOCTLS (fioclex, FIOCLEX, FIONCLEX);
132 #include <hurd/term.h>
133 #include <hurd/tioctl.h>
135 /* Install a new CTTYID port, atomically updating the dtable appropriately.
136 This consumes the send right passed in. */
138 void
139 _hurd_locked_install_cttyid (mach_port_t cttyid)
141 mach_port_t old;
142 struct hurd_port *const port = &_hurd_ports[INIT_PORT_CTTYID];
143 struct hurd_userlink ulink;
144 int i;
146 /* Install the new cttyid port, and preserve it with a ulink.
147 We unroll the _hurd_port_set + _hurd_port_get here so that
148 there is no window where the cell is unlocked and CTTYID could
149 be changed by another thread. (We also delay the deallocation
150 of the old port until the end, to minimize the duration of the
151 critical section.)
153 It is important that changing the cttyid port is only ever done by
154 holding the dtable lock continuously while updating the port cell and
155 re-ctty'ing the dtable; dtable.c assumes we do this. Otherwise, the
156 pgrp-change notification code in dtable.c has to worry about racing
157 against us here in odd situations. The one exception to this is
158 setsid, which holds the dtable lock while changing the pgrp and
159 clearing the cttyid port, and then unlocks the dtable lock to allow
164 __spin_lock (&port->lock);
165 old = _hurd_userlink_clear (&port->users) ? port->port : MACH_PORT_NULL;
166 port->port = cttyid;
167 cttyid = _hurd_port_locked_get (port, &ulink);
169 for (i = 0; i < _hurd_dtablesize; ++i)
171 struct hurd_fd *const d = _hurd_dtable[i];
172 mach_port_t newctty;
174 if (d == NULL)
175 /* Nothing to do for an unused descriptor cell. */
176 continue;
178 if (cttyid == MACH_PORT_NULL)
179 /* We now have no controlling tty at all. */
180 newctty = MACH_PORT_NULL;
181 else
182 HURD_PORT_USE (&d->port,
183 ({ mach_port_t id;
184 /* Get the io object's cttyid port. */
185 if (! __term_getctty (port, &id))
187 if (id == cttyid && /* Is it ours? */
188 /* Get the ctty io port. */
189 __term_open_ctty (port,
190 _hurd_pid, _hurd_pgrp,
191 &newctty))
192 /* XXX it is our ctty but the call failed? */
193 newctty = MACH_PORT_NULL;
194 __mach_port_deallocate
195 (__mach_task_self (), (mach_port_t) id);
197 else
198 newctty = MACH_PORT_NULL;
200 }));
202 /* Install the new ctty port. */
203 _hurd_port_set (&d->ctty, newctty);
206 __mutex_unlock (&_hurd_dtable_lock);
208 if (old != MACH_PORT_NULL)
209 __mach_port_deallocate (__mach_task_self (), old);
210 _hurd_port_free (port, &ulink, cttyid);
213 static void
214 install_ctty (mach_port_t cttyid)
216 HURD_CRITICAL_BEGIN;
217 __mutex_lock (&_hurd_dtable_lock);
218 _hurd_locked_install_cttyid (cttyid);
219 HURD_CRITICAL_END;
223 /* Called when we have received a message saying to use a new ctty ID port. */
225 error_t
226 _hurd_setcttyid (mach_port_t cttyid)
228 error_t err;
230 if (cttyid != MACH_PORT_NULL)
232 /* Give the new send right a user reference.
233 This is a good way to check that it is valid. */
234 if (err = __mach_port_mod_refs (__mach_task_self (), cttyid,
235 MACH_PORT_RIGHT_SEND, 1))
236 return err;
239 /* Install the port, consuming the reference we just created. */
240 install_ctty (cttyid);
242 return 0;
246 /* Make FD be the controlling terminal.
247 This function is called for `ioctl (fd, TCIOSCTTY)'. */
249 static int
250 tiocsctty (int fd,
251 int request) /* Always TIOCSCTTY. */
253 mach_port_t cttyid;
254 error_t err;
256 /* Get FD's cttyid port, unless it is already ours. */
257 err = HURD_DPORT_USE (fd, ctty != MACH_PORT_NULL ? EADDRINUSE :
258 __term_getctty (port, &cttyid));
259 if (err == EADDRINUSE)
260 /* FD is already the ctty. Nothing to do. */
261 return 0;
262 else if (err)
263 return __hurd_fail (err);
265 /* Change the terminal's pgrp to ours. */
266 err = HURD_DPORT_USE (fd, __tioctl_tiocspgrp (port, _hurd_pgrp));
267 if (err)
268 return __hurd_fail (err);
270 /* Make it our own. */
271 install_ctty (cttyid);
273 return 0;
275 _HURD_HANDLE_IOCTL (tiocsctty, TIOCSCTTY);
277 /* Dissociate from the controlling terminal. */
279 static int
280 tiocnotty (int fd,
281 int request) /* Always TIOCNOTTY. */
283 mach_port_t fd_cttyid;
284 error_t err;
286 if (err = HURD_DPORT_USE (fd, __term_getctty (port, &fd_cttyid)))
287 return __hurd_fail (err);
289 if (__USEPORT (CTTYID, port != fd_cttyid))
290 err = EINVAL;
292 __mach_port_deallocate (__mach_task_self (), fd_cttyid);
294 if (err)
295 return __hurd_fail (err);
297 /* Clear our cttyid port. */
298 install_ctty (MACH_PORT_NULL);
300 return 0;
302 _HURD_HANDLE_IOCTL (tiocnotty, TIOCNOTTY);