From: Sascha Wildner Date: Mon, 22 Oct 2012 18:06:05 +0000 (+0200) Subject: Remove CAPS. X-Git-Tag: v3.4.0rc~990^2~3 X-Git-Url: https://gitweb.dragonflybsd.org/dragonfly.git/commitdiff_plain/8f8e1daf36fef12527aa047a5a10e5d740a1848d Remove CAPS. OK'd-by: dillon --- diff --git a/Makefile_upgrade.inc b/Makefile_upgrade.inc index 838e709cb6..c1243bcc29 100644 --- a/Makefile_upgrade.inc +++ b/Makefile_upgrade.inc @@ -2059,6 +2059,28 @@ TO_REMOVE+=/usr/share/man/cat1/cpp41.1.gz TO_REMOVE+=/usr/share/man/cat1/g++41.1.gz TO_REMOVE+=/usr/share/man/cat1/gcc41.1.gz TO_REMOVE+=/usr/share/man/cat1/gcov41.1.gz +TO_REMOVE+=/usr/include/sys/caps.h +TO_REMOVE+=/usr/share/man/cat2/caps_sys_abort.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_abort.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_client.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_client.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_close.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_close.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_get.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_get.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_getgen.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_getgen.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_put.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_put.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_reply.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_reply.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_service.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_service.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_setgen.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_setgen.2.gz +TO_REMOVE+=/usr/share/man/cat2/caps_sys_wait.2.gz +TO_REMOVE+=/usr/share/man/man2/caps_sys_wait.2.gz +TO_REMOVE+=/var/caps .if ${MACHINE_ARCH} == "x86_64" TO_REMOVE+=/usr/libdata/stallion/2681.sys diff --git a/etc/mtree/BSD.var.dist b/etc/mtree/BSD.var.dist index 76f2e23597..441a58ffd2 100644 --- a/etc/mtree/BSD.var.dist +++ b/etc/mtree/BSD.var.dist @@ -25,12 +25,6 @@ .. .. /set mode=0755 - caps - root - .. - users - .. - .. db .. empty mode=0555 flags=schg diff --git a/gnu/usr.bin/groff/tmac/mdoc.local b/gnu/usr.bin/groff/tmac/mdoc.local index 7660b6bc7a..ad0fe3f01c 100644 --- a/gnu/usr.bin/groff/tmac/mdoc.local +++ b/gnu/usr.bin/groff/tmac/mdoc.local @@ -38,7 +38,6 @@ .ds doc-str-Lb-libbsdxml eXpat XML parser library (libbsdxml, \-lbsdxml) .ds doc-str-Lb-libcalendar Calendar Arithmetic Library (libcalendar, \-lcalendar) .ds doc-str-Lb-libcam Common Access Method User Library (libcam, \-lcam) -.ds doc-str-Lb-libcaps CAPS IPC Library (libcaps, \-lcaps) .ds doc-str-Lb-libcipher FreeSec Crypt Library (libcipher, \-lcipher) .ds doc-str-Lb-libdevattr Device attribute and event library (libdevattr \-ldevattr) .ds doc-str-Lb-libdevinfo Device and Resource Information Utility Library (libdevinfo, \-ldevinfo) diff --git a/lib/libc/sys/Makefile.inc b/lib/libc/sys/Makefile.inc index bd2e7ad4be..16130705c1 100644 --- a/lib/libc/sys/Makefile.inc +++ b/lib/libc/sys/Makefile.inc @@ -60,9 +60,6 @@ MAN+= _exit.2 accept.2 access.2 acct.2 adjtime.2 \ aio_cancel.2 aio_error.2 aio_read.2 aio_return.2 \ aio_suspend.2 aio_waitcomplete.2 aio_write.2 \ bind.2 brk.2 \ - caps_sys_abort.2 caps_sys_client.2 caps_sys_close.2 caps_sys_get.2 \ - caps_sys_getgen.2 caps_sys_put.2 caps_sys_reply.2 caps_sys_service.2 \ - caps_sys_setgen.2 \ sys_checkpoint.2 chdir.2 chflags.2 \ chmod.2 chown.2 chroot.2 clock_gettime.2 close.2 closefrom.2 \ connect.2 dup.2 execve.2 extattr.2 extexit.2 \ @@ -101,7 +98,6 @@ MAN+= sched_get_priority_max.2 sched_setparam.2 \ MLINKS+=access.2 faccessat.2 MLINKS+=brk.2 sbrk.2 -MLINKS+=caps_sys_get.2 caps_sys_wait.2 MLINKS+=chdir.2 fchdir.2 MLINKS+=chflags.2 fchflags.2 chflags.2 lchflags.2 MLINKS+=chmod.2 fchmod.2 chmod.2 lchmod.2 chmod.2 fchmodat.2 diff --git a/lib/libc/sys/caps_sys_abort.2 b/lib/libc/sys/caps_sys_abort.2 deleted file mode 100644 index a2382e13ea..0000000000 --- a/lib/libc/sys/caps_sys_abort.2 +++ /dev/null @@ -1,90 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_abort.2,v 1.1 2006/02/28 22:40:49 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_ABORT 2 -.Os -.Sh NAME -.Nm caps_sys_abort -.Nd abort a CAPS IPC message -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft int -.Fn caps_sys_abort "int portid" "off_t msgid" "int flags" -.Sh DESCRIPTION -Abort a previously sent message. -The -.Fa portid -argument is a port identifier returned by a previous call to -.Fn caps_sys_service -or -.Fn caps_sys_client . -The message to be aborted is identified by the 64 bit -.Fa msgid -that was returned by a previous call to -.Fn caps_sys_put . -.Pp -You must still wait for the message to be returned after sending the -abort request. -.\".Sh RETURN VALUES -.\"This function returns an abort code indicating failure or success of -.\"the call: -.\".Bl -tag -width ".Dv CAPS_ABORT_BEFORESERVER" -.\".It Dv CAPS_ABORT_RETURNED -.\"The message was already returned. -.\"No action is taken. -.\".It Dv CAPS_ABORT_BEFORESERVER -.\"The message was caught before the server got it. -.\".It Dv CAPS_ABORT_ATSERVER -.\"The message was already retrieved by the server. -.\".El -.Sh SEE ALSO -.Xr caps_sys_client 2 , -.Xr caps_sys_put 2 , -.Xr caps_sys_service 2 -.Sh HISTORY -The -.Fn caps_sys_abort -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . -.Sh BUGS -This function is currently not implemented and -.Dv CAPS_ABORT_NOTIMPL -is returned. diff --git a/lib/libc/sys/caps_sys_client.2 b/lib/libc/sys/caps_sys_client.2 deleted file mode 100644 index 17a1dce63a..0000000000 --- a/lib/libc/sys/caps_sys_client.2 +++ /dev/null @@ -1,101 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_client.2,v 1.2 2006/03/02 19:27:35 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_CLIENT 2 -.Os -.Sh NAME -.Nm caps_sys_client -.Nd create a CAPS IPC client -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft int -.Fo caps_sys_client -.Fa "const char *name" -.Fa "uid_t uid" -.Fa "gid_t gid" -.Fa "int upcid" -.Fa "int flags" -.Fc -.Sh DESCRIPTION -Create an IPC client connected to the service specified by the -.Fa name -argument. -Either -.Fa uid -or -.Fa gid -can be -1 (thereby indicating a wildcard), -but not both. -Programs connecting to a -.Em generic -service typically first try -.Fn getuid -and -1, then try -1 and -.Fn getgid , -then try 0 and 0. -The -.Fa upcid -argument can either be an upcall or a kqueue identifier. -.Sh RETURN VALUES -On success, this function returns a port identifier. -On failure, -1 is returned and -.Va errno -is set to indicate the error. -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er EOPNOTSUPP" -.It Bq Er EOPNOTSUPP -The CAPS system has not been enabled with -.Va kern.caps_enabled . -.It Bq Er EINVAL -An invalid argument was specified. -.El -.Sh SEE ALSO -.Xr caps_sys_service 2 -.Sh HISTORY -The -.Fn caps_sys_client -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . -.Sh BUGS -Support for the -.Fa upcid -argument is currently not implemented. diff --git a/lib/libc/sys/caps_sys_close.2 b/lib/libc/sys/caps_sys_close.2 deleted file mode 100644 index c705b9e42c..0000000000 --- a/lib/libc/sys/caps_sys_close.2 +++ /dev/null @@ -1,77 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_close.2,v 1.1 2006/02/28 22:40:49 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_CLOSE 2 -.Os -.Sh NAME -.Nm caps_sys_close -.Nd terminate a CAPS IPC link -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft int -.Fn caps_sys_close "int portid" -.Sh DESCRIPTION -Terminate a CAPS IPC link. -The -.Fa portid -argument is a port identifier returned by a previous call to -.Fn caps_sys_service -or -.Fn caps_sys_client . -Any unreplied messages will be automatically replied to by the kernel. -.Sh RETURN VALUES -.Rv -std caps_sys_close -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er EINVAL" -.It Bq Er EINVAL -The -.Fa portid -could not be found. -.El -.Sh SEE ALSO -.Xr caps_sys_client 2 , -.Xr caps_sys_service 2 -.Sh HISTORY -The -.Fn caps_sys_close -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . diff --git a/lib/libc/sys/caps_sys_get.2 b/lib/libc/sys/caps_sys_get.2 deleted file mode 100644 index 70aabe7bf7..0000000000 --- a/lib/libc/sys/caps_sys_get.2 +++ /dev/null @@ -1,168 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_get.2,v 1.2 2006/03/02 19:27:35 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_GET 2 -.Os -.Sh NAME -.Nm caps_sys_get , -.Nm caps_sys_wait -.Nd retrieve a message from a CAPS IPC port -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft int -.Fo caps_sys_get -.Fa "int portid" -.Fa "void *msg" -.Fa "int maxsize" -.Fa "struct caps_msgid *msgid" -.Fa "struct caps_cred *ccr" -.Fc -.Ft int -.Fo caps_sys_wait -.Fa "int portid" -.Fa "void *msg" -.Fa "int maxsize" -.Fa "struct caps_msgid *msgid" -.Fa "struct caps_cred *ccr" -.Fc -.Sh DESCRIPTION -The -.Fn caps_sys_get -function retrieves the next ready message from a port specified by -.Fa portid . -The identifier and creds of the message are stored in -.Fa msgid -and -.Fa ccr -(which may be NULL). -.Pp -The message is only stored in the -.Fa msg -buffer if its length is less or equal than the size specified by -.Fa maxsize . -If the message is too large its identifier and creds are still -returned but the message is not dequeued. -In this case, the caller is expected to call -.Fn caps_sys_get -again with a larger buffer or to call -.Fn caps_sys_reply -on the -.Fa msgid -without retrieving it (if it does not want to handle the message). -.Pp -The returned -.Fa msg -can either be a new message from a client, a reply from the service, -or (on the service side only) -an acknowledgement that a reply made earlier has been processed by -the client. -This state information is stored in -.Va msgid->c_state -and can be: -.Bl -tag -width ".Dv CAPMS_REQUEST_RETRY" -.It Dv CAPMS_REQUEST -The server side received a new request. -.It Dv CAPMS_REQUEST_RETRY -Reserved for future use. -.It Dv CAPMS_REPLY -The client side received a reply. -.It Dv CAPMS_REPLY_RETRY -Reserved for future use. -.It Dv CAPMS_DISPOSE -The server side reply has been disposed of by the client. -.El -.Pp -If you are a CAPS client the only message type you will get is -.Dv CAPMS_REPLY . -If you are a CAPS server you can get -.Dv CAPMS_REQUEST -or -.Dv CAPMS_DISPOSE -message types. -.Pp -The -.Fn caps_sys_get -function does not block. -If a blocking function is needed -.Fn caps_sys_wait -can be used which blocks until it is interrupted or a message is -received. -.Sh RETURN VALUES -If successful, the -.Fn caps_sys_get -and -.Fn caps_sys_wait -functions return the length of the message received. -Note that zero message lengths are perfectly acceptable so 0 can be -legitimately returned. -On failure, -1 is returned and -.Va errno -is set to indicate the error. -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er EWOULDBLOCK" -.It Bq Er EINVAL -An invalid argument was specified. -.It Bq Er ENOTCONN -The process originally creating the port forked and the child -process attempts to access the port. -The child process is expected to create its own port. -This error is also returned if the remote end closed its connection -and is no longer available. -.It Bq Er EWOULDBLOCK -No messages are ready (this applies only to -.Fn caps_sys_get ) . -.It Bq Er EINTR -The system call was interrupted (this applies only to -.Fn caps_sys_wait ) . -.El -.Sh SEE ALSO -.Xr caps_sys_client 2 , -.Xr caps_sys_put 2 , -.Xr caps_sys_reply 2 , -.Xr caps_sys_service 2 -.Sh HISTORY -The -.Fn caps_sys_get -and -.Fn caps_sys_wait -function calls first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . diff --git a/lib/libc/sys/caps_sys_getgen.2 b/lib/libc/sys/caps_sys_getgen.2 deleted file mode 100644 index a44247c5cc..0000000000 --- a/lib/libc/sys/caps_sys_getgen.2 +++ /dev/null @@ -1,83 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_getgen.2,v 1.1 2006/02/28 22:40:49 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_GETGEN 2 -.Os -.Sh NAME -.Nm caps_sys_getgen -.Nd get the generation number for a CAPS IPC link -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft caps_gen_t -.Fn caps_sys_getgen "int portid" -.Sh DESCRIPTION -The -.Fn caps_sys_getgen -function returns the 64 bit generation number for a CAPS link -specified by the -.Fa portid -identifier. -This number is typically used to allow a client to detect when a -service has been restarted. -.Sh RETURN VALUES -On success, the 64 bit generation number is returned. -If an error occurs, -1 is returned and -.Va errno -is set. -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er ENOTCONN" -.It Bq Er EINVAL -The -.Fa portid -could not be found. -.It Bq Er ENOTCONN -The process originally creating the port forked and the child -process attempts to access the port. -The child process is expected to create its own port. -.El -.Sh SEE ALSO -.Xr caps_sys_setgen 2 -.Sh HISTORY -The -.Fn caps_sys_getgen -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . diff --git a/lib/libc/sys/caps_sys_put.2 b/lib/libc/sys/caps_sys_put.2 deleted file mode 100644 index 60bf082808..0000000000 --- a/lib/libc/sys/caps_sys_put.2 +++ /dev/null @@ -1,92 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_put.2,v 1.1 2006/02/28 22:40:49 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_PUT 2 -.Os -.Sh NAME -.Nm caps_sys_put -.Nd send an opaque message to a CAPS IPC port -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft off_t -.Fn caps_sys_put "int portid" "const void *msg" "int msgsize" -.Sh DESCRIPTION -Send an opaque message -.Fa msg -of the specified size -.Fa msgsiz -to the port identified by -.Fa portid . -The memory associated with the message must be left intact until the -message is returned. -The kernel does not make a copy of the message and its size may not -exceed 128KB. -.Pp -This function is only used on the client side. -.Sh RETURN VALUES -On success, this function returns a 64 bit message identifier. -If an error occurs, -1 is returned and -.Va errno -is set. -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er ENOTCONN" -.It Bq Er EINVAL -An invalid argument was specified. -.It Bq Er ENOTCONN -The process originally creating the port forked and the child -process attempts to access the port. -The child process is expected to create its own port. -This error is also returned if the remote end closed its connection -and is no longer available. -.It Bq Er ENOBUFS -The maximum number of in-transmit messages has been reached. -No more messages can be sent until some of them are replied to. -.El -.Sh SEE ALSO -.Xr caps_sys_client 2 , -.Xr caps_sys_get 2 , -.Xr caps_sys_service 2 -.Sh HISTORY -The -.Fn caps_sys_put -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . diff --git a/lib/libc/sys/caps_sys_reply.2 b/lib/libc/sys/caps_sys_reply.2 deleted file mode 100644 index 3dfb975762..0000000000 --- a/lib/libc/sys/caps_sys_reply.2 +++ /dev/null @@ -1,90 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_reply.2,v 1.1 2006/02/28 22:40:49 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_REPLY 2 -.Os -.Sh NAME -.Nm caps_sys_reply -.Nd reply to a CAPS IPC message -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft int -.Fn caps_sys_reply "int portid" "const void *msg" "int msgsize" "off_t msgid" -.Sh DESCRIPTION -Reply to the received CAPS message identified by -.Fa msgid -on the port specified by -.Fa portid . -The reply may supply opaque data in -.Fa msg . -The memory associated with the message must be left intact until -an acknowledgement is returned at a later time. -The kernel does not make a copy of the message and its size may not -exceed 128KB. -.Pp -This function is only used on the server side. -The server may reply to a message without retrieving its data. -.Sh RETURN VALUES -.Rv -std caps_sys_reply -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er ENOTCONN" -.It Bq Er EINVAL -An invalid argument was specified. -.It Bq Er ENOTCONN -The process originally creating the port forked and the child -process attempts to access the port. -The child process is expected to create its own port. -This error is also returned if the remote end closed its connection -and is no longer available. -Note that a child process may not reply to a message received by its -parent. -.El -.Sh SEE ALSO -.Xr caps_sys_client 2 , -.Xr caps_sys_get 2 , -.Xr caps_sys_put 2 , -.Xr caps_sys_service 2 -.Sh HISTORY -The -.Fn caps_sys_reply -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . diff --git a/lib/libc/sys/caps_sys_service.2 b/lib/libc/sys/caps_sys_service.2 deleted file mode 100644 index 123ba7a147..0000000000 --- a/lib/libc/sys/caps_sys_service.2 +++ /dev/null @@ -1,97 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_service.2,v 1.2 2006/03/02 19:27:35 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_SERVICE 2 -.Os -.Sh NAME -.Nm caps_sys_service -.Nd create a CAPS IPC service -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft int -.Fo caps_sys_service -.Fa "const char *name" -.Fa "uid_t uid" -.Fa "gid_t gid" -.Fa "int upcid" -.Fa "int flags" -.Fc -.Sh DESCRIPTION -Create an IPC service using the specified -.Fa name , -.Fa uid , -.Fa gid , -and -.Fa flags . -Either -.Fa uid -or -.Fa gid -can be -1 (thereby indicating a wildcard), -but not both. -The -.Fa upcid -argument can either be an upcall or a kqueue identifier. -.Sh RETURN VALUES -On success, this function returns a port identifier. -On failure, -1 is returned and -.Va errno -is set to indicate the error. -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er EOPNOTSUPP" -.It Bq Er EOPNOTSUPP -The CAPS system has not been enabled with -.Va kern.caps_enabled . -.It Bq Er EINVAL -An invalid argument was specified. -.El -.Sh SEE ALSO -.Xr caps_sys_client 2 -.Sh HISTORY -The -.Fn caps_sys_service -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . -.Sh BUGS -Support for the -.Fa upcid -argument is currently not implemented. diff --git a/lib/libc/sys/caps_sys_setgen.2 b/lib/libc/sys/caps_sys_setgen.2 deleted file mode 100644 index d23514d364..0000000000 --- a/lib/libc/sys/caps_sys_setgen.2 +++ /dev/null @@ -1,79 +0,0 @@ -.\" -.\" Copyright (c) 2006 The DragonFly Project. 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. Neither the name of The DragonFly Project nor the names of its -.\" contributors may be used to endorse or promote products derived -.\" from this software without specific, prior written permission. -.\" -.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -.\" ``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 -.\" COPYRIGHT HOLDERS OR CONTRIBUTORS 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. -.\" -.\" $DragonFly: src/lib/libc/sys/caps_sys_setgen.2,v 1.1 2006/02/28 22:40:49 swildner Exp $ -.\" -.Dd February 28, 2006 -.Dt CAPS_SYS_SETGEN 2 -.Os -.Sh NAME -.Nm caps_sys_setgen -.Nd set the generation number for a CAPS IPC link -.Sh LIBRARY -.Lb libc -.Sh SYNOPSIS -.In sys/caps.h -.Ft int -.Fn caps_sys_setgen "int portid" "caps_gen_t gen" -.Sh DESCRIPTION -Set the 64 bit generation number -.Fa gen -for a CAPS link specified by the -.Fa portid -identifier. -A service typically changes the generation number to indicate that it -has been restarted. -.Sh RETURN VALUES -.Rv -std caps_sys_setgen -.Sh ERRORS -This function will fail if: -.Bl -tag -width ".Bq Er ENOTCONN" -.It Bq Er EINVAL -The -.Fa portid -could not be found. -.It Bq Er ENOTCONN -The process originally creating the port forked and the child -process attempts to access the port. -The child process is expected to create its own port. -.El -.Sh SEE ALSO -.Xr caps_sys_getgen 2 -.Sh HISTORY -The -.Fn caps_sys_setgen -function call first appeared in -.Dx 1.0 . -.Sh AUTHORS -.An -nosplit -CAPS IPC was written by -.An Matthew Dillon . -This man page was written by -.An Sascha Wildner . diff --git a/lib/libcaps/Makefile b/lib/libcaps/Makefile deleted file mode 100644 index aab0f00053..0000000000 --- a/lib/libcaps/Makefile +++ /dev/null @@ -1,45 +0,0 @@ -# $DragonFly: src/lib/libcaps/Makefile,v 1.8 2008/05/22 20:01:55 nth Exp $ -# -LIB=caps -SHLIB_MAJOR= 2 -AINC= -I${.CURDIR}/${MACHINE_ARCH} -I${.OBJDIR} -CFLAGS+= -I${.CURDIR}/.. -I${.CURDIR}/${MACHINE_ARCH} -CFLAGS+= -DSMP -D_UTHREAD -CFLAGS+= -DCAPS_DEBUG -INSTALL_PIC_ARCHIVE= yes -.PATH: ${.CURDIR}/${MACHINE_ARCH} ${.CURDIR}/../../sys/kern - -#MISRCS= uthread.c init.c sysport.c slaballoc.c globaldata.c - -MISRCS= caps_msgbuf.c caps_struct.c caps_pwent.c - -SRCS+= ${.OBJDIR}/asdefs.h -CLEANFILES+=asdefs asdefs.o ${.CURDIR}/asdefs.h - -${.OBJDIR}/asdefs.h: asdefs - ${.OBJDIR}/${.ALLSRC} > ${.TARGET} - -.include "${MACHINE_ARCH}/Makefile.inc" - -################################################################## -# For now this is a clone of what src/lib/libcr/Makefile.inc does. -# When this is liblwkt becomes part of libcr the rest of this file -# can be removed. -################################################################## - -# If there are no machine dependent sources, append all the -# machine-independent sources: -.if empty{MDSRCS} -SRCS+= ${MISRCS} -.else -# Append machine-dependent sources, then append machine-independent sources -# for which there is no machine-dependent variant. -SRCS+= ${MDSRCS} -.for _src in ${MISRCS} -.if ${MDSRCS:R:M${_src:R}} == "" -SRCS+= ${_src} -.endif -.endfor -.endif - -.include diff --git a/lib/libcaps/asdefs.c b/lib/libcaps/asdefs.c deleted file mode 100644 index 2d4b596a8a..0000000000 --- a/lib/libcaps/asdefs.c +++ /dev/null @@ -1,39 +0,0 @@ -/* - * ASDEFS.C - * - * Generate assembly defs. - * - * $DragonFly: src/lib/libcaps/asdefs.c,v 1.2 2003/12/07 04:21:52 dillon Exp $ - */ - -#include /* for __dead2 needed by thread.h */ -#include "libcaps/thread.h" -#include -#include "libcaps/globaldata.h" -#include /* for offsetof(type, field) */ -#include - -#define OFFSET(name, offset) printf("#define %s %d\n", #name, offset); - -int -main(int ac, char **av) -{ - OFFSET(TD_SP, offsetof(struct thread, td_sp)); - OFFSET(TD_FLAGS, offsetof(struct thread, td_flags)); - OFFSET(TD_MPCOUNT, offsetof(struct thread, td_mpcount)); - OFFSET(TD_PRI, offsetof(struct thread, td_pri)); - - OFFSET(UPC_MAGIC, offsetof(struct upcall, upc_magic)); - OFFSET(UPC_CRITOFF, offsetof(struct upcall, upc_critoff)); - OFFSET(UPC_PENDING, offsetof(struct upcall, upc_pending)); - OFFSET(UPC_UTHREAD, offsetof(struct upcall, upc_uthread)); - - OFFSET(TDF_RUNNING, TDF_RUNNING); - OFFSET(TDPRI_CRIT, TDPRI_CRIT); - - OFFSET(gd_curthread, offsetof(struct globaldata, gd_upcall.upc_uthread)); - OFFSET(gd_cpuid, offsetof(struct globaldata, gd_cpuid)); - - return(0); -} - diff --git a/lib/libcaps/caps_msgbuf.c b/lib/libcaps/caps_msgbuf.c deleted file mode 100644 index 20b3c40dc1..0000000000 --- a/lib/libcaps/caps_msgbuf.c +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/caps_msgbuf.c,v 1.1 2004/03/07 23:36:44 dillon Exp $ - */ - -#include "defs.h" - -void -caps_init_msgbuf(caps_msgbuf_t msg, void *data, int size) -{ - msg->base = data; - msg->index = 0; - msg->bufsize = size; - msg->error = 0; -} - -void -caps_msgbuf_error(caps_msgbuf_t msg, int eno, int undo) -{ - if (eno) - msg->error = eno; - if (msg->index < undo) - msg->index = 0; - else - msg->index -= undo; -} - -/* - * Extract the next class specification. A class specification is an upper - * case letter followed by quoted data or non-quoted data. Non-quoted data - * may only contain the characters 0-9 and LOWER CASE a-z, '.', or '_'. - * The returned (ptr,len) tuple includes the quotes in quoted data. - */ -u_int8_t -caps_msgbuf_getclass(caps_msgbuf_t msg, u_int8_t **pptr, int *plen) -{ - u_int8_t c; - u_int8_t cc; - int i; - - while (msg->index < msg->bufsize) { - c = msg->base[msg->index++]; - if (c >= 'A' && c <= 'Z') { - i = msg->index; - *pptr = msg->base + i; - if (i < msg->bufsize && msg->base[i] == '\"') { - for (++i; i < msg->bufsize; ++i) { - cc = msg->base[i]; - if ((cc >= 'a' && cc <= 'z') || - (cc >= 'A' && cc <= 'Z') || - (cc >= '0' && cc <= '9') || - cc == '_' || cc == '.' || cc == '/' || cc == '+' || - cc == '-' || cc == '%' - ) { - continue; - } - if (cc == '"') /* quote end string, else error */ - ++i; - else - msg->error = EINVAL; - break; - } - } else { - for (; i < msg->bufsize; ++i) { - cc = msg->base[i]; - if (cc >= 'a' && cc <= 'z') - continue; - if (cc >= '0' && cc <= '9') - continue; - if (cc == '.' || cc == '_') - continue; - break; - } - } - *plen = i - msg->index; - msg->index = i; - return(c); - } - if (c == ',' || c == '{' || c == '}') - return(c); - if (c != '\t' && c != ' ' && c != '\r' && c != '\n') { - msg->error = EINVAL; - break; - } - /* loop on whitespce */ - } - return(0); -} - -/* - * Support routines for encoding/decoding - */ -void -caps_msgbuf_printf(caps_msgbuf_t msg, const char *ctl, ...) -{ - va_list va; - int i; - - va_start(va, ctl); - i = msg->index; - if (i <= msg->bufsize) - i += vsnprintf(msg->base + i, msg->bufsize - i, ctl, va); - else - i += vsnprintf(NULL, 0, ctl, va); - msg->index = i; - va_end(va); -} - diff --git a/lib/libcaps/caps_pwent.c b/lib/libcaps/caps_pwent.c deleted file mode 100644 index 590e2b7d95..0000000000 --- a/lib/libcaps/caps_pwent.c +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/caps_pwent.c,v 1.1 2004/03/07 23:36:44 dillon Exp $ - */ - -#include -#include -#include -#include -#include "caps_struct.h" - -/* - * Password Entry encoding and decoding - */ -#define CAPS_PW_NAME 1 -#define CAPS_PW_PASSWD 2 -#define CAPS_PW_UID 3 -#define CAPS_PW_GID 4 -#define CAPS_PW_CHANGE 5 -#define CAPS_PW_CLASS 6 -#define CAPS_PW_GECOS 7 -#define CAPS_PW_DIR 8 -#define CAPS_PW_SHELL 9 -#define CAPS_PW_EXPIRE 10 - -#define STYPE struct passwd - -const struct caps_label caps_passwd_label[] = { - { offsetof(STYPE, pw_name), CAPS_IN_STRPTR_T, CAPS_PW_NAME }, - { offsetof(STYPE, pw_passwd), CAPS_IN_STRPTR_T, CAPS_PW_PASSWD }, - { offsetof(STYPE, pw_uid), CAPS_IN_UID_T, CAPS_PW_UID }, - { offsetof(STYPE, pw_gid), CAPS_IN_GID_T, CAPS_PW_GID }, - { offsetof(STYPE, pw_change), CAPS_IN_TIME_T, CAPS_PW_CHANGE }, - { offsetof(STYPE, pw_class), CAPS_IN_STRPTR_T, CAPS_PW_CLASS }, - { offsetof(STYPE, pw_gecos), CAPS_IN_STRPTR_T, CAPS_PW_GECOS }, - { offsetof(STYPE, pw_dir), CAPS_IN_STRPTR_T, CAPS_PW_DIR }, - { offsetof(STYPE, pw_shell), CAPS_IN_STRPTR_T, CAPS_PW_SHELL }, - { offsetof(STYPE, pw_expire), CAPS_IN_TIME_T, CAPS_PW_EXPIRE }, - { -1 } -}; - -#undef STYPE - -const struct caps_struct caps_passwd_struct = { - "passwd", caps_passwd_label -}; - diff --git a/lib/libcaps/caps_struct.c b/lib/libcaps/caps_struct.c deleted file mode 100644 index 56f223fa56..0000000000 --- a/lib/libcaps/caps_struct.c +++ /dev/null @@ -1,661 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/caps_struct.c,v 1.1 2004/03/07 23:36:44 dillon Exp $ - */ - -#include "defs.h" - -static -int32_t -parsehex32(const u_int8_t *ptr, int len) -{ - int neg = 0; - int32_t v = 0; - u_int8_t c; - - if (len && ptr[0] == '-') { - neg = 1; - --len; - ++ptr; - } - while (len) { - v = v << 4; - c = *ptr; - if (c >= '0' && c <= '9') - v |= c - '0'; - if (c >= 'a' && c <= 'f') - v |= c - ('a' - 10); - --len; - ++ptr; - } - if (neg) - v = -v; - return(v); -} - -static -int64_t -parsehex64(const u_int8_t *ptr, int len) -{ - int neg = 0; - int64_t v; - - if (len && ptr[0] == '-') { - neg = 1; - --len; - ++ptr; - } - - if (len > 4) { - v = parsehex32(ptr + len - 4, 4) | - ((int64_t)parsehex32(ptr, len - 4) << 32); - } else { - v = (int64_t)parsehex32(ptr, len); - } - if (neg) - v = -v; - return(v); -} - -static caps_label_t -caps_find_label(caps_struct_t cs, caps_fid_t fid, const struct caps_label **pcache) -{ - caps_label_t label; - - if ((label = *pcache) != NULL) { - if (label->fid == fid) - return(label); - ++label; - if (label->fid == fid && label->offset >= 0) { - *pcache = label; - return(label); - } - --label; - if (label != cs->labels) { - --label; - if (label->fid == fid && label->offset >= 0) { - *pcache = label; - return(label); - } - } - } - for (label = cs->labels; label->offset >= 0; ++label) { - if (label->fid == fid) { - *pcache = label; - return(label); - } - } - return(NULL); -} - -/* - * Generic structural encoder. The number of bytes that would be stored in - * buf if it were infinitely-sized is returned. - */ -int -caps_encode(void *buf, int bytes, void *data, caps_struct_t cs) -{ - struct caps_msgbuf msgbuf; - - caps_init_msgbuf(&msgbuf, buf, bytes); - caps_msg_encode_structure(&msgbuf, data, cs); - return(msgbuf.index); -} - -/* - * Encode a structure into a message using the supplied label data. The - * message's index is updated to reflect the actual number of bytes that - * would be consumed, even if the message buffer would overflow (but we don't - * overflow the buffer, obviously). - */ -void -caps_msg_encode_structure(caps_msgbuf_t msg, void *data, caps_struct_t cs) -{ - caps_label_t label; - void *ptr; - - caps_msgbuf_printf(msg, "S%s{", cs->name); - for (label = cs->labels; label->offset >= 0; ++label) { - if (label != cs->labels) - caps_msgbuf_putc(msg, ','); - caps_msgbuf_printf(msg, "F%x", label->fid); - ptr = (char *)data + label->offset; - if (label->nary > 1) - caps_msg_encode_array(msg, ptr, label); - else if (label->csinfo) - caps_msg_encode_structure(msg, ptr, label->csinfo); - else - caps_msg_encode_data(msg, ptr, label->type, label->size); - } - caps_msgbuf_putc(msg, '}'); -} - -void -caps_msg_encode_array(caps_msgbuf_t msg, void *data, caps_label_t label) -{ - int i; - void *ptr; - - caps_msgbuf_printf(msg, "A%x{", label->nary); - for (i = 0; i < label->nary; ++i) { - ptr = (char *)data + i * - ((label->type & CAPS_OPF_PTR) ? sizeof(void *) : label->size); - if (label->csinfo) - caps_msg_encode_structure(msg, ptr, label->csinfo); - else - caps_msg_encode_data(msg, ptr, label->type, label->size); - } - caps_msgbuf_putc(msg, '}'); -} - -void -caps_msg_encode_data(caps_msgbuf_t msg, void *data, int type, int size) -{ - int i; - u_int8_t c; - - switch(type) { - case CAPS_OP_INT_T: - switch(size) { - case 1: - if (*(int8_t *)data < 0) - caps_msgbuf_printf(msg, "D-%x", -*(int8_t *)data); - else - caps_msgbuf_printf(msg, "D%x", *(u_int8_t *)data); - break; - case 2: - if (*(int16_t *)data < 0) - caps_msgbuf_printf(msg, "D%x", -*(int16_t *)data); - else - caps_msgbuf_printf(msg, "D%x", *(u_int16_t *)data); - break; - case 4: - if (*(int32_t *)data < 0) - caps_msgbuf_printf(msg, "D%x", -*(int32_t *)data); - else - caps_msgbuf_printf(msg, "D%x", *(u_int32_t *)data); - break; - case 8: - if (*(int64_t *)data < 0) - caps_msgbuf_printf(msg, "D%llx", -*(int64_t *)data); - else - caps_msgbuf_printf(msg, "D%llx", *(u_int64_t *)data); - break; - default: - caps_msgbuf_putc(msg, 'D'); - caps_msgbuf_putc(msg, '?'); - break; - } - break; - case CAPS_OP_UINT_T: - switch(size) { - case 1: - caps_msgbuf_printf(msg, "D%x", *(u_int8_t *)data); - break; - case 2: - caps_msgbuf_printf(msg, "D%x", *(u_int16_t *)data); - break; - case 4: - caps_msgbuf_printf(msg, "D%x", *(u_int32_t *)data); - break; - case 8: - caps_msgbuf_printf(msg, "D%llx", *(u_int64_t *)data); - break; - default: - caps_msgbuf_putc(msg, 'D'); - caps_msgbuf_putc(msg, '?'); - break; - } - break; - case CAPS_OP_STRPTR_T: - data = *(void **)data; - if (data == NULL) { - caps_msgbuf_printf(msg, "D"); /* represents NULL */ - break; - } - if (size == 0) - size = 0x7FFFFFFF; - /* fall through, size is the 'limit' */ - case CAPS_OP_STRBUF_T: - caps_msgbuf_putc(msg, 'D'); - caps_msgbuf_putc(msg, '"'); /* string designator */ - for (i = 0; i < size && (c = ((u_int8_t *)data)[i]) != 0; ++i) { - if ((c >= 'a' && c <= 'z') || - (c >= 'A' && c <= 'Z') || - (c >= '0' && c <= '9') || - c == '_' || c == '.' || c == '/' || c == '+' || c == '-' - ) { - caps_msgbuf_putc(msg, c); - } else { - caps_msgbuf_printf(msg, "%%%02x", (int)c); - } - } - caps_msgbuf_putc(msg, '"'); - break; - case CAPS_OP_OPAQUE_T: - caps_msgbuf_putc(msg, 'D'); - caps_msgbuf_putc(msg, '"'); - for (i = 0; i < size; ++i) { - c = ((u_int8_t *)data)[i]; - if ((c >= 'a' && c <= 'z') || - (c >= 'A' && c <= 'Z') || - (c >= '0' && c <= '9') || - c == '_' || c == '.' || c == '/' || c == '+' || c == '-' - ) { - caps_msgbuf_putc(msg, c); - } else { - caps_msgbuf_printf(msg, "%%%02x", (int)c); - } - } - caps_msgbuf_putc(msg, '"'); - break; - default: - caps_msgbuf_putc(msg, 'D'); - caps_msgbuf_putc(msg, '?'); - break; - } -} - -/* - * Generic structural decoder. The number of bytes that were decoded from - * the buffer are returned, the structure is populated, and the error code - * is set unconditionally as a side effect. - */ -int -caps_decode(const void *buf, int bytes, void *data, caps_struct_t cs, int *error) -{ - struct caps_msgbuf msgbuf; - u_int8_t c; - u_int8_t *ptr; - int len; - - caps_init_msgbuf(&msgbuf, (void *)buf, bytes); - while ((c = caps_msgbuf_getclass(&msgbuf, &ptr, &len)) != 0) { - if (c == 'S' && len == strlen(cs->name) && - strncmp(ptr, cs->name, len) == 0 - ) { - caps_msg_decode_structure(&msgbuf, data, cs); - *error = msgbuf.error; - return(msgbuf.index); - } - /* - * Skip substructures. - */ - if (c == '{') { - caps_msgbuf_error(&msgbuf, 0, 1); - caps_msg_decode_structure(&msgbuf, NULL, NULL); - } - } - if (msgbuf.error == 0) - *error = ENOENT; - *error = msgbuf.error; - return(msgbuf.index); -} - -/* - * Decode a message buffer into a structure, return the number of bytes - * chomped and set *error to 0 on success, or an error code on failure. - * The 'Sname' has already been snarfed. We are responsible for snarfing - * the '{'. - * - * Note that the structural specification, cs, may be NULL, indicating and - * unknown structure which causes us to skip the structure. - */ -void -caps_msg_decode_structure(caps_msgbuf_t msg, void *data, caps_struct_t cs) -{ - caps_label_t label; - caps_label_t cache; - u_int8_t *ptr; - int len; - char c; - - cache = NULL; - - /* - * A structure must contain an open brace - */ - if (caps_msgbuf_getc(msg) != '{') { - caps_msgbuf_error(msg, EINVAL, 1); - return; - } - - /* - * Parse data elements within the structure - */ - do { - /* - * Parse class info for the next element. Note that the label - * specification may be NULL. - */ - label = NULL; - while ((c = caps_msgbuf_getclass(msg, &ptr, &len)) != 0) { - switch(c) { - case 'F': - label = caps_find_label(cs, parsehex32(ptr, len), &cache); - continue; - case 'A': - caps_msg_decode_array(msg, - (char *)data + label->offset, - parsehex32(ptr, len), - label); - continue; - case 'S': - if (label && label->csinfo && - strlen(label->csinfo->name) == len && - strncmp(label->csinfo->name, ptr, len) == 0 - ) { - caps_msg_decode_structure(msg, - (char *)data + label->offset, - label->csinfo); - } else { - caps_msg_decode_structure(msg, NULL, NULL); - } - continue; - case 'D': - if (label) { - caps_msg_decode_data(ptr, len, - (char *)data + label->offset, - label->type, - label->size); - } - continue; - case '{': - /* - * This case occurs when we previously hit an unknown class - * which has a sub-structure associated with it. Parseskip - * the sub-structure. - */ - caps_msgbuf_error(msg, 0, 1); - caps_msg_decode_structure(msg, NULL, NULL); - continue; - case '}': - case ',': - break; - default: - /* unknown classes are ignored */ - continue; - } - break; - } - } while (c == ','); - - /* - * A structure must end with a close brace - */ - if (c != '}') - caps_msgbuf_error(msg, EINVAL, 1); -} - -void -caps_msg_decode_array(caps_msgbuf_t msg, void *data, int nary, caps_label_t label) -{ - int i; - char c; - int len; - u_int8_t *ptr; - - c = 0; - - /* - * An array must contain an open brace - */ - if (caps_msgbuf_getc(msg) != '{') { - caps_msgbuf_error(msg, EINVAL, 1); - return; - } - for (i = 0; i < nary && (label == NULL || i < label->nary); ++i) { - while ((c = caps_msgbuf_getclass(msg, &ptr, &len)) != 0) { - switch(c) { - case 'F': - /* a field id for an array element is not expected */ - continue; - case 'A': - /* nested arrays are not yet supported */ - continue; - case 'S': - if (label && label->csinfo && - strlen(label->csinfo->name) == len && - strncmp(label->csinfo->name, ptr, len) == 0 - ) { - caps_msg_decode_structure(msg, data, label->csinfo); - } else { - caps_msg_decode_structure(msg, NULL, NULL); - } - continue; - case 'D': - if (label) { - caps_msg_decode_data(ptr, len, data, - label->type, label->size); - } - continue; - case '{': - /* - * This case occurs when we previously hit an unknown class - * which has a sub-structure associated with it. Parseskip - * the sub-structure. - */ - caps_msgbuf_error(msg, 0, 1); - caps_msg_decode_structure(msg, NULL, NULL); - continue; - case '}': - case ',': - break; - default: - /* unknown classes are ignored */ - continue; - } - break; - } - - if (label) { - data = (char *)data + - ((label->type & CAPS_OPF_PTR) ? sizeof(void *) : label->size); - } - - /* - * I really expected a comma here - */ - if (c != ',') { - caps_msgbuf_error(msg, EINVAL, 0); - break; - } - } - - /* - * Our array was too small, exhaust any remaining elements - */ - for (; i < nary; ++i) { - while ((c = caps_msgbuf_getclass(msg, &ptr, &len)) != 0) { - switch(c) { - case 'S': - caps_msg_decode_structure(msg, NULL, NULL); - continue; - case 'D': - /* data is embedded, no additional decoding needed to skip */ - continue; - case '{': - caps_msgbuf_error(msg, 0, 1); - caps_msg_decode_structure(msg, NULL, NULL); - continue; - case '}': - case ',': - break; - default: - /* unknown classes are ignored */ - continue; - } - break; - } - if (c != ',') { - caps_msgbuf_error(msg, EINVAL, 0); - break; - } - } - - /* - * Finish up. Note degenerate case (c not loaded) if nary is 0 - */ - if (nary == 0) - c = caps_msgbuf_getc(msg); - if (c != '}') - caps_msgbuf_error(msg, EINVAL, 1); -} - -void -caps_msg_decode_data(char *ptr, int len, void *data, int type, int size) -{ - int i; - int j; - - switch(type) { - case CAPS_OP_INT_T: - case CAPS_OP_UINT_T: - switch(size) { - case 1: - *(int8_t *)data = parsehex32(ptr, len); - break; - case 2: - *(int16_t *)data = parsehex32(ptr, len); - break; - case 4: - *(int32_t *)data = parsehex32(ptr, len); - break; - case 8: - *(int64_t *)data = parsehex64(ptr, len); - break; - default: - /* unknown data type */ - break; - } - break; - case CAPS_OP_STRPTR_T: - /* - * Assume NULL if not a quoted string (the actual encoding for NULL - * is a completely empty 'D' specification). - */ - if (len < 2 || ptr[0] != '"' || ptr[len-1] != '"') { - *(void **)data = NULL; - break; - } - for (i = j = 0; i < len; ++j) { - if (ptr[i] == '%') { - i += 3; - } else { - ++i; - } - } - if (size == 0 || size > j) - size = j + 1; - *(void **)data = malloc(size); - data = *(void **)data; - assert(data != NULL); - /* fall through */ - case CAPS_OP_STRBUF_T: - case CAPS_OP_OPAQUE_T: - /* - * Skip quotes - */ - if (len < 2 || ptr[0] != '"' || ptr[len-1] != '"') { - break; - } - ++ptr; - len -= 2; - - /* - * Parse the contents of the string - */ - for (i = j = 0; i < len && j < size; ++j) { - if (ptr[i] == '%') { - if (i + 2 < len) { - ((char *)data)[j] = parsehex32(ptr + 1, 2); - i += 3; - } else { - /* XXX error */ - i = len; - } - } else { - ((char *)data)[j] = ptr[i]; - ++i; - } - } - if (type == CAPS_OP_OPAQUE_T) { - if (j < size) - bzero((char *)data + j, size - j); - } else { - if (j < size) - ((char *)data)[j] = 0; - else if (size) - ((char *)data)[size - 1] = 0; /* XXX error */ - } - break; - default: - break; - } -} - -/* - * Free string pointers dynamically allocated by caps_msg_decode_structure(). - */ -void -caps_struct_free_pointers(void *data, caps_struct_t cs) -{ - caps_label_t label; - void *ptr; - - for (label = cs->labels; label->offset >= 0; ++label) { - ptr = (char *)data + label->offset; - if (label->nary > 1) { - caps_array_free_pointers(ptr, label); - } else if (label->csinfo) { - caps_struct_free_pointers(ptr, label->csinfo); - } else if (label->type & CAPS_OPF_PTR) { - if (*(void **)ptr) { - free(*(void **)ptr); - *(void **)ptr = NULL; - } - } - } -} - -void -caps_array_free_pointers(void *data, caps_label_t label) -{ - int i; - - for (i = 0; i < label->nary; ++i) { - if (label->csinfo) { - caps_struct_free_pointers(data, label->csinfo); - } else if (label->type & CAPS_OPF_PTR) { - if (*(void **)data) { - free(*(void **)data); - *(void **)data = NULL; - } - } - data = (char *)data + - ((label->type & CAPS_OPF_PTR) ? sizeof(void *) : label->size); - } -} diff --git a/lib/libcaps/caps_struct.h b/lib/libcaps/caps_struct.h deleted file mode 100644 index 5fd23e309d..0000000000 --- a/lib/libcaps/caps_struct.h +++ /dev/null @@ -1,139 +0,0 @@ -/* - * CAPS_STRUCT.H - * - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/caps_struct.h,v 1.1 2004/03/07 23:36:44 dillon Exp $ - */ -#include - -struct caps_label; -struct caps_struct; -struct caps_msgbuf; - -typedef const struct caps_label *caps_label_t; -typedef const struct caps_struct *caps_struct_t; -typedef struct caps_msgbuf *caps_msgbuf_t; - -typedef u_int32_t caps_fid_t; - -struct caps_label { - int offset; - int type; - int size; /* element size for array[1] */ - caps_fid_t fid; - int nary; /* can be 0 or 1 to indicate 1 element */ - caps_struct_t csinfo; /* if embedded structure */ -}; - -struct caps_struct { - char *name; - const caps_label_t labels; -}; - -struct caps_msgbuf { - u_int8_t *base; - int index; - int bufsize; - int error; -}; - -#define CAPS_OPF_PTR 0x0100 - -#define CAPS_OP_INT_T 1 -#define CAPS_OP_UINT_T 2 -#define CAPS_OP_STRBUF_T 3 -#define CAPS_OP_STRPTR_T (3|CAPS_OPF_PTR) -#define CAPS_OP_OPAQUE_T 4 - -/* - * Note: signed/unsignedness may not reflect the actual type. Instead it - * reflects our casting policy if the client and server are using different - * integer sizes for any given field. - */ -#define CAPS_IN_INT_T CAPS_OP_INT_T, sizeof(int) -#define CAPS_IN_INT8_T CAPS_OP_INT_T, sizeof(int8_t) -#define CAPS_IN_INT16_T CAPS_OP_INT_T, sizeof(int16_t) -#define CAPS_IN_INT32_T CAPS_OP_INT_T, sizeof(int32_t) -#define CAPS_IN_LONG_T CAPS_OP_INT_T, sizeof(long) -#define CAPS_IN_INT64_T CAPS_OP_INT_T, sizeof(int64_t) - -#define CAPS_IN_UINT_T CAPS_OP_INT_T, sizeof(u_int) -#define CAPS_IN_UINT8_T CAPS_OP_INT_T, sizeof(u_int8_t) -#define CAPS_IN_UINT16_T CAPS_OP_INT_T, sizeof(u_int16_t) -#define CAPS_IN_UINT32_T CAPS_OP_INT_T, sizeof(u_int32_t) -#define CAPS_IN_ULONG_T CAPS_OP_INT_T, sizeof(u_long) -#define CAPS_IN_UINT64_T CAPS_OP_INT_T, sizeof(u_int64_t) - -#define CAPS_IN_STRPTR_T CAPS_OP_STRPTR_T, 0 -#define CAPS_IN_STRBUF_T(n) CAPS_OP_STRBUF_T, (n) -#define CAPS_IN_UID_T CAPS_OP_INT_T, sizeof(uid_t) -#define CAPS_IN_GID_T CAPS_OP_INT_T, sizeof(gid_t) -#define CAPS_IN_TIME_T CAPS_OP_UINT_T, sizeof(time_t) -#define CAPS_IN_OFF_T CAPS_OP_INT_T, sizeof(off_t) -#define CAPS_IN_SIZE_T CAPS_OP_UINT_T, sizeof(size_t) -#define CAPS_IN_SSIZE_T CAPS_OP_INT_T, sizeof(ssize_t) - -static __inline -u_int8_t -caps_msgbuf_getc(caps_msgbuf_t msg) -{ - u_int8_t c = 0; - - if (msg->index < msg->bufsize) - c = msg->base[msg->index]; - ++msg->index; - return(c); /* always bumped */ -} - -static __inline -void -caps_msgbuf_putc(caps_msgbuf_t msg, u_int8_t c) -{ - if (msg->index < msg->bufsize) { - msg->base[msg->index] = c; - } - ++msg->index; /* always bumped */ -} - -extern const struct caps_struct caps_passwd_struct; - -int caps_encode(void *buf, int bytes, void *data, caps_struct_t cs); -int caps_decode(const void *buf, int bytes, void *data, caps_struct_t cs, int *error); -void caps_struct_free_pointers(void *data, caps_struct_t cs); -void caps_array_free_pointers(void *data, caps_label_t label); - -void caps_init_msgbuf(caps_msgbuf_t msg, void *data, int size); -void caps_msgbuf_error(caps_msgbuf_t msg, int eno, int undo); -u_int8_t caps_msgbuf_getclass(caps_msgbuf_t msg, u_int8_t **pptr, int *plen); -void caps_msgbuf_printf(caps_msgbuf_t msg, const char *ctl, ...); - -void caps_msg_encode_structure(caps_msgbuf_t msg, void *data, caps_struct_t cs); -void caps_msg_encode_array(caps_msgbuf_t msg, void *data, caps_label_t label); -void caps_msg_encode_data(caps_msgbuf_t msg, void *data, int type, int size); -void caps_msg_decode_structure(caps_msgbuf_t msg, void *data, caps_struct_t cs); -void caps_msg_decode_array(caps_msgbuf_t msg, void *data, int nary, caps_label_t label); -void caps_msg_decode_data(char *ptr, int len, void *data, int type, int size); - diff --git a/lib/libcaps/defs.h b/lib/libcaps/defs.h deleted file mode 100644 index 0c4a7c1f00..0000000000 --- a/lib/libcaps/defs.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - * DEFS.H - * - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/defs.h,v 1.5 2004/07/04 22:44:26 eirikn Exp $ - */ - -#include -#include -#include -#include -#include -#include -#include "thread.h" -#include -#include -#include -#include "globaldata.h" -#include "sysport.h" -#include -#include -#include -#include - -#include -#include -#if 0 -#include -#include -#endif - -#include -#include /* temporary debugging */ -#include -#include -#include -#include -#include /* temporary debugging */ -#include -#include - -#include "caps_struct.h" - -#ifdef CAPS_DEBUG -#define DBPRINTF(x) printf x -#else -#define DBPRINTF(x) -#endif - -extern struct thread main_td; diff --git a/lib/libcaps/globaldata.c b/lib/libcaps/globaldata.c deleted file mode 100644 index 659ba7d299..0000000000 --- a/lib/libcaps/globaldata.c +++ /dev/null @@ -1,183 +0,0 @@ -/* - * GLOBALDATA.C - * - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/globaldata.c,v 1.7 2004/07/29 08:55:02 dillon Exp $ - */ - -#include "defs.h" - -struct globaldata gdary[MAXVCPU]; -u_int mp_lock; -int ncpus = 1; -cpumask_t stopped_cpus; -cpumask_t smp_active_mask; -char *panicstr; - -/* - * Master globaldata init - */ -void -globaldata_init(thread_t td) -{ - mi_gdinit1(&gdary[0], 0); - mi_gdinit2(&gdary[0]); - - /* - * If a 'main' thread is passed make it the current thread and mark it - * as currently running, but not on the run queue. - */ - if (td) { - gdary[0].gd_curthread = td; - lwkt_init_thread(td, NULL, 0, TDF_RUNNING|TDF_SYSTHREAD, mycpu); - } -} - -/* - * per-cpu globaldata init. Calls lwkt_gdinit() and md_gdinit*(). Returns - * with the target cpu left in a critical section. - */ -void -mi_gdinit1(globaldata_t gd, int cpuid) -{ - bzero(gd, sizeof(*gd)); - TAILQ_INIT(&gd->gd_tdfreeq); - gd->gd_cpuid = cpuid; - gd->gd_cpumask = (cpumask_t)1 << cpuid; - gd->gd_self = gd; - gd->gd_upcall.upc_magic = UPCALL_MAGIC; - gd->gd_upcall.upc_critoff = offsetof(struct thread, td_pri); - gd->gd_ipiq = malloc(sizeof(lwkt_ipiq) * MAXVCPU); - bzero(gd->gd_ipiq, sizeof(lwkt_ipiq) * MAXVCPU); - md_gdinit1(gd); -} - -void -mi_gdinit2(globaldata_t gd) -{ - gd->gd_upcid = upc_register(&gd->gd_upcall, upc_callused_wrapper, - (void *)lwkt_process_ipiq, gd); - if (gd->gd_upcid < 0) - panic("upc_register: failed on cpu %d\n", gd->gd_cpuid); - md_gdinit2(gd); - lwkt_gdinit(gd); -} - -globaldata_t -globaldata_find(int cpu) -{ - KKASSERT(cpu >= 0 && cpu < ncpus); - return(&gdary[cpu]); -} - -void * -libcaps_alloc_stack(int stksize) -{ - return(malloc(stksize)); -} - -void -libcaps_free_stack(void *stk, int stksize) -{ - free(stk); -} - -/* - * Process any pending upcalls now. Remember there is a dispatch interlock - * if upc_pending is non-zero, so we have to set it to zero. If we are in - * a critical section this function is a NOP. - */ -void -splz(void) -{ - globaldata_t gd = mycpu; - - if (gd->gd_upcall.upc_pending) { - gd->gd_upcall.upc_pending = 0; - upc_control(UPC_CONTROL_DISPATCH, -1, (void *)1); - } -} - -int -need_lwkt_resched(void) -{ - return(0); -} - -void -cpu_send_ipiq(int dcpu) -{ - upc_control(UPC_CONTROL_DISPATCH, gdary[dcpu].gd_upcid, (void *)TDPRI_CRIT); -} - -void -cpu_halt(void) -{ - upc_control(UPC_CONTROL_WAIT, -1, (void *)TDPRI_CRIT); -} - -__dead2 void -panic(const char *ctl, ...) -{ - va_list va; - - va_start(va, ctl); - vfprintf(stderr, ctl, va); - va_end(va); - abort(); -} - -/* - * Create a new virtual cpu. The cpuid is returned and may be used - * in later lwkt_create() calls. - */ -static int -caps_vcpu_start(void *vgd) -{ - mi_gdinit2(vgd); /* sets %gs */ - cpu_rfork_start(); -} - -int -caps_fork_vcpu(void) -{ - int cpuid; - globaldata_t gd; - char stack[8192]; - - if ((cpuid = ncpus) >= MAXVCPU) - return(-1); - ++ncpus; - gd = &gdary[cpuid]; - mi_gdinit1(gd, cpuid); - rfork_thread(RFMEM|RFPROC|RFSIGSHARE, stack + sizeof(stack), - caps_vcpu_start, gd); - while (gd->gd_pid == 0) - ; - /* XXX wait for upcall setup */ - return(cpuid); -} - diff --git a/lib/libcaps/globaldata.h b/lib/libcaps/globaldata.h deleted file mode 100644 index 918efcb54f..0000000000 --- a/lib/libcaps/globaldata.h +++ /dev/null @@ -1,135 +0,0 @@ -/* - * GLOBALDATA.H - */ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/globaldata.h,v 1.9 2004/09/21 18:40:30 joerg Exp $ - */ - -#ifndef _LIBCAPS_GLOBALDATA_H_ -#define _LIBCAPS_GLOBALDATA_H_ - -#ifndef _LIBCAPS_THREAD_H_ -#include "thread.h" -#endif -#ifndef _SYS_THREAD_H_ -#include -#endif -#ifndef _SYS_UPCALL_H_ -#include -#endif -#ifndef _LIBCAPS_SLABALLOC_H_ -#include "slaballoc.h" -#endif -#ifndef _ASSERT_H_ -#include -#endif -#ifndef _SYS_QUEUE_H_ -#include -#endif -#ifndef _MACHINE_LOCK_H_ -#include -#endif - -struct globaldata; -typedef struct globaldata *globaldata_t; - -#include "md_globaldata.h" - -extern int smp_active; -extern int ncpus; -extern int hz; -extern u_int32_t stopped_cpus; -extern char *panicstr; - -struct globaldata { - struct globaldata *gd_self; /* self pointer */ - struct upcall gd_upcall; /* upcall for this cpu */ - int gd_upcid; /* upcall id */ - int gd_pid; /* user pid for rfork'd cpu */ - int gd_tdfreecount; - TAILQ_HEAD(,thread) gd_tdallq; /* all threads */ - TAILQ_HEAD(,thread) gd_tdfreeq; /* new thread cache */ - TAILQ_HEAD(,thread) gd_tdrunq[32]; /* runnable threads */ - __uint32_t gd_runqmask; /* which queues? */ - __uint32_t gd_cpuid; - cpumask_t gd_cpumask; /* mask = 1<gd_curthread) - -extern cpumask_t smp_active_mask; - -extern struct globaldata *globaldata_find(int cpu); - -void globaldata_init(struct thread *td); -void splz(void); -int need_lwkt_resched(void); -void cpu_halt(void); -void cpu_send_ipiq(int dcpu); -void mi_gdinit1(globaldata_t gd, int cpuid); -void mi_gdinit2(globaldata_t gd); -__dead2 void panic(const char *, ...); - -#endif diff --git a/lib/libcaps/i386/Makefile.inc b/lib/libcaps/i386/Makefile.inc deleted file mode 100644 index b499a36996..0000000000 --- a/lib/libcaps/i386/Makefile.inc +++ /dev/null @@ -1,5 +0,0 @@ -# $DragonFly: src/lib/libcaps/i386/Makefile.inc,v 1.2 2006/01/28 18:07:45 dillon Exp $ -# -#MDSRCS= td_switch.c md_globaldata.c \ -# td_switch_asm.S upcall.S mplock.S -MDSRCS= diff --git a/lib/libcaps/i386/asmacros.h b/lib/libcaps/i386/asmacros.h deleted file mode 100644 index d88863484b..0000000000 --- a/lib/libcaps/i386/asmacros.h +++ /dev/null @@ -1,9 +0,0 @@ -/* - * ASMACROS.H - * - * $DragonFly: src/lib/libcaps/i386/asmacros.h,v 1.1 2003/12/04 22:06:22 dillon Exp $ - */ -#include - -#define PCPU(name) %gs:gd_ ## name - diff --git a/lib/libcaps/i386/md_globaldata.c b/lib/libcaps/i386/md_globaldata.c deleted file mode 100644 index 495cfe382c..0000000000 --- a/lib/libcaps/i386/md_globaldata.c +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/i386/md_globaldata.c,v 1.2 2003/12/07 04:21:54 dillon Exp $ - */ -#include "../defs.h" -#include -#include - -int __mycpu__dummy; /* for the MP lock functions */ - -void -md_gdinit1(globaldata_t gd) -{ - union descriptor desc; - int error; - - bzero(&desc, sizeof(desc)); - desc.sd.sd_lolimit = sizeof(struct globaldata); - desc.sd.sd_lobase = (uintptr_t)gd & 0xFFFFFF; - desc.sd.sd_hibase = (uintptr_t)gd >> 24; - desc.sd.sd_type = SDT_MEMRW; - desc.sd.sd_dpl = SEL_UPL; - desc.sd.sd_p = 1; - desc.sd.sd_hilimit = 0; - desc.sd.sd_xx = 0; - desc.sd.sd_def32 = 1; - desc.sd.sd_gran = 0; - - error = i386_set_ldt(gd->gd_cpuid, &desc, 1); - if (error < 0) - panic("i386_set_ldt cpu %d failed\n", gd->gd_cpuid); -} - -void -md_gdinit2(globaldata_t gd) -{ - _set_mycpu(LSEL(gd->gd_cpuid, SEL_UPL)); -} - diff --git a/lib/libcaps/i386/md_globaldata.h b/lib/libcaps/i386/md_globaldata.h deleted file mode 100644 index 89e45591b6..0000000000 --- a/lib/libcaps/i386/md_globaldata.h +++ /dev/null @@ -1,37 +0,0 @@ -/* - * MD_GLOBALDATA.H - * - * $DragonFly: src/lib/libcaps/i386/md_globaldata.h,v 1.3 2007/04/13 12:12:27 corecode Exp $ - */ - -#ifndef _MD_GLOBALDATA_H_ -#define _MD_GLOBALDATA_H_ - -extern int __mycpu__dummy; - -static __inline -globaldata_t -_get_mycpu(void) -{ - globaldata_t gd; - - __asm ("movl %%gs:0,%0" : "=r" (gd) : "m"(__mycpu__dummy)); - return(gd); -} - -static __inline -void -_set_mycpu(int selector) -{ - __asm __volatile("mov %0,%%gs" :: "g"(selector)); -} - -#define mycpu _get_mycpu() - -void md_gdinit1(globaldata_t gd); -void md_gdinit2(globaldata_t gd); -void cpu_user_switch(void); -void cpu_rfork_start(void) __dead2; - -#endif - diff --git a/lib/libcaps/i386/mplock.S b/lib/libcaps/i386/mplock.S deleted file mode 100644 index 9549dd8725..0000000000 --- a/lib/libcaps/i386/mplock.S +++ /dev/null @@ -1,256 +0,0 @@ -/* - * $FreeBSD: src/sys/i386/i386/mplock.s,v 1.29.2.2 2000/05/16 06:58:06 dillon Exp $ - * $DragonFly: src/lib/libcaps/i386/mplock.S,v 1.2 2003/12/07 04:21:54 dillon Exp $ - * - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * DragonFly MPLOCK operation - * - * Each thread as an MP lock count, td_mpcount, and there is a shared - * global called mp_lock. mp_lock is the physical MP lock and contains either - * -1 or the cpuid of the cpu owning the lock. The count is *NOT* integrated - * into mp_lock but instead resides in each thread td_mpcount. - * - * When obtaining or releasing the MP lock the td_mpcount is PREDISPOSED - * to the desired count *PRIOR* to operating on the mp_lock itself. MP - * lock operations can occur outside a critical section with interrupts - * enabled with the provisio (which the routines below handle) that an - * interrupt may come along and preempt us, racing our cmpxchgl instruction - * to perform the operation we have requested by pre-dispoing td_mpcount. - * - * Additionally, the LWKT threading system manages the MP lock and - * lwkt_switch(), in particular, may be called after pre-dispoing td_mpcount - * to handle 'blocking' on the MP lock. - * - * - * Recoded from the FreeBSD original: - * ---------------------------------------------------------------------------- - * "THE BEER-WARE LICENSE" (Revision 42): - * wrote this file. As long as you retain this notice you - * can do whatever you want with this stuff. If we meet some day, and you think - * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp - * ---------------------------------------------------------------------------- - */ - -#include "asmacros.h" -#include "asdefs.h" - - .data - ALIGN_DATA -#ifdef SMP - .globl mp_lock -mp_lock: - .long -1 /* initialized to not held */ -#endif - - .text - SUPERALIGN_TEXT - - /* - * Note on cmpxchgl... exchanges ecx with mem if mem matches eax. - * Z=1 (jz) on success. A lock prefix is required for MP. - */ -NON_GPROF_ENTRY(cpu_get_initial_mplock) - movl PCPU(curthread),%ecx - movl $1,TD_MPCOUNT(%ecx) /* curthread has mpcount of 1 */ - movl $0,mp_lock /* owned by cpu 0 */ - ret - - /* - * cpu_try_mplock() returns non-zero on success, 0 on failure. It - * only adjusts mp_lock, it does not touch td_mpcount. Callers - * should always increment td_mpcount *before* trying to acquire - * the actual lock, predisposing td_mpcount to the desired state of - * the lock. - * - * NOTE! Only call cpu_try_mplock() inside a critical section. If - * you don't an interrupt can come along and get and release - * the lock before our cmpxchgl instruction, causing us to fail - * but resulting in the lock being held by our cpu. - */ -NON_GPROF_ENTRY(cpu_try_mplock) - movl PCPU(cpuid),%ecx - movl $-1,%eax - lock cmpxchgl %ecx,mp_lock /* ecx<->mem if eax matches */ - jnz 1f -#ifdef PARANOID_INVLTLB - movl %cr3,%eax; movl %eax,%cr3 /* YYY check and remove */ -#endif - movl $1,%eax - ret -1: - subl %eax,%eax - ret - - /* - * get_mplock() Obtains the MP lock and may switch away if it cannot - * get it. This routine may be called WITHOUT a critical section - * and with cpu interrupts enabled. - * - * To handle races in a sane fashion we predispose TD_MPCOUNT, - * which prevents us from losing the lock in a race if we already - * have it or happen to get it. It also means that we might get - * the lock in an interrupt race before we have a chance to execute - * our cmpxchgl instruction, so we have to handle that case. - * Fortunately simply calling lwkt_switch() handles the situation - * for us and also 'blocks' us until the MP lock can be obtained. - */ -NON_GPROF_ENTRY(get_mplock) - movl PCPU(cpuid),%ecx - movl PCPU(curthread),%edx - incl TD_MPCOUNT(%edx) /* predispose */ - cmpl %ecx,mp_lock - jne 1f - ret /* success! */ - - /* - * We don't already own the mp_lock, use cmpxchgl to try to get - * it. - */ -1: - movl $-1,%eax - lock cmpxchgl %ecx,mp_lock - jnz 2f -#ifdef PARANOID_INVLTLB - movl %cr3,%eax; movl %eax,%cr3 /* YYY check and remove */ -#endif - ret /* success */ - - /* - * Failure, but we could end up owning mp_lock anyway due to - * an interrupt race. lwkt_switch() will clean up the mess - * and 'block' until the mp_lock is obtained. - */ -2: - call lwkt_switch -#ifdef INVARIANTS - movl PCPU(cpuid),%eax /* failure */ - cmpl %eax,mp_lock - jne 4f -#endif - ret -#ifdef INVARIANTS -4: - cmpl $0,panicstr /* don't double panic */ - je badmp_get2 - ret -#endif - - /* - * try_mplock() attempts to obtain the MP lock. 1 is returned on - * success, 0 on failure. We do not have to be in a critical section - * and interrupts are almost certainly enabled. - * - * We must pre-dispose TD_MPCOUNT in order to deal with races in - * a reasonable way. - * - */ -NON_GPROF_ENTRY(try_mplock) - movl PCPU(cpuid),%ecx - movl PCPU(curthread),%edx - incl TD_MPCOUNT(%edx) /* pre-dispose for race */ - cmpl %ecx,mp_lock - je 1f /* trivial success */ - movl $-1,%eax - lock cmpxchgl %ecx,mp_lock - jnz 2f - /* - * Success - */ -#ifdef PARANOID_INVLTLB - movl %cr3,%eax; movl %eax,%cr3 /* YYY check and remove */ -#endif -1: - movl $1,%eax /* success (cmpxchgl good!) */ - ret - - /* - * The cmpxchgl failed but we might have raced. Undo the mess by - * predispoing TD_MPCOUNT and then checking. If TD_MPCOUNT is - * still non-zero we don't care what state the lock is in (since - * we obviously didn't own it above), just return failure even if - * we won the lock in an interrupt race. If TD_MPCOUNT is zero - * make sure we don't own the lock in case we did win it in a race. - */ -2: - decl TD_MPCOUNT(%edx) - cmpl $0,TD_MPCOUNT(%edx) - jne 3f - movl PCPU(cpuid),%eax - movl $-1,%ecx - lock cmpxchgl %ecx,mp_lock -3: - subl %eax,%eax - ret - - /* - * rel_mplock() releases a previously obtained MP lock. - * - * In order to release the MP lock we pre-dispose TD_MPCOUNT for - * the release and basically repeat the release portion of try_mplock - * above. - */ -NON_GPROF_ENTRY(rel_mplock) - movl PCPU(curthread),%edx - movl TD_MPCOUNT(%edx),%eax -#ifdef INVARIANTS - cmpl $0,%eax - je badmp_rel -#endif - subl $1,%eax - movl %eax,TD_MPCOUNT(%edx) - cmpl $0,%eax - jne 3f - movl PCPU(cpuid),%eax - movl $-1,%ecx - lock cmpxchgl %ecx,mp_lock -3: - ret - -#ifdef INVARIANTS - -badmp_get: - pushl $bmpsw1 - call panic -badmp_get2: - pushl $bmpsw1a - call panic -badmp_rel: - pushl $bmpsw2 - call panic - - .data - -bmpsw1: - .asciz "try/get_mplock(): already have lock! %d %p" - -bmpsw1a: - .asciz "try/get_mplock(): failed on count or switch %d %p" - -bmpsw2: - .asciz "rel_mplock(): mpcount already 0 @ %p %p %p %p %p %p %p %p!" - -#endif - diff --git a/lib/libcaps/i386/sendsys.h b/lib/libcaps/i386/sendsys.h deleted file mode 100644 index 2bc829309d..0000000000 --- a/lib/libcaps/i386/sendsys.h +++ /dev/null @@ -1,16 +0,0 @@ -/* - * $DragonFly: src/lib/libcaps/i386/sendsys.h,v 1.1 2003/12/04 22:06:22 dillon Exp $ - */ -#ifndef _SENDSYS_H_ -#define _SENDSYS_H_ - -static __inline -int -sendsys(struct lwkt_port *port, void *msg, int msgsize) -{ - int error; - __asm __volatile("int $0x81" : "=a"(error), "=c"(msg), "=d"(msgsize) : "0"(port), "1"(msg), "2"(msgsize) : "memory"); - return(error); -} - -#endif /* _SENDSYS_H_ */ diff --git a/lib/libcaps/i386/td_switch.c b/lib/libcaps/i386/td_switch.c deleted file mode 100644 index 192e7617e6..0000000000 --- a/lib/libcaps/i386/td_switch.c +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/i386/td_switch.c,v 1.2 2004/07/29 08:55:02 dillon Exp $ - */ -#include /* for __dead2 needed by thread.h */ -#include "libcaps/thread.h" -#include -#include "libcaps/globaldata.h" /* for curthread */ - -void cpu_lwkt_switch(struct thread *); -void cpu_kthread_start(struct thread *); -void cpu_exit_switch(struct thread *); - -void -cpu_init_thread(struct thread *td) -{ - td->td_sp = td->td_kstack + td->td_kstack_size - sizeof(void *); - td->td_switch = cpu_lwkt_switch; -} - -void -cpu_set_thread_handler(thread_t td, void (*rfunc)(void), void (*func)(void *), void *arg) -{ - td->td_sp -= sizeof(void *); - *(void **)td->td_sp = arg; /* argument to function */ - td->td_sp -= sizeof(void *); - *(void **)td->td_sp = rfunc; /* exit function on return */ - td->td_sp -= sizeof(void *); - *(void **)td->td_sp = func; /* started by cpu_kthread_start */ - td->td_sp -= sizeof(void *); - *(void **)td->td_sp = cpu_kthread_start; /* bootstrap */ - td->td_switch = cpu_lwkt_switch; -} - -void -cpu_thread_exit(void) -{ - curthread->td_switch = cpu_exit_switch; - lwkt_switch(); - panic("cpu_exit"); -} diff --git a/lib/libcaps/i386/td_switch_asm.S b/lib/libcaps/i386/td_switch_asm.S deleted file mode 100644 index 4d1e436658..0000000000 --- a/lib/libcaps/i386/td_switch_asm.S +++ /dev/null @@ -1,221 +0,0 @@ -/*- - * Copyright (c) 1990 The Regents of the University of California. - * All rights reserved. - * LWKT threads Copyright (c) 2003 Matthew Dillon - * - * This code is derived from software contributed to Berkeley by - * William Jolitz. - * - * 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. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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: src/sys/i386/i386/swtch.s,v 1.89.2.10 2003/01/23 03:36:24 ps Exp $ - * $DragonFly: src/lib/libcaps/i386/td_switch_asm.S,v 1.2 2003/12/07 04:21:54 dillon Exp $ - */ - -#include "asmacros.h" -#include "asdefs.h" - - .text - -/* - * cpu_exit_switch() - * - * The switch function is changed to this when a thread is going away - * for good. We have to ensure that the MMU state is not cached, and - * we don't bother saving the existing thread state before switching. - * - * At this point we are in a critical section and this cpu owns the - * thread's token, which serves as an interlock until the switchout is - * complete. - */ -NON_GPROF_ENTRY(cpu_exit_switch) - /* - * Get us out of the vmspace - */ - movl PCPU(curthread),%ebx - /* - * Switch to the next thread. RET into the restore function, which - * expects the new thread in EAX and the old in EBX. - * - * There is a one-instruction window where curthread is the new - * thread but %esp still points to the old thread's stack, but - * we are protected by a critical section so it is ok. - */ - movl 4(%esp),%eax - movl %eax,PCPU(curthread) - movl TD_SP(%eax),%esp - ret - -/* - * cpu_kthread_start() (current thread is %eax on entry) (one-time execution) - * - * Run only on first function - */ -NON_GPROF_ENTRY(cpu_kthread_start) - andl $~TDF_RUNNING,TD_FLAGS(%ebx) - orl $TDF_RUNNING,TD_FLAGS(%eax) - subl $TDPRI_CRIT,TD_PRI(%eax) - /* call splz here? */ - movl $0,%eax - movl %eax,%ebx - movl %eax,%ecx - movl %eax,%edx - movl %eax,%esi - movl %eax,%edi - movl %eax,%ebp - ret - -/* - * cpu_rfork_start(). The current thread is the idlethread. We restore the - * idle thread which generally causes us to jump to cpu_kthraed_start. - */ -NON_GPROF_ENTRY(cpu_rfork_start) - movl PCPU(curthread),%eax - movl %eax,%ebx - movl TD_SP(%eax),%esp - ret - -/* - * cpu_lwkt_switch() - * - * Standard LWKT switching function. Only non-scratch registers are - * saved and we don't bother with the MMU state or anything else. - * - * This function is always called while in a critical section. - * - * There is a one-instruction window where curthread is the new - * thread but %esp still points to the old thread's stack, but - * we are protected by a critical section so it is ok. - * - * YYY BGL, SPL - */ -NON_GPROF_ENTRY(cpu_lwkt_switch) - movl 4(%esp),%eax - pushl %ebp - pushl %ebx - pushl %esi - pushl %edi - pushfl - movl PCPU(curthread),%ebx - pushl $cpu_lwkt_restore - movl %esp,TD_SP(%ebx) - movl %eax,PCPU(curthread) - movl TD_SP(%eax),%esp - - /* - * eax contains new thread, ebx contains old thread. - */ - ret - -/* - * cpu_lwkt_restore() (current thread in %eax on entry) - * (old thread %ebx on entry) - * - * Standard LWKT restore function. This function is always called - * while in a critical section. - * - * Warning: due to preemption the restore function can be used to - * 'return' to the original thread. Interrupt disablement must be - * protected through the switch so we cannot run splz here. - * - * YYY we theoretically do not need to load IdlePTD into cr3, but if - * so we need a way to detect when the PTD we are using is being - * deleted due to a process exiting. - */ -NON_GPROF_ENTRY(cpu_lwkt_restore) - andl $~TDF_RUNNING,TD_FLAGS(%ebx) - orl $TDF_RUNNING,TD_FLAGS(%eax) - popfl - popl %edi - popl %esi - popl %ebx - popl %ebp - ret - -/* - * cpu_user_switch() - * - * Standard USER switching function. FP and non-scratch registers - * are saved. - * - * This function is always called while in a critical section. - * - * There is a one-instruction window where curthread is the new - * thread but %esp still points to the old thread's stack, but - * we are protected by a critical section so it is ok. - * - * YYY BGL, SPL - */ -NON_GPROF_ENTRY(cpu_user_switch) - movl 4(%esp),%eax - pushl %ebp - pushl %ebx - pushl %esi - pushl %edi - pushfl - subl $108,%esp - fnsave 0(%esp) - movl PCPU(curthread),%ebx - pushl $cpu_user_restore - movl %esp,TD_SP(%ebx) - movl %eax,PCPU(curthread) - movl TD_SP(%eax),%esp - - /* - * eax contains new thread, ebx contains old thread. - */ - ret - -/* - * cpu_user_restore() (current thread in %eax on entry) - * - * Standard LWKT restore function. This function is always called - * while in a critical section. - * - * Warning: due to preemption the restore function can be used to - * 'return' to the original thread. Interrupt disablement must be - * protected through the switch so we cannot run splz here. - * - * YYY we theoretically do not need to load IdlePTD into cr3, but if - * so we need a way to detect when the PTD we are using is being - * deleted due to a process exiting. - */ -NON_GPROF_ENTRY(cpu_user_restore) - andl $~TDF_RUNNING,TD_FLAGS(%ebx) - orl $TDF_RUNNING,TD_FLAGS(%eax) - frstor 0(%esp) - addl $108,%esp - popfl - popl %edi - popl %esi - popl %ebx - popl %ebp - ret - - .end diff --git a/lib/libcaps/i386/upcall.S b/lib/libcaps/i386/upcall.S deleted file mode 100644 index 242027363c..0000000000 --- a/lib/libcaps/i386/upcall.S +++ /dev/null @@ -1,34 +0,0 @@ - /* - * $DragonFly: src/lib/libcaps/i386/upcall.S,v 1.2 2003/12/07 04:21:54 dillon Exp $ - */ - -#include "asmacros.h" -#include "asdefs.h" - - .text - .globl upc_callused_wrapper - - /* - * On entry: %eax contains function - * %ecx contains data - * Stack: [eax,ecx,eflags,oldip] - */ -NON_GPROF_ENTRY(upc_callused_wrapper) - pushl %edx /* save %edx (upcall pointer) */ - pushl %ecx /* func(data) */ - call *%eax - addl $4,%esp - popl %edx /* upcall pointer */ - movl UPC_UTHREAD(%edx),%eax - incl UPC_PENDING(%edx) /* set pending bit (prevents upcalls) */ - subl $TDPRI_CRIT,TD_PRI(%eax) /* cleanup critical section count */ - pushl %esp /* sp pointing to os supplied frame */ - pushl $-1 /* upcid */ - pushl $2 /* FETCH next */ - call upc_control - popl %eax - popl %ecx - popl %edx - popfl - ret - diff --git a/lib/libcaps/init.c b/lib/libcaps/init.c deleted file mode 100644 index 38fe5c5590..0000000000 --- a/lib/libcaps/init.c +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/init.c,v 1.2 2003/12/07 04:21:52 dillon Exp $ - */ - -#include "defs.h" - -struct thread main_td; - -static void uthread_exit(void); - -void -uthread_init(void) -{ - slab_init(); - globaldata_init(&main_td); - sysport_init(); - crit_exit(); - get_mplock(); - atexit(uthread_exit); -} - -void -uthread_exit(void) -{ - int i; - - for (i = 0; i < ncpus; ++i) { - globaldata_t gd = globaldata_find(i); - if (gd != mycpu && gd->gd_pid) - kill(gd->gd_pid, 9); - } -} - diff --git a/lib/libcaps/slaballoc.c b/lib/libcaps/slaballoc.c deleted file mode 100644 index 4b9056b595..0000000000 --- a/lib/libcaps/slaballoc.c +++ /dev/null @@ -1,827 +0,0 @@ -/* - * SLABALLOC.C - Userland SLAB memory allocator - * - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/slaballoc.c,v 1.4 2004/07/04 22:44:26 eirikn Exp $ - * - * This module implements a thread-safe slab allocator for userland. - * - * A slab allocator reserves a ZONE for each chunk size, then lays the - * chunks out in an array within the zone. Allocation and deallocation - * is nearly instantanious, and fragmentation/overhead losses are limited - * to a fixed worst-case amount. - * - * The downside of this slab implementation is in the chunk size - * multiplied by the number of zones. ~80 zones * 128K = 10MB of VM per cpu. - * To mitigate this we attempt to select a reasonable zone size based on - * available system memory. e.g. 32K instead of 128K. Also since the - * slab allocator is operating out of virtual memory in userland the actual - * physical memory use is not as bad as it might otherwise be. - * - * The upside is that overhead is bounded... waste goes down as use goes up. - * - * Slab management is done on a per-cpu basis and no locking or mutexes - * are required, only a critical section. When one cpu frees memory - * belonging to another cpu's slab manager an asynchronous IPI message - * will be queued to execute the operation. In addition, both the - * high level slab allocator and the low level zone allocator optimize - * M_ZERO requests, and the slab allocator does not have to pre initialize - * the linked list of chunks. - * - * XXX Balancing is needed between cpus. Balance will be handled through - * asynchronous IPIs primarily by reassigning the z_Cpu ownership of chunks. - * - * Alloc Size Chunking Number of zones - * 0-127 8 16 - * 128-255 16 8 - * 256-511 32 8 - * 512-1023 64 8 - * 1024-2047 128 8 - * 2048-4095 256 8 - * 4096-8191 512 8 - * 8192-16383 1024 8 - * 16384-32767 2048 8 - * (if PAGE_SIZE is 4K the maximum zone allocation is 16383) - * - * Allocations >= ZoneLimit go directly to kmem. - * - * API REQUIREMENTS AND SIDE EFFECTS - * - * To operate as a drop-in replacement to the FreeBSD-4.x malloc() we - * have remained compatible with the following API requirements: - * - * + small power-of-2 sized allocations are power-of-2 aligned (kern_tty) - * + all power-of-2 sized allocations are power-of-2 aligned (twe) - * + malloc(0) is allowed and returns non-NULL (ahc driver) - * + ability to allocate arbitrarily large chunks of memory - */ - -#include -#include -#include -#include -#include -#include -#include "thread.h" -#include -#include -#include -#include "globaldata.h" -#include -#include -#include -#include - -#define arysize(ary) (sizeof(ary)/sizeof((ary)[0])) -#define slab_min(a,b) (((a)<(b)) ? (a) : (b)) - -/* - * Fixed globals (not per-cpu) - */ -static int ZoneSize; -static int ZoneLimit; -static int ZonePageCount; -static int ZonePageLimit; -static int ZoneMask; -static struct malloc_type *kmemstatistics; -static int32_t weirdary[16]; - -/* - * Misc constants. Note that allocations that are exact multiples of - * PAGE_SIZE, or exceed the zone limit, fall through to the kmem module. - * IN_SAME_PAGE_MASK is used to sanity-check the per-page free lists. - */ -#define MIN_CHUNK_SIZE 8 /* in bytes */ -#define MIN_CHUNK_MASK (MIN_CHUNK_SIZE - 1) -#define ZONE_RELS_THRESH 2 /* threshold number of zones */ -#define IN_SAME_PAGE_MASK (~(intptr_t)PAGE_MASK | MIN_CHUNK_MASK) - -#define SLOVERSZ_HSIZE 8192 -#define SLOVERSZ_HMASK (SLOVERSZ_HSIZE - 1) - -#define SLOVERSZ_HASH(ptr) ((((uintptr_t)ptr >> PAGE_SHIFT) ^ \ - ((uintptr_t)ptr >> (PAGE_SHIFT * 2))) & \ - SLOVERSZ_HMASK) - -SLOversized *SLOvHash[SLOVERSZ_HSIZE]; - -/* - * The WEIRD_ADDR is used as known text to copy into free objects to - * try to create deterministic failure cases if the data is accessed after - * free. - */ -#define WEIRD_ADDR 0xdeadc0de -#define MAX_COPY sizeof(weirdary) -#define ZERO_LENGTH_PTR ((void *)-8) - -/* - * Misc global malloc buckets - */ -MALLOC_DEFINE(M_OVERSIZED, "overszinfo", "Oversized Info Blocks"); - -static __inline -SLOversized ** -get_oversized(void *ptr) -{ - SLOversized **slovpp; - SLOversized *slov; - - for (slovpp = &SLOvHash[SLOVERSZ_HASH(ptr)]; - (slov = *slovpp) != NULL; - slovpp = &slov->ov_Next - ) { - if (slov->ov_Ptr == ptr) - return(slovpp); - } - return(NULL); -} - -/* - * Initialize the slab memory allocator. We have to choose a zone size based - * on available physical memory. We choose a zone side which is approximately - * 1/1024th of our memory, so if we have 128MB of ram we have a zone size of - * 128K. The zone size is limited to the bounds set in slaballoc.h - * (typically 32K min, 128K max). - */ -void -slab_init(void) -{ - int i; - int error; - int pagecnt; - int pagecnt_size = sizeof(pagecnt); - - error = sysctlbyname("vm.stats.vm.v_page_count", - &pagecnt, &pagecnt_size, NULL, 0); - if (error == 0) { - vm_poff_t limsize; - int usesize; - - limsize = pagecnt * (vm_poff_t)PAGE_SIZE; - usesize = (int)(limsize / 1024); /* convert to KB */ - - ZoneSize = ZALLOC_MIN_ZONE_SIZE; - while (ZoneSize < ZALLOC_MAX_ZONE_SIZE && (ZoneSize << 1) < usesize) - ZoneSize <<= 1; - } else { - ZoneSize = ZALLOC_MIN_ZONE_SIZE; - } - ZoneLimit = ZoneSize / 4; - if (ZoneLimit > ZALLOC_ZONE_LIMIT) - ZoneLimit = ZALLOC_ZONE_LIMIT; - ZoneMask = ZoneSize - 1; - ZonePageLimit = PAGE_SIZE * 4; - ZonePageCount = ZoneSize / PAGE_SIZE; - - for (i = 0; i < arysize(weirdary); ++i) - weirdary[i] = WEIRD_ADDR; - slab_malloc_init(M_OVERSIZED); -} - -/* - * Initialize a malloc type tracking structure. - */ -void -slab_malloc_init(void *data) -{ - struct malloc_type *type = data; - vm_poff_t limsize; - - /* - * Skip if already initialized - */ - if (type->ks_limit != 0) - return; - - type->ks_magic = M_MAGIC; - limsize = (vm_poff_t)-1; /* unlimited */ - type->ks_limit = limsize / 10; - type->ks_next = kmemstatistics; - kmemstatistics = type; -} - -void -slab_malloc_uninit(void *data) -{ - struct malloc_type *type = data; - struct malloc_type *t; -#ifdef INVARIANTS - int i; - long ttl; -#endif - - if (type->ks_magic != M_MAGIC) - panic("malloc type lacks magic"); - - if (type->ks_limit == 0) - panic("malloc_uninit on uninitialized type"); - -#ifdef INVARIANTS - /* - * memuse is only correct in aggregation. Due to memory being allocated - * on one cpu and freed on another individual array entries may be - * negative or positive (canceling each other out). - */ - for (i = ttl = 0; i < ncpus; ++i) - ttl += type->ks_memuse[i]; - if (ttl) { - printf("malloc_uninit: %ld bytes of '%s' still allocated on cpu %d\n", - ttl, type->ks_shortdesc, i); - } -#endif - if (type == kmemstatistics) { - kmemstatistics = type->ks_next; - } else { - for (t = kmemstatistics; t->ks_next != NULL; t = t->ks_next) { - if (t->ks_next == type) { - t->ks_next = type->ks_next; - break; - } - } - } - type->ks_next = NULL; - type->ks_limit = 0; -} - -/* - * Calculate the zone index for the allocation request size and set the - * allocation request size to that particular zone's chunk size. - */ -static __inline int -zoneindex(unsigned long *bytes) -{ - unsigned int n = (unsigned int)*bytes; /* unsigned for shift opt */ - if (n < 128) { - *bytes = n = (n + 7) & ~7; - return(n / 8 - 1); /* 8 byte chunks, 16 zones */ - } - if (n < 256) { - *bytes = n = (n + 15) & ~15; - return(n / 16 + 7); - } - if (n < 8192) { - if (n < 512) { - *bytes = n = (n + 31) & ~31; - return(n / 32 + 15); - } - if (n < 1024) { - *bytes = n = (n + 63) & ~63; - return(n / 64 + 23); - } - if (n < 2048) { - *bytes = n = (n + 127) & ~127; - return(n / 128 + 31); - } - if (n < 4096) { - *bytes = n = (n + 255) & ~255; - return(n / 256 + 39); - } - *bytes = n = (n + 511) & ~511; - return(n / 512 + 47); - } -#if ZALLOC_ZONE_LIMIT > 8192 - if (n < 16384) { - *bytes = n = (n + 1023) & ~1023; - return(n / 1024 + 55); - } -#endif -#if ZALLOC_ZONE_LIMIT > 16384 - if (n < 32768) { - *bytes = n = (n + 2047) & ~2047; - return(n / 2048 + 63); - } -#endif - panic("Unexpected byte count %d", n); - return(0); -} - -/* - * slab_malloc() - * - * Allocate memory via the slab allocator. If the request is too large, - * or if it page-aligned beyond a certain size, we fall back to the - * KMEM subsystem. A SLAB tracking descriptor must be specified, use - * &SlabMisc if you don't care. - * - * M_NOWAIT - return NULL instead of blocking. - * M_ZERO - zero the returned memory. - */ -void * -slab_malloc(unsigned long size, struct malloc_type *type, int flags) -{ - SLZone *z; - SLChunk *chunk; - SLGlobalData *slgd; - struct globaldata *gd; - int zi; - - gd = mycpu; - slgd = &gd->gd_slab; - - /* - * XXX silly to have this in the critical path. - */ - if (type->ks_limit == 0) { - crit_enter(); - if (type->ks_limit == 0) - slab_malloc_init(type); - crit_exit(); - } - ++type->ks_calls; - - /* - * Handle the case where the limit is reached. Panic if can't return - * NULL. XXX the original malloc code looped, but this tended to - * simply deadlock the computer. - */ - while (type->ks_loosememuse >= type->ks_limit) { - int i; - long ttl; - - for (i = ttl = 0; i < ncpus; ++i) - ttl += type->ks_memuse[i]; - type->ks_loosememuse = ttl; - if (ttl >= type->ks_limit) { - if (flags & (M_NOWAIT|M_NULLOK)) - return(NULL); - panic("%s: malloc limit exceeded", type->ks_shortdesc); - } - } - - /* - * Handle the degenerate size == 0 case. Yes, this does happen. - * Return a special pointer. This is to maintain compatibility with - * the original malloc implementation. Certain devices, such as the - * adaptec driver, not only allocate 0 bytes, they check for NULL and - * also realloc() later on. Joy. - */ - if (size == 0) - return(ZERO_LENGTH_PTR); - - /* - * Handle hysteresis from prior frees here in malloc(). We cannot - * safely manipulate the kernel_map in free() due to free() possibly - * being called via an IPI message or from sensitive interrupt code. - */ - while (slgd->NFreeZones > ZONE_RELS_THRESH && (flags & M_NOWAIT) == 0) { - crit_enter(); - if (slgd->NFreeZones > ZONE_RELS_THRESH) { /* crit sect race */ - z = slgd->FreeZones; - slgd->FreeZones = z->z_Next; - --slgd->NFreeZones; - munmap(z, ZoneSize); - } - crit_exit(); - } - /* - * XXX handle oversized frees that were queued from free(). - */ - while (slgd->FreeOvZones && (flags & M_NOWAIT) == 0) { - crit_enter(); - if ((z = slgd->FreeOvZones) != NULL) { - KKASSERT(z->z_Magic == ZALLOC_OVSZ_MAGIC); - slgd->FreeOvZones = z->z_Next; - munmap(z, z->z_ChunkSize); - } - crit_exit(); - } - - /* - * Handle large allocations directly. There should not be very many of - * these so performance is not a big issue. - * - * Guarentee page alignment for allocations in multiples of PAGE_SIZE - */ - if (size >= ZoneLimit || (size & PAGE_MASK) == 0) { - SLOversized **slovpp; - SLOversized *slov; - - slov = slab_malloc(sizeof(SLOversized), M_OVERSIZED, M_ZERO); - if (slov == NULL) - return(NULL); - - size = round_page(size); - chunk = mmap(NULL, size, PROT_READ|PROT_WRITE, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (chunk == MAP_FAILED) { - slab_free(slov, M_OVERSIZED); - return(NULL); - } - flags &= ~M_ZERO; /* result already zero'd if M_ZERO was set */ - flags |= M_PASSIVE_ZERO; - - slov->ov_Ptr = chunk; - slov->ov_Bytes = size; - slovpp = &SLOvHash[SLOVERSZ_HASH(chunk)]; - slov->ov_Next = *slovpp; - *slovpp = slov; - crit_enter(); - goto done; - } - - /* - * Attempt to allocate out of an existing zone. First try the free list, - * then allocate out of unallocated space. If we find a good zone move - * it to the head of the list so later allocations find it quickly - * (we might have thousands of zones in the list). - * - * Note: zoneindex() will panic of size is too large. - */ - zi = zoneindex(&size); - KKASSERT(zi < NZONES); - crit_enter(); - if ((z = slgd->ZoneAry[zi]) != NULL) { - KKASSERT(z->z_NFree > 0); - - /* - * Remove us from the ZoneAry[] when we become empty - */ - if (--z->z_NFree == 0) { - slgd->ZoneAry[zi] = z->z_Next; - z->z_Next = NULL; - } - - /* - * Locate a chunk in a free page. This attempts to localize - * reallocations into earlier pages without us having to sort - * the chunk list. A chunk may still overlap a page boundary. - */ - while (z->z_FirstFreePg < ZonePageCount) { - if ((chunk = z->z_PageAry[z->z_FirstFreePg]) != NULL) { -#ifdef DIAGNOSTIC - /* - * Diagnostic: c_Next is not total garbage. - */ - KKASSERT(chunk->c_Next == NULL || - ((intptr_t)chunk->c_Next & IN_SAME_PAGE_MASK) == - ((intptr_t)chunk & IN_SAME_PAGE_MASK)); -#endif -#ifdef INVARIANTS - if ((uintptr_t)chunk < VM_MIN_KERNEL_ADDRESS) - panic("chunk %p FFPG %d/%d", chunk, z->z_FirstFreePg, ZonePageCount); - if (chunk->c_Next && (uintptr_t)chunk->c_Next < VM_MIN_KERNEL_ADDRESS) - panic("chunkNEXT %p %p FFPG %d/%d", chunk, chunk->c_Next, z->z_FirstFreePg, ZonePageCount); -#endif - z->z_PageAry[z->z_FirstFreePg] = chunk->c_Next; - goto done; - } - ++z->z_FirstFreePg; - } - - /* - * No chunks are available but NFree said we had some memory, so - * it must be available in the never-before-used-memory area - * governed by UIndex. The consequences are very serious if our zone - * got corrupted so we use an explicit panic rather then a KASSERT. - */ - if (z->z_UIndex + 1 != z->z_NMax) - z->z_UIndex = z->z_UIndex + 1; - else - z->z_UIndex = 0; - if (z->z_UIndex == z->z_UEndIndex) - panic("slaballoc: corrupted zone"); - chunk = (SLChunk *)(z->z_BasePtr + z->z_UIndex * size); - if ((z->z_Flags & SLZF_UNOTZEROD) == 0) { - flags &= ~M_ZERO; - flags |= M_PASSIVE_ZERO; - } - goto done; - } - - /* - * If all zones are exhausted we need to allocate a new zone for this - * index. Use M_ZERO to take advantage of pre-zerod pages. Also see - * UAlloc use above in regards to M_ZERO. Note that when we are reusing - * a zone from the FreeZones list UAlloc'd data will not be zero'd, and - * we do not pre-zero it because we do not want to mess up the L1 cache. - * - * At least one subsystem, the tty code (see CROUND) expects power-of-2 - * allocations to be power-of-2 aligned. We maintain compatibility by - * adjusting the base offset below. - */ - { - int off; - - if ((z = slgd->FreeZones) != NULL) { - slgd->FreeZones = z->z_Next; - --slgd->NFreeZones; - bzero(z, sizeof(SLZone)); - z->z_Flags |= SLZF_UNOTZEROD; - } else { - z = mmap(NULL, ZoneSize, PROT_READ|PROT_WRITE, - MAP_ANON|MAP_PRIVATE, -1, 0); - if (z == MAP_FAILED) - goto fail; - } - - /* - * Guarentee power-of-2 alignment for power-of-2-sized chunks. - * Otherwise just 8-byte align the data. - */ - if ((size | (size - 1)) + 1 == (size << 1)) - off = (sizeof(SLZone) + size - 1) & ~(size - 1); - else - off = (sizeof(SLZone) + MIN_CHUNK_MASK) & ~MIN_CHUNK_MASK; - z->z_Magic = ZALLOC_SLAB_MAGIC; - z->z_ZoneIndex = zi; - z->z_NMax = (ZoneSize - off) / size; - z->z_NFree = z->z_NMax - 1; - z->z_BasePtr = (char *)z + off; - z->z_UIndex = z->z_UEndIndex = slgd->JunkIndex % z->z_NMax; - z->z_ChunkSize = size; - z->z_FirstFreePg = ZonePageCount; - z->z_Cpu = gd->gd_cpuid; - z->z_CpuGd = gd; - chunk = (SLChunk *)(z->z_BasePtr + z->z_UIndex * size); - z->z_Next = slgd->ZoneAry[zi]; - slgd->ZoneAry[zi] = z; - if ((z->z_Flags & SLZF_UNOTZEROD) == 0) { - flags &= ~M_ZERO; /* already zero'd */ - flags |= M_PASSIVE_ZERO; - } - - /* - * Slide the base index for initial allocations out of the next - * zone we create so we do not over-weight the lower part of the - * cpu memory caches. - */ - slgd->JunkIndex = (slgd->JunkIndex + ZALLOC_SLAB_SLIDE) - & (ZALLOC_MAX_ZONE_SIZE - 1); - } -done: - ++type->ks_inuse[gd->gd_cpuid]; - type->ks_memuse[gd->gd_cpuid] += size; - type->ks_loosememuse += size; - crit_exit(); - if (flags & M_ZERO) - bzero(chunk, size); -#ifdef INVARIANTS - else if ((flags & (M_ZERO|M_PASSIVE_ZERO)) == 0) - chunk->c_Next = (void *)-1; /* avoid accidental double-free check */ -#endif - return(chunk); -fail: - crit_exit(); - return(NULL); -} - -void * -slab_realloc(void *ptr, unsigned long size, struct malloc_type *type, int flags) -{ - SLZone *z; - SLOversized **slovpp; - SLOversized *slov; - void *nptr; - unsigned long osize; - - if (ptr == NULL || ptr == ZERO_LENGTH_PTR) - return(slab_malloc(size, type, flags)); - if (size == 0) { - slab_free(ptr, type); - return(NULL); - } - - /* - * Handle oversized allocations. - */ - if ((slovpp = get_oversized(ptr)) != NULL) { - slov = *slovpp; - osize = slov->ov_Bytes; - if (osize == round_page(size)) - return(ptr); - if ((nptr = slab_malloc(size, type, flags)) == NULL) - return(NULL); - bcopy(ptr, nptr, slab_min(size, osize)); - slab_free(ptr, type); - return(nptr); - } - - /* - * Get the original allocation's zone. If the new request winds up - * using the same chunk size we do not have to do anything. - */ - z = (SLZone *)((uintptr_t)ptr & ~(uintptr_t)ZoneMask); - KKASSERT(z->z_Magic == ZALLOC_SLAB_MAGIC); - - zoneindex(&size); - if (z->z_ChunkSize == size) - return(ptr); - - /* - * Allocate memory for the new request size. Note that zoneindex has - * already adjusted the request size to the appropriate chunk size, which - * should optimize our bcopy(). Then copy and return the new pointer. - */ - if ((nptr = slab_malloc(size, type, flags)) == NULL) - return(NULL); - bcopy(ptr, nptr, slab_min(size, z->z_ChunkSize)); - slab_free(ptr, type); - return(nptr); -} - -#ifdef SMP -/* - * slab_free() (SLAB ALLOCATOR) - * - * Free the specified chunk of memory. - */ -static -void -slab_free_remote(void *ptr) -{ - slab_free(ptr, *(struct malloc_type **)ptr); -} - -#endif - -void -slab_free(void *ptr, struct malloc_type *type) -{ - SLZone *z; - SLOversized **slovpp; - SLOversized *slov; - SLChunk *chunk; - SLGlobalData *slgd; - struct globaldata *gd; - int pgno; - - gd = mycpu; - slgd = &gd->gd_slab; - - /* - * Handle special 0-byte allocations - */ - if (ptr == ZERO_LENGTH_PTR) - return; - - /* - * Handle oversized allocations. XXX we really should require that a - * size be passed to slab_free() instead of this nonsense. - * - * This code is never called via an ipi. - */ - if ((slovpp = get_oversized(ptr)) != NULL) { - slov = *slovpp; - *slovpp = slov->ov_Next; - -#ifdef INVARIANTS - KKASSERT(sizeof(weirdary) <= slov->ov_Bytes); - bcopy(weirdary, ptr, sizeof(weirdary)); -#endif - /* - * note: we always adjust our cpu's slot, not the originating - * cpu (kup->ku_cpuid). The statistics are in aggregate. - * - * note: XXX we have still inherited the interrupts-can't-block - * assumption. An interrupt thread does not bump - * gd_intr_nesting_level so check TDF_INTTHREAD. This is - * primarily until we can fix softupdate's assumptions about - * slab_free(). - */ - crit_enter(); - --type->ks_inuse[gd->gd_cpuid]; - type->ks_memuse[gd->gd_cpuid] -= slov->ov_Bytes; - if (mycpu->gd_intr_nesting_level || (gd->gd_curthread->td_flags & TDF_INTTHREAD)) { - z = (SLZone *)ptr; - z->z_Magic = ZALLOC_OVSZ_MAGIC; - z->z_Next = slgd->FreeOvZones; - z->z_ChunkSize = slov->ov_Bytes; - slgd->FreeOvZones = z; - crit_exit(); - } else { - crit_exit(); - munmap(ptr, slov->ov_Bytes); - } - slab_free(slov, M_OVERSIZED); - return; - } - - /* - * Zone case. Figure out the zone based on the fact that it is - * ZoneSize aligned. - */ - z = (SLZone *)((uintptr_t)ptr & ~(uintptr_t)ZoneMask); - KKASSERT(z->z_Magic == ZALLOC_SLAB_MAGIC); - - /* - * If we do not own the zone then forward the request to the - * cpu that does. The freeing code does not need the byte count - * unless DIAGNOSTIC is set. - */ - if (z->z_CpuGd != gd) { - *(struct malloc_type **)ptr = type; -#ifdef SMP - lwkt_send_ipiq(z->z_CpuGd, slab_free_remote, ptr); -#else - panic("Corrupt SLZone"); -#endif - return; - } - - if (type->ks_magic != M_MAGIC) - panic("slab_free: malloc type lacks magic"); - - crit_enter(); - pgno = ((char *)ptr - (char *)z) >> PAGE_SHIFT; - chunk = ptr; - -#ifdef INVARIANTS - /* - * Attempt to detect a double-free. To reduce overhead we only check - * if there appears to be link pointer at the base of the data. - */ - if (((intptr_t)chunk->c_Next - (intptr_t)z) >> PAGE_SHIFT == pgno) { - SLChunk *scan; - for (scan = z->z_PageAry[pgno]; scan; scan = scan->c_Next) { - if (scan == chunk) - panic("Double free at %p", chunk); - } - } -#endif - - /* - * Put weird data into the memory to detect modifications after freeing, - * illegal pointer use after freeing (we should fault on the odd address), - * and so forth. XXX needs more work, see the old malloc code. - */ -#ifdef INVARIANTS - if (z->z_ChunkSize < sizeof(weirdary)) - bcopy(weirdary, chunk, z->z_ChunkSize); - else - bcopy(weirdary, chunk, sizeof(weirdary)); -#endif - - /* - * Add this free non-zero'd chunk to a linked list for reuse, adjust - * z_FirstFreePg. - */ -#ifdef INVARIANTS - if ((uintptr_t)chunk < VM_MIN_KERNEL_ADDRESS) - panic("BADFREE %p\n", chunk); -#endif - chunk->c_Next = z->z_PageAry[pgno]; - z->z_PageAry[pgno] = chunk; -#ifdef INVARIANTS - if (chunk->c_Next && (uintptr_t)chunk->c_Next < VM_MIN_KERNEL_ADDRESS) - panic("BADFREE2"); -#endif - if (z->z_FirstFreePg > pgno) - z->z_FirstFreePg = pgno; - - /* - * Bump the number of free chunks. If it becomes non-zero the zone - * must be added back onto the appropriate list. - */ - if (z->z_NFree++ == 0) { - z->z_Next = slgd->ZoneAry[z->z_ZoneIndex]; - slgd->ZoneAry[z->z_ZoneIndex] = z; - } - - --type->ks_inuse[z->z_Cpu]; - type->ks_memuse[z->z_Cpu] -= z->z_ChunkSize; - - /* - * If the zone becomes totally free, and there are other zones we - * can allocate from, move this zone to the FreeZones list. Since - * this code can be called from an IPI callback, do *NOT* try to mess - * with kernel_map here. Hysteresis will be performed at malloc() time. - */ - if (z->z_NFree == z->z_NMax && - (z->z_Next || slgd->ZoneAry[z->z_ZoneIndex] != z) - ) { - SLZone **pz; - - for (pz = &slgd->ZoneAry[z->z_ZoneIndex]; z != *pz; pz = &(*pz)->z_Next) - ; - *pz = z->z_Next; - z->z_Magic = -1; - z->z_Next = slgd->FreeZones; - slgd->FreeZones = z; - ++slgd->NFreeZones; - } - crit_exit(); -} - diff --git a/lib/libcaps/slaballoc.h b/lib/libcaps/slaballoc.h deleted file mode 100644 index 20b11838c5..0000000000 --- a/lib/libcaps/slaballoc.h +++ /dev/null @@ -1,111 +0,0 @@ -/* - * SLABALLOC.H - Userland SLAB memory allocator - * - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/slaballoc.h,v 1.3 2004/03/06 19:48:22 dillon Exp $ - */ - -#ifndef _LIBCAPS_SLABALLOC_H_ -#define _LIBCAPS_SLABALLOC_H_ - -#ifndef _SYS_STDINT_H_ -#include -#endif -#ifndef _SYS_MALLOC_H_ -#include -#endif - -/* - * Note that any allocations which are exact multiples of PAGE_SIZE, or - * which are >= ZALLOC_ZONE_LIMIT, will fall through to the kmem subsystem. - */ -#define ZALLOC_ZONE_LIMIT (16 * 1024) /* max slab-managed alloc */ -#define ZALLOC_MIN_ZONE_SIZE (32 * 1024) /* minimum zone size */ -#define ZALLOC_MAX_ZONE_SIZE (128 * 1024) /* maximum zone size */ -#define ZALLOC_SLAB_MAGIC 0x736c6162 /* magic sanity */ -#define ZALLOC_OVSZ_MAGIC 0x736c6163 /* magic sanity */ -#define ZALLOC_SLAB_SLIDE 20 - - -#if ZALLOC_ZONE_LIMIT == 16384 -#define NZONES 72 -#elif ZALLOC_ZONE_LIMIT == 32768 -#define NZONES 80 -#else -#error "I couldn't figure out NZONES" -#endif - -/* - * Chunk structure for free elements - */ -typedef struct SLChunk { - struct SLChunk *c_Next; -} SLChunk; - -/* - * The IN-BAND zone header is placed at the beginning of each zone. - */ -typedef struct SLZone { - __int32_t z_Magic; /* magic number for sanity check */ - int z_Cpu; /* which cpu owns this zone? */ - struct globaldata *z_CpuGd; - int z_NFree; /* total free chunks / ualloc space in zone */ - struct SLZone *z_Next; /* ZoneAry[] link if z_NFree non-zero */ - int z_NMax; /* maximum free chunks */ - char *z_BasePtr; /* pointer to start of chunk array */ - int z_UIndex; /* current initial allocation index */ - int z_UEndIndex; /* last (first) allocation index */ - int z_ChunkSize; /* chunk size for validation */ - int z_FirstFreePg; /* chunk list on a page-by-page basis */ - int z_ZoneIndex; - int z_Flags; - SLChunk *z_PageAry[ZALLOC_MAX_ZONE_SIZE / PAGE_SIZE]; -} SLZone; - -#define SLZF_UNOTZEROD 0x0001 - -typedef struct SLGlobalData { - SLZone *ZoneAry[NZONES]; /* linked list of zones NFree > 0 */ - SLZone *FreeZones; /* whole zones that have become free */ - SLZone *FreeOvZones; /* oversized zones */ - int NFreeZones; /* free zone count */ - int JunkIndex; - struct malloc_type ZoneInfo; /* stats on meta-zones allocated */ -} SLGlobalData; - -typedef struct SLOversized { - struct SLOversized *ov_Next; - void *ov_Ptr; - __uintptr_t ov_Bytes; -} SLOversized; - -void slab_init(void); -void slab_malloc_init(void *data); -void *slab_malloc(unsigned long size, struct malloc_type *type, int flags); -void slab_free(void *ptr, struct malloc_type *info); - -#endif - diff --git a/lib/libcaps/sysport.c b/lib/libcaps/sysport.c deleted file mode 100644 index 34212d124c..0000000000 --- a/lib/libcaps/sysport.c +++ /dev/null @@ -1,189 +0,0 @@ -/* - * Copyright (c) 2003 Galen Sampson - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/sysport.c,v 1.4 2004/07/29 08:55:02 dillon Exp $ - */ -#include "defs.h" - -#include "sendsys.h" -#include -#include -#include - -/* XXX Temporary */ -#include - -#ifdef DEBUG -#include -#endif - -static int sysport_putport(lwkt_port_t port, lwkt_msg_t msg); -static void sysport_loop(void *dummy); - -struct thread sys_td; -lwkt_port_t sysport; - -void -sysport_init(void) -{ - lwkt_init_thread(&sys_td, libcaps_alloc_stack(LWKT_THREAD_STACK), - LWKT_THREAD_STACK, TDF_SYSTHREAD, mycpu); - sysport = &sys_td.td_msgport; - sysport->mp_putport = sysport_putport; - sysport->mp_flags = MSGPORTF_WAITING; /* XXX temporary */ - cpu_set_thread_handler(&sys_td, lwkt_exit, sysport_loop, NULL); -} - -/************************************************************************ - * PORT FUNCTIONS * - ************************************************************************/ - -/* - * XXX We might need to separte this function in the way *lwkt_putport* - * is separated in the case of multiple cpus. Secifically we will need - * a lwkt_sysputport_remote(). - */ -static -int -sysport_putport(lwkt_port_t port, lwkt_msg_t msg) -{ - int error = 0; - thread_t td = port->mp_td; - - /** - * XXX sendsys() will only allow asynchronous messages from uid 0. This - * is a kernel issue. See note below. - */ - if(msg->ms_flags & MSGF_ASYNC) - { - /** - * The message is not done. - */ - msg->ms_flags &= ~MSGF_DONE; - error = sendsys(NULL, msg, msg->ms_msgsize); - if(error == EASYNC) - { - TAILQ_INSERT_TAIL(&port->mp_msgq, msg, ms_node); - msg->ms_flags |= MSGF_QUEUED; - /** - * Shouldn't need this check, we are always waiting - */ - if(port->mp_flags & MSGPORTF_WAITING) - { - lwkt_schedule(td); - } - } -#ifdef DEBUG - printf("async return error %d\n", error); -#endif - } - - /** - * XXX this is a temporary hack until the kernel changes to implement - * the desired asynchronous goals. - * - * The current asynchronous messaging systemcall interface that sendsys - * uses has some potential security issues and is limited to use by the - * superuser only. Synchronous messages are allowed by anyone. Sendsys - * returns EPERM in the case where you are not the superuser but tried to - * send an asynchonous message. - * - * If you are not the super user then the system call will be made again, - * but without MSGF_ASYNC set. - */ - if(error != EASYNC && error == EPERM) - { - msg->ms_flags &= ~MSGF_ASYNC; -#ifdef DEBUG - printf("Warning, only super user can send asynchonous system messages\n"); -#endif - } - - /** - * The message is synchronous. Send it sychronously. - */ - if((msg->ms_flags & MSGF_ASYNC) == 0) - { - error = sendsys(NULL, msg, msg->ms_msgsize); - msg->ms_flags |= MSGF_DONE; - } - - return(error); -} - -void * -lwkt_syswaitport(lwkt_msg_t msg) -{ - lwkt_msg_t rmsg; - - /** - * Block awaiting a return from the kernel. - */ - for(rmsg = (lwkt_msg_t)sendsys(NULL, NULL, -1); rmsg != msg; ) - { - usleep(1000000 / 10); - rmsg = (lwkt_msg_t)sendsys(NULL, NULL, -1); -#ifdef DEBUG - printf(" rmsg %p\n", rmsg); -#endif - } - - return msg; -} - -/************************************************************************ - * THREAD FUNCTIONS * - ************************************************************************/ -/* - * XXX Temporary function that provides a mechanism to return an asynchronous - * message completed by the kernel to be returned to the port it originated - * from. - */ -static -void -sysport_loop(void *dummy) -{ - lwkt_msg_t msg; - - for(;;) - { - msg = lwkt_waitport(&curthread->td_msgport, NULL); - - msg = lwkt_syswaitport(msg); - - /** - * The message was asynchronous - */ - if(msg->ms_flags & MSGF_ASYNC) - { - lwkt_replymsg(msg, msg->ms_error); - } - else - { - msg->ms_flags |= MSGF_DONE; - } - } -} diff --git a/lib/libcaps/sysport.h b/lib/libcaps/sysport.h deleted file mode 100644 index 9aaf57d0ea..0000000000 --- a/lib/libcaps/sysport.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/sysport.h,v 1.1 2003/12/04 22:06:19 dillon Exp $ - */ - -#ifndef _SYSPORT_H_ -#define _SYSPORT_H_ - -struct lwkt_port; - -extern struct lwkt_port *sysport; - -void sysport_init(void); - -#endif /* _SYSPORT_H_ */ diff --git a/lib/libcaps/thread.h b/lib/libcaps/thread.h deleted file mode 100644 index 2740075b2e..0000000000 --- a/lib/libcaps/thread.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * THREAD.H - * - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/thread.h,v 1.4 2004/10/18 17:54:35 eirikn Exp $ - */ - -#ifndef _LIBCAPS_THREAD_H_ -#define _LIBCAPS_THREAD_H_ - -#define LWKT_THREAD_STACK 65536 - -struct thread; - -struct md_thread { - -}; - -extern void *libcaps_alloc_stack(int); -extern void libcaps_free_stack(void *, int); -extern int tsleep(struct thread *, int, const char *, int); -extern void lwkt_start_threading(struct thread *); -extern void cpu_init_thread(struct thread *); -extern void cpu_set_thread_handler(struct thread *, void (*)(void), void (*)(void *), void *); -extern void kthread_exit(void) __dead2; -extern void cpu_thread_exit(void) __dead2; - -/* - * User overloads of lwkt_* - * Unfortunately C doesn't support function overloading. - * XXX we need some strong weak magic here.... - */ -struct globaldata; -void lwkt_user_gdinit(struct globaldata *); - -extern int hz; - -#endif - diff --git a/lib/libcaps/uthread.c b/lib/libcaps/uthread.c deleted file mode 100644 index 3ca601c6cf..0000000000 --- a/lib/libcaps/uthread.c +++ /dev/null @@ -1,187 +0,0 @@ -/* - * Copyright (c) 2003 Galen Sampson - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/lib/libcaps/uthread.c,v 1.5 2004/07/29 08:55:02 dillon Exp $ - */ - -/* - * Each cpu in a system has its own self-contained light weight kernel - * thread scheduler, which means that generally speaking we only need - * to use a critical section to avoid problems. Foreign thread - * scheduling is queued via (async) IPIs. - */ - -#include "defs.h" - -void cpu_lwkt_switch(thread_t); - -/* - * system message port for the system call interface - */ -lwkt_port_t sysport; - -static void -lwkt_idleloop(void *dummy) -{ - globaldata_t gd = mycpu; - - DBPRINTF(("idlestart cpu %d pri %d (should be < 32) mpcount %d (should be 0)\n", - gd->gd_cpuid, curthread->td_pri, curthread->td_mpcount)); - - gd->gd_pid = getpid(); - - for (;;) { - /* - * If only our 'main' thread is left, schedule it. - */ - if (gd->gd_num_threads == gd->gd_sys_threads) { - int i; - globaldata_t tgd; - - for (i = 0; i < ncpus; ++i) { - tgd = globaldata_find(i); - if (tgd->gd_num_threads != tgd->gd_sys_threads) - break; - } - if (i == ncpus && (main_td.td_flags & TDF_RUNQ) == 0) - lwkt_schedule(&main_td); - } - - /* - * Wait for an interrupt, aka wait for a signal or an upcall to - * occur, then switch away. - */ - crit_enter(); - if (gd->gd_runqmask || (curthread->td_flags & TDF_IDLE_NOHLT)) { - curthread->td_flags &= ~TDF_IDLE_NOHLT; - } else { - printf("cpu %d halting\n", gd->gd_cpuid); - cpu_halt(); - printf("cpu %d resuming\n", gd->gd_cpuid); - } - crit_exit(); - lwkt_switch(); - } -} - -/* - * Userland override of lwkt_init_thread. The only difference is - * the manipulation of gd->gd_num_threads. - */ -static void -lwkt_init_thread_remote(void *arg) -{ - thread_t td = arg; - globaldata_t gd = td->td_gd; - - printf("init_thread_remote td %p on cpu %d\n", td, gd->gd_cpuid); - - TAILQ_INSERT_TAIL(&gd->gd_tdallq, td, td_allq); - ++gd->gd_num_threads; - if (td->td_flags & TDF_SYSTHREAD) - ++gd->gd_sys_threads; -} - -void -lwkt_init_thread(thread_t td, void *stack, int stksize, int flags, - struct globaldata *gd) -{ - bzero(td, sizeof(struct thread)); - td->td_kstack = stack; - td->td_kstack_size = stksize; - td->td_flags |= flags; - td->td_gd = gd; - td->td_pri = TDPRI_KERN_DAEMON + TDPRI_CRIT; - lwkt_initport(&td->td_msgport, td); - cpu_init_thread(td); - if (td == &gd->gd_idlethread) { - TAILQ_INSERT_TAIL(&gd->gd_tdallq, td, td_allq); - /* idle thread is not counted in gd_num_threads */ - } else if (gd == mycpu) { - crit_enter(); - TAILQ_INSERT_TAIL(&gd->gd_tdallq, td, td_allq); - ++gd->gd_num_threads; - if (td->td_flags & TDF_SYSTHREAD) - ++gd->gd_sys_threads; - crit_exit(); - } else { - lwkt_send_ipiq(gd, lwkt_init_thread_remote, td); - } -} - -/* - * Userland override of lwkt_exit. The only difference is - * the manipulation of gd->gd_num_threads; - */ -void -lwkt_exit(void) -{ - thread_t td = curthread; - globaldata_t gd = mycpu; - - if (td->td_flags & TDF_VERBOSE) - printf("kthread %p %s has exited\n", td, td->td_comm); - crit_enter(); - lwkt_deschedule_self(td); - ++gd->gd_tdfreecount; - if (td->td_flags & TDF_SYSTHREAD) - --gd->gd_sys_threads; - --gd->gd_num_threads; - TAILQ_INSERT_TAIL(&gd->gd_tdfreeq, td, td_threadq); - cpu_thread_exit(); -} - -/* - * Userland override of lwkt_gdinit. Called from mi_gdinit(). Note that - * critical sections do not work until lwkt_init_thread() is called. The - * idle thread will be left in a critical section. - */ -void -lwkt_gdinit(struct globaldata *gd) -{ - int i; - - for (i = 0; i < sizeof(gd->gd_tdrunq)/sizeof(gd->gd_tdrunq[0]); ++i) - TAILQ_INIT(&gd->gd_tdrunq[i]); - gd->gd_runqmask = 0; - gd->gd_curthread = &gd->gd_idlethread; - TAILQ_INIT(&gd->gd_tdallq); - - /* Set up this cpu's idle thread */ - lwkt_init_thread(&gd->gd_idlethread, - libcaps_alloc_stack(LWKT_THREAD_STACK), LWKT_THREAD_STACK, - 0, gd); - cpu_set_thread_handler(&gd->gd_idlethread, lwkt_exit, lwkt_idleloop, NULL); -} - -/* - * Start threading. - */ -void -lwkt_start_threading(thread_t td) -{ - lwkt_switch(); -} - diff --git a/nrelease/gui/etc/defaults/pfi.conf b/nrelease/gui/etc/defaults/pfi.conf index 4f68f0a3b2..cdfaf3bdbc 100644 --- a/nrelease/gui/etc/defaults/pfi.conf +++ b/nrelease/gui/etc/defaults/pfi.conf @@ -1,6 +1,5 @@ ####################################################################### # $Id: pfi.conf,v 1.7 2005/02/24 23:23:15 cpressey Exp $ -# $DragonFly: src/nrelease/gui/etc/defaults/pfi.conf,v 1.2 2008/10/23 16:45:36 swildner Exp $ # Defaults for pfi.conf. # A space-separated list of what services to restart when we are done @@ -54,7 +53,7 @@ pfi_script="" pfi_run="" # What transport layer the DFUI in the installer should use. Valid -# values are currently "caps", "npipe", and "tcp". +# values are currently "npipe" and "tcp". pfi_dfui_transport="tcp" diff --git a/nrelease/root/etc/defaults/pfi.conf b/nrelease/root/etc/defaults/pfi.conf index 69ecbff7c7..4ff6dba979 100644 --- a/nrelease/root/etc/defaults/pfi.conf +++ b/nrelease/root/etc/defaults/pfi.conf @@ -1,6 +1,5 @@ ####################################################################### # $Id: pfi.conf,v 1.7 2005/02/24 23:23:15 cpressey Exp $ -# $DragonFly: src/nrelease/installer/etc/defaults/pfi.conf,v 1.9 2008/10/23 16:45:36 swildner Exp $ # Defaults for pfi.conf. # A space-separated list of what services to restart when we are done @@ -52,7 +51,7 @@ pfi_script="" pfi_run="" # What transport layer the DFUI in the installer should use. Valid -# values are currently "caps", "npipe", and "tcp". +# values are currently "npipe" and "tcp". pfi_dfui_transport="tcp" diff --git a/sys/conf/files b/sys/conf/files index ba4700d336..776f534a91 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -881,7 +881,6 @@ kern/lwkt_ipiq.c standard kern/lwkt_token.c standard kern/lwkt_msgport.c standard kern/lwkt_serialize.c standard -kern/lwkt_caps.c standard kern/kern_dsched.c standard kern/kern_sensors.c standard kern/kern_spinlock.c standard diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c index b96207f8fc..d0fee0fb82 100644 --- a/sys/kern/init_sysent.c +++ b/sys/kern/init_sysent.c @@ -488,16 +488,16 @@ struct sysent sysent[] = { { AS(varsym_list_args), (sy_call_t *)sys_varsym_list }, /* 452 = varsym_list */ { AS(upc_register_args), (sy_call_t *)sys_upc_register }, /* 453 = upc_register */ { AS(upc_control_args), (sy_call_t *)sys_upc_control }, /* 454 = upc_control */ - { AS(caps_sys_service_args), (sy_call_t *)sys_caps_sys_service }, /* 455 = caps_sys_service */ - { AS(caps_sys_client_args), (sy_call_t *)sys_caps_sys_client }, /* 456 = caps_sys_client */ - { AS(caps_sys_close_args), (sy_call_t *)sys_caps_sys_close }, /* 457 = caps_sys_close */ - { AS(caps_sys_put_args), (sy_call_t *)sys_caps_sys_put }, /* 458 = caps_sys_put */ - { AS(caps_sys_reply_args), (sy_call_t *)sys_caps_sys_reply }, /* 459 = caps_sys_reply */ - { AS(caps_sys_get_args), (sy_call_t *)sys_caps_sys_get }, /* 460 = caps_sys_get */ - { AS(caps_sys_wait_args), (sy_call_t *)sys_caps_sys_wait }, /* 461 = caps_sys_wait */ - { AS(caps_sys_abort_args), (sy_call_t *)sys_caps_sys_abort }, /* 462 = caps_sys_abort */ - { AS(caps_sys_getgen_args), (sy_call_t *)sys_caps_sys_getgen }, /* 463 = caps_sys_getgen */ - { AS(caps_sys_setgen_args), (sy_call_t *)sys_caps_sys_setgen }, /* 464 = caps_sys_setgen */ + { 0, (sy_call_t *)sys_nosys }, /* 455 = obsolete caps_sys_service */ + { 0, (sy_call_t *)sys_nosys }, /* 456 = obsolete caps_sys_client */ + { 0, (sy_call_t *)sys_nosys }, /* 457 = obsolete caps_sys_close */ + { 0, (sy_call_t *)sys_nosys }, /* 458 = obsolete caps_sys_put */ + { 0, (sy_call_t *)sys_nosys }, /* 459 = obsolete caps_sys_reply */ + { 0, (sy_call_t *)sys_nosys }, /* 460 = obsolete caps_sys_get */ + { 0, (sy_call_t *)sys_nosys }, /* 461 = obsolete caps_sys_wait */ + { 0, (sy_call_t *)sys_nosys }, /* 462 = obsolete caps_sys_abort */ + { 0, (sy_call_t *)sys_nosys }, /* 463 = obsolete caps_sys_getgen */ + { 0, (sy_call_t *)sys_nosys }, /* 464 = obsolete caps_sys_setgen */ { AS(exec_sys_register_args), (sy_call_t *)sys_exec_sys_register }, /* 465 = exec_sys_register */ { AS(exec_sys_unregister_args), (sy_call_t *)sys_exec_sys_unregister }, /* 466 = exec_sys_unregister */ { AS(sys_checkpoint_args), (sy_call_t *)sys_sys_checkpoint }, /* 467 = sys_checkpoint */ diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c index 5d99503682..b4019cb506 100644 --- a/sys/kern/kern_exit.c +++ b/sys/kern/kern_exit.c @@ -64,7 +64,6 @@ #include #include #include -#include #include #include #include @@ -302,8 +301,6 @@ exit1(int rv) /* NOT REACHED */ } - caps_exit(lp->lwp_thread); - /* are we a task leader? */ if (p == p->p_leader) { struct kill_args killArgs; diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c index b8ea0ea0ad..3a9274b562 100644 --- a/sys/kern/kern_fork.c +++ b/sys/kern/kern_fork.c @@ -37,7 +37,6 @@ * * @(#)kern_fork.c 8.6 (Berkeley) 4/8/94 * $FreeBSD: src/sys/kern/kern_fork.c,v 1.72.2.14 2003/06/26 04:15:10 silby Exp $ - * $DragonFly: src/sys/kern/kern_fork.c,v 1.77 2008/05/18 20:02:02 nth Exp $ */ #include "opt_ktrace.h" @@ -56,7 +55,6 @@ #include #include #include -#include #include #include @@ -685,7 +683,6 @@ lwp_fork(struct lwp *origlp, struct proc *destproc, int flags) * and make the child ready to run. */ cpu_fork(origlp, lp, flags); - caps_fork(origlp->lwp_thread, lp->lwp_thread); kqueue_init(&lp->lwp_kqueue, destproc->p_fd); /* diff --git a/sys/kern/lwkt_caps.c b/sys/kern/lwkt_caps.c deleted file mode 100644 index cc9321462e..0000000000 --- a/sys/kern/lwkt_caps.c +++ /dev/null @@ -1,1140 +0,0 @@ -/* - * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved. - * - * This code is derived from software contributed to The DragonFly Project - * by Matthew Dillon - * - * 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. Neither the name of The DragonFly Project nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific, prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * ``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 - * COPYRIGHT HOLDERS OR CONTRIBUTORS 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. - * - * $DragonFly: src/sys/kern/lwkt_caps.c,v 1.13 2007/02/26 21:41:08 corecode Exp $ - */ - -/* - * This module implements the DragonFly LWKT IPC rendezvous and message - * passing API which operates between userland processes, between userland - * threads, and between userland processes and kernel threads. This API - * is known as the CAPS interface. - * - * Generally speaking this module abstracts the LWKT message port interface - * into userland Clients and Servers rendezvous through ports named - * by or wildcarded by (name,uid,gid). The kernel provides system calls - * which may be assigned to the mp_* fields in a userland-supplied - * kernel-managed port, and a registration interface which associates an - * upcall with a userland port. The kernel tracks authentication information - * and deals with connection failures by automatically replying to unreplied - * messages. - * - * From the userland perspective a client/server connection involves two - * message ports on the client and two message ports on the server. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include -#include - -static int caps_process_msg(caps_kinfo_t caps, caps_kmsg_t msg, struct caps_sys_get_args *uap); -static void caps_free(caps_kinfo_t caps); -static void caps_free_msg(caps_kmsg_t msg); -static int caps_name_check(const char *name, size_t len); -static caps_kinfo_t caps_free_msg_mcaps(caps_kmsg_t msg); -static caps_kinfo_t kern_caps_sys_service(const char *name, uid_t uid, - gid_t gid, struct ucred *cred, - int flags, int *error); -static caps_kinfo_t kern_caps_sys_client(const char *name, uid_t uid, - gid_t gid, struct ucred *cred, int flags, int *error); - -#define CAPS_HSIZE 64 -#define CAPS_HMASK (CAPS_HSIZE - 1) - -static caps_kinfo_t caps_hash_ary[CAPS_HSIZE]; -static int caps_waitsvc; - -MALLOC_DEFINE(M_CAPS, "caps", "caps IPC messaging"); - -static int caps_enabled; -SYSCTL_INT(_kern, OID_AUTO, caps_enabled, - CTLFLAG_RW, &caps_enabled, 0, "Enable CAPS"); - -/************************************************************************ - * INLINE SUPPORT FUNCTIONS * - ************************************************************************/ - -static __inline -struct caps_kinfo ** -caps_hash(const char *name, int len) -{ - int hv = 0x7123F4B3; - - while (--len >= 0) - hv = (hv << 5) ^ name[len] ^ (hv >> 23); - return(&caps_hash_ary[(hv ^ (hv >> 16)) & CAPS_HMASK]); -} - -static __inline -void -caps_hold(caps_kinfo_t caps) -{ - ++caps->ci_refs; -} - -static __inline -void -caps_drop(caps_kinfo_t caps) -{ - if (--caps->ci_refs == 0) - caps_free(caps); -} - -/************************************************************************ - * STATIC SUPPORT FUNCTIONS * - ************************************************************************/ - -static -caps_kinfo_t -caps_find(const char *name, int len, uid_t uid, gid_t gid) -{ - caps_kinfo_t caps; - struct caps_kinfo **chash; - - chash = caps_hash(name, len); - for (caps = *chash; caps; caps = caps->ci_hnext) { - if ((uid == (uid_t)-1 || uid == caps->ci_uid) && - (gid == (gid_t)-1 || gid == caps->ci_gid) && - len == caps->ci_namelen && - bcmp(name, caps->ci_name, len) == 0 - ) { - caps_hold(caps); - break; - } - } - return(caps); -} - -static -caps_kinfo_t -caps_find_id(thread_t td, int id) -{ - caps_kinfo_t caps; - - for (caps = td->td_caps; caps; caps = caps->ci_tdnext) { - if (caps->ci_id == id) { - caps_hold(caps); - break; - } - } - return(caps); -} - -static -caps_kinfo_t -caps_alloc(thread_t td, const char *name, int len, uid_t uid, gid_t gid, - int flags, caps_type_t type) -{ - struct caps_kinfo **chash; - caps_kinfo_t caps; - caps_kinfo_t ctmp; - - caps = kmalloc(offsetof(struct caps_kinfo, ci_name[len+1]), - M_CAPS, M_WAITOK|M_ZERO); - TAILQ_INIT(&caps->ci_msgpendq); - TAILQ_INIT(&caps->ci_msguserq); - caps->ci_uid = uid; /* -1 == not registered for uid search */ - caps->ci_gid = gid; /* -1 == not registered for gid search */ - caps->ci_type = type; - caps->ci_refs = 1; /* CAPKF_TDLIST reference */ - caps->ci_namelen = len; - caps->ci_flags = flags; - bcopy(name, caps->ci_name, len + 1); - if (type == CAPT_SERVICE) { - chash = caps_hash(caps->ci_name, len); - caps->ci_hnext = *chash; - *chash = caps; - caps->ci_flags |= CAPKF_HLIST; - } - if (td->td_caps) { - caps->ci_id = td->td_caps->ci_id + 1; - if (caps->ci_id < 0) { - /* - * It is virtually impossible for this case to occur. - */ - caps->ci_id = 1; - while ((ctmp = caps_find_id(td, caps->ci_id)) != NULL) { - caps_drop(ctmp); - ++caps->ci_id; - } - } - } else { - caps->ci_id = 1; - } - caps->ci_flags |= CAPKF_TDLIST; - caps->ci_tdnext = td->td_caps; - caps->ci_td = td; - td->td_caps = caps; - return(caps); -} - -static -caps_kmsg_t -caps_alloc_msg(caps_kinfo_t caps) -{ - caps_kmsg_t msg; - - msg = kmalloc(sizeof(struct caps_kmsg), M_CAPS, M_WAITOK|M_ZERO); - msg->km_msgid.c_id = (off_t)(uintptr_t)msg; - return(msg); -} - -static -caps_kmsg_t -caps_find_msg(caps_kinfo_t caps, off_t msgid) -{ - caps_kmsg_t msg; - - TAILQ_FOREACH(msg, &caps->ci_msguserq, km_node) { - if (msg->km_msgid.c_id == msgid) - return(msg); - } - TAILQ_FOREACH(msg, &caps->ci_msgpendq, km_node) { - if (msg->km_msgid.c_id == msgid) - return(msg); - } - return(NULL); -} - -static -caps_kinfo_t -caps_load_ccr(caps_kinfo_t caps, caps_kmsg_t msg, struct lwp *lp, - void *udata, int ubytes) -{ - struct ucred *cr = lp ? lp->lwp_thread->td_ucred : proc0.p_ucred; - caps_kinfo_t rcaps; - int i; - - /* - * replace km_mcaps with new VM state, return the old km_mcaps. The - * caller is expected to drop the rcaps ref count on return so we do - * not do it ourselves. - */ - rcaps = caps_free_msg_mcaps(msg); /* can be NULL */ - caps_hold(caps); - msg->km_mcaps = caps; - xio_init_ubuf(&msg->km_xio, udata, ubytes, XIOF_READ); - - msg->km_ccr.pid = lp ? lp->lwp_proc->p_pid : -1; - msg->km_ccr.uid = cr->cr_ruid; - msg->km_ccr.euid = cr->cr_uid; - msg->km_ccr.gid = cr->cr_rgid; - msg->km_ccr.ngroups = MIN(cr->cr_ngroups, CAPS_MAXGROUPS); - for (i = 0; i < msg->km_ccr.ngroups; ++i) - msg->km_ccr.groups[i] = cr->cr_groups[i]; - return(rcaps); -} - -static void -caps_dequeue_msg(caps_kinfo_t caps, caps_kmsg_t msg) -{ - if (msg->km_flags & CAPKMF_ONUSERQ) - TAILQ_REMOVE(&caps->ci_msguserq, msg, km_node); - if (msg->km_flags & CAPKMF_ONPENDQ) - TAILQ_REMOVE(&caps->ci_msgpendq, msg, km_node); - msg->km_flags &= ~(CAPKMF_ONPENDQ|CAPKMF_ONUSERQ); -} - -static void -caps_put_msg(caps_kinfo_t caps, caps_kmsg_t msg, caps_msg_state_t state) -{ - KKASSERT((msg->km_flags & (CAPKMF_ONUSERQ|CAPKMF_ONPENDQ)) == 0); - - msg->km_flags |= CAPKMF_ONPENDQ; - msg->km_flags &= ~CAPKMF_PEEKED; - msg->km_state = state; - TAILQ_INSERT_TAIL(&caps->ci_msgpendq, msg, km_node); - - /* - * Instead of waking up the service for both new messages and disposals, - * just wakeup the service for new messages and it will process the - * previous disposal in the same loop, reducing the number of context - * switches required to run an IPC. - */ - if (state != CAPMS_DISPOSE) - wakeup(caps); - caps_drop(caps); -} - -/* - * caps_free_msg_mcaps() - */ -static -caps_kinfo_t -caps_free_msg_mcaps(caps_kmsg_t msg) -{ - caps_kinfo_t mcaps; - - mcaps = msg->km_mcaps; /* may be NULL */ - msg->km_mcaps = NULL; - if (msg->km_xio.xio_npages) - xio_release(&msg->km_xio); - return(mcaps); -} - -/* - * caps_free_msg() - * - * Free a caps placeholder message. The message must not be on any queues. - */ -static void -caps_free_msg(caps_kmsg_t msg) -{ - caps_kinfo_t rcaps; - - if ((rcaps = caps_free_msg_mcaps(msg)) != NULL) - caps_drop(rcaps); - kfree(msg, M_CAPS); -} - -/* - * Validate the service name - */ -static int -caps_name_check(const char *name, size_t len) -{ - size_t i; - char c; - - for (i = len - 1; i >= 0; --i) { - c = name[i]; - if (c >= '0' && c <= '9') - continue; - if (c >= 'a' && c <= 'z') - continue; - if (c >= 'A' && c <= 'Z') - continue; - if (c == '_' || c == '.') - continue; - return(EINVAL); - } - return(0); -} - -/* - * caps_term() - * - * Terminate portions of a caps info structure. This is used to close - * an end-point or to flush particular messages on an end-point. - * - * This function should not be called with CAPKF_TDLIST unless the caller - * has an additional hold on the caps structure. - */ -static void -caps_term(caps_kinfo_t caps, int flags, caps_kinfo_t cflush) -{ - struct thread *td = curthread; - struct caps_kinfo **scan; - caps_kmsg_t msg; - - if (flags & CAPKF_TDLIST) - caps->ci_flags |= CAPKF_CLOSED; - - if (flags & CAPKF_FLUSH) { - int mflags; - struct caps_kmsg_queue tmpuserq; - struct caps_kmsg_queue tmppendq; - caps_kinfo_t rcaps; - - TAILQ_INIT(&tmpuserq); - TAILQ_INIT(&tmppendq); - - while ((msg = TAILQ_FIRST(&caps->ci_msgpendq)) != NULL || - (msg = TAILQ_FIRST(&caps->ci_msguserq)) != NULL - ) { - mflags = msg->km_flags & (CAPKMF_ONUSERQ|CAPKMF_ONPENDQ); - caps_dequeue_msg(caps, msg); - - if (cflush && msg->km_mcaps != cflush) { - if (mflags & CAPKMF_ONUSERQ) - TAILQ_INSERT_TAIL(&tmpuserq, msg, km_node); - else - TAILQ_INSERT_TAIL(&tmppendq, msg, km_node); - } else { - /* - * Dispose of the message. If the received message is a - * request we must reply it. If the received message is - * a reply we must return it for disposal. If the - * received message is a disposal request we simply free it. - */ - switch(msg->km_state) { - case CAPMS_REQUEST: - case CAPMS_REQUEST_RETRY: - rcaps = caps_load_ccr(caps, msg, td->td_lwp, NULL, 0); - if (rcaps->ci_flags & CAPKF_CLOSED) { - /* - * can't reply, if we never read the message (its on - * the pending queue), or if we are closed ourselves, - * we can just free the message. Otherwise we have - * to send ourselves a disposal request (multi-threaded - * services have to deal with disposal requests for - * messages that might be in progress). - */ - if ((caps->ci_flags & CAPKF_CLOSED) || - (mflags & CAPKMF_ONPENDQ) - ) { - caps_free_msg(msg); - caps_drop(rcaps); - } else { - caps_drop(rcaps); - caps_hold(caps); /* for message */ - caps_put_msg(caps, msg, CAPMS_DISPOSE); - } - } else { - /* - * auto-reply to the originator. rcaps already - * has a dangling hold so we do not have to hold it - * again. - */ - caps_put_msg(rcaps, msg, CAPMS_REPLY); - } - break; - case CAPMS_REPLY: - case CAPMS_REPLY_RETRY: - rcaps = caps_load_ccr(caps, msg, td->td_lwp, NULL, 0); - if (caps == rcaps || (rcaps->ci_flags & CAPKF_CLOSED)) { - caps_free_msg(msg); /* degenerate disposal case */ - caps_drop(rcaps); - } else { - caps_put_msg(rcaps, msg, CAPMS_DISPOSE); - } - break; - case CAPMS_DISPOSE: - caps_free_msg(msg); - break; - } - } - } - while ((msg = TAILQ_FIRST(&tmpuserq)) != NULL) { - TAILQ_REMOVE(&tmpuserq, msg, km_node); - TAILQ_INSERT_TAIL(&caps->ci_msguserq, msg, km_node); - msg->km_flags |= CAPKMF_ONUSERQ; - } - while ((msg = TAILQ_FIRST(&tmppendq)) != NULL) { - TAILQ_REMOVE(&tmppendq, msg, km_node); - TAILQ_INSERT_TAIL(&caps->ci_msgpendq, msg, km_node); - msg->km_flags |= CAPKMF_ONPENDQ; - } - } - if ((flags & CAPKF_HLIST) && (caps->ci_flags & CAPKF_HLIST)) { - for (scan = caps_hash(caps->ci_name, caps->ci_namelen); - *scan != caps; - scan = &(*scan)->ci_hnext - ) { - KKASSERT(*scan != NULL); - } - *scan = caps->ci_hnext; - caps->ci_hnext = (void *)-1; - caps->ci_flags &= ~CAPKF_HLIST; - } - if ((flags & CAPKF_TDLIST) && (caps->ci_flags & CAPKF_TDLIST)) { - for (scan = &caps->ci_td->td_caps; - *scan != caps; - scan = &(*scan)->ci_tdnext - ) { - KKASSERT(*scan != NULL); - } - *scan = caps->ci_tdnext; - caps->ci_flags &= ~CAPKF_TDLIST; - caps->ci_tdnext = (void *)-1; - caps->ci_td = NULL; - caps_drop(caps); - } - if ((flags & CAPKF_RCAPS) && (caps->ci_flags & CAPKF_RCAPS)) { - caps_kinfo_t ctmp; - - caps->ci_flags &= ~CAPKF_RCAPS; - if ((ctmp = caps->ci_rcaps)) { - caps->ci_rcaps = NULL; - caps_term(ctmp, CAPKF_FLUSH, caps); - caps_drop(ctmp); - } - } -} - -static void -caps_free(caps_kinfo_t caps) -{ - KKASSERT(TAILQ_EMPTY(&caps->ci_msgpendq)); - KKASSERT(TAILQ_EMPTY(&caps->ci_msguserq)); - KKASSERT((caps->ci_flags & (CAPKF_HLIST|CAPKF_TDLIST)) == 0); - kfree(caps, M_CAPS); -} - -/************************************************************************ - * PROCESS SUPPORT FUNCTIONS * - ************************************************************************/ - -/* - * Create dummy entries in p2 so we can return the appropriate - * error code. Robust userland code will check the error for a - * forked condition and reforge the connection. - */ -void -caps_fork(struct thread *td1, struct thread *td2) -{ - caps_kinfo_t caps1; - caps_kinfo_t caps2; - - /* - * Create dummy entries with the same id's as the originals. Note - * that service entries are not re-added to the hash table. The - * dummy entries return an ENOTCONN error allowing userland code to - * detect that a fork occured. Userland must reconnect to the service. - */ - for (caps1 = td1->td_caps; caps1; caps1 = caps1->ci_tdnext) { - if (caps1->ci_flags & CAPF_NOFORK) - continue; - caps2 = caps_alloc(td2, - caps1->ci_name, caps1->ci_namelen, - caps1->ci_uid, caps1->ci_gid, - caps1->ci_flags & CAPF_UFLAGS, CAPT_FORKED); - caps2->ci_id = caps1->ci_id; - } - - /* - * Reverse the list order to maintain highest-id-first - */ - caps2 = td2->td_caps; - td2->td_caps = NULL; - while (caps2) { - caps1 = caps2->ci_tdnext; - caps2->ci_tdnext = td2->td_caps; - td2->td_caps = caps2; - caps2 = caps1; - } -} - -void -caps_exit(struct thread *td) -{ - caps_kinfo_t caps; - - while ((caps = td->td_caps) != NULL) { - caps_hold(caps); - caps_term(caps, CAPKF_TDLIST|CAPKF_HLIST|CAPKF_FLUSH|CAPKF_RCAPS, NULL); - caps_drop(caps); - } -} - -/************************************************************************ - * SYSTEM CALLS * - ************************************************************************/ - -/* - * caps_sys_service(name, uid, gid, upcid, flags); - * - * Create an IPC service using the specified name, uid, gid, and flags. - * Either uid or gid can be -1, but not both. The port identifier is - * returned. - * - * upcid can either be an upcall or a kqueue identifier (XXX) - * - * MPALMOSTSAFE - */ -int -sys_caps_sys_service(struct caps_sys_service_args *uap) -{ - struct ucred *cred = curthread->td_ucred; - char name[CAPS_MAXNAMELEN]; - caps_kinfo_t caps; - size_t len; - int error; - - if (caps_enabled == 0) - return(EOPNOTSUPP); - if ((error = copyinstr(uap->name, name, CAPS_MAXNAMELEN, &len)) != 0) - return(error); - if ((ssize_t)--len <= 0) - return(EINVAL); - get_mplock(); - - if ((error = caps_name_check(name, len)) == 0) { - caps = kern_caps_sys_service(name, uap->uid, uap->gid, cred, - uap->flags & CAPF_UFLAGS, &error); - if (caps) - uap->sysmsg_result = caps->ci_id; - } - rel_mplock(); - return(error); -} - -/* - * caps_sys_client(name, uid, gid, upcid, flags); - * - * Create an IPC client connected to the specified service. Either uid or gid - * may be -1, indicating a wildcard, but not both. The port identifier is - * returned. - * - * upcid can either be an upcall or a kqueue identifier (XXX) - * - * MPALMOSTSAFE - */ -int -sys_caps_sys_client(struct caps_sys_client_args *uap) -{ - struct ucred *cred = curthread->td_ucred; - char name[CAPS_MAXNAMELEN]; - caps_kinfo_t caps; - size_t len; - int error; - - if (caps_enabled == 0) - return(EOPNOTSUPP); - if ((error = copyinstr(uap->name, name, CAPS_MAXNAMELEN, &len)) != 0) - return(error); - if ((ssize_t)--len <= 0) - return(EINVAL); - get_mplock(); - - if ((error = caps_name_check(name, len)) == 0) { - caps = kern_caps_sys_client(name, uap->uid, uap->gid, cred, - uap->flags & CAPF_UFLAGS, &error); - if (caps) - uap->sysmsg_result = caps->ci_id; - } - rel_mplock(); - return(error); -} - -/* - * MPALMOSTSAFE - */ -int -sys_caps_sys_close(struct caps_sys_close_args *uap) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - int error; - - get_mplock(); - - if ((caps = caps_find_id(td, uap->portid)) != NULL) { - caps_term(caps, CAPKF_TDLIST|CAPKF_HLIST|CAPKF_FLUSH|CAPKF_RCAPS, - NULL); - caps_drop(caps); - error = 0; - } else { - error = EINVAL; - } - rel_mplock(); - return(error); -} - -/* - * MPALMOSTSAFE - */ -int -sys_caps_sys_setgen(struct caps_sys_setgen_args *uap) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - int error; - - get_mplock(); - - if ((caps = caps_find_id(td, uap->portid)) != NULL) { - if (caps->ci_type == CAPT_FORKED) { - error = ENOTCONN; - } else { - caps->ci_gen = uap->gen; - error = 0; - } - caps_drop(caps); - } else { - error = EINVAL; - } - rel_mplock(); - return(error); -} - -/* - * MPALMOSTSAFE - */ -int -sys_caps_sys_getgen(struct caps_sys_getgen_args *uap) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - int error; - - get_mplock(); - - if ((caps = caps_find_id(td, uap->portid)) != NULL) { - if (caps->ci_type == CAPT_FORKED) { - error = ENOTCONN; - } else if (caps->ci_rcaps == NULL) { - error = EINVAL; - } else { - uap->sysmsg_result64 = caps->ci_rcaps->ci_gen; - error = 0; - } - caps_drop(caps); - } else { - error = EINVAL; - } - rel_mplock(); - return(error); -} - -/* - * caps_sys_put(portid, msg, msgsize) - * - * Send an opaque message of the specified size to the specified port. This - * function may only be used with a client port. The message id is returned. - * - * MPALMOSTSAFE - */ -int -sys_caps_sys_put(struct caps_sys_put_args *uap) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - caps_kmsg_t msg; - int error; - - if (uap->msgsize < 0) - return(EINVAL); - get_mplock(); - - if ((caps = caps_find_id(td, uap->portid)) == NULL) { - error = EINVAL; - goto done; - } - if (caps->ci_type == CAPT_FORKED) { - error = ENOTCONN; - } else if (caps->ci_rcaps == NULL) { - error = EINVAL; - } else if (caps->ci_cmsgcount > CAPS_MAXINPROG) { - /* - * If this client has queued a large number of messages return - * ENOBUFS. The client must process some replies before it can - * send new messages. The server can also throttle a client by - * holding its replies. XXX allow a server to refuse messages from - * a client. - */ - error = ENOBUFS; - } else { - msg = caps_alloc_msg(caps); - uap->sysmsg_offset = msg->km_msgid.c_id; - - /* - * If the remote end is closed return ENOTCONN immediately, otherwise - * send it to the remote end. - * - * Note: since this is a new message, caps_load_ccr() returns a remote - * caps of NULL. - */ - if (caps->ci_rcaps->ci_flags & CAPKF_CLOSED) { - error = ENOTCONN; - caps_free_msg(msg); - } else { - /* - * new message, load_ccr returns NULL. hold rcaps for put_msg - */ - error = 0; - caps_load_ccr(caps, msg, td->td_lwp, uap->msg, uap->msgsize); - caps_hold(caps->ci_rcaps); - ++caps->ci_cmsgcount; - caps_put_msg(caps->ci_rcaps, msg, CAPMS_REQUEST); /* drops rcaps */ - } - } - caps_drop(caps); -done: - rel_mplock(); - return(error); -} - -/* - * caps_sys_reply(portid, msg, msgsize, msgid) - * - * Reply to the message referenced by the specified msgid, supplying opaque - * data back to the originator. - * - * MPALMOSTSAFE - */ -int -sys_caps_sys_reply(struct caps_sys_reply_args *uap) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - caps_kinfo_t rcaps; - caps_kmsg_t msg; - int error; - - if (uap->msgsize < 0) - return(EINVAL); - get_mplock(); - - if ((caps = caps_find_id(td, uap->portid)) == NULL) { - error = EINVAL; - goto done; - } - if (caps->ci_type == CAPT_FORKED) { - /* - * The caps structure is just a fork placeholder, tell the caller - * that he has to reconnect. - */ - error = ENOTCONN; - } else if ((msg = caps_find_msg(caps, uap->msgcid)) == NULL) { - /* - * Could not find message being replied to (other side might have - * gone away). - */ - error = EINVAL; - } else if ((msg->km_flags & CAPKMF_ONUSERQ) == 0) { - /* - * Trying to reply to a non-replyable message - */ - error = EINVAL; - } else { - /* - * If the remote end is closed requeue to ourselves for disposal. - * Otherwise send the reply to the other end (the other end will - * return a passive DISPOSE to us when it has eaten the data) - */ - error = 0; - caps_dequeue_msg(caps, msg); - if (msg->km_mcaps->ci_flags & CAPKF_CLOSED) { - caps_drop(caps_load_ccr(caps, msg, td->td_lwp, NULL, 0)); - caps_hold(caps); /* ref for message */ - caps_put_msg(caps, msg, CAPMS_DISPOSE); - } else { - rcaps = caps_load_ccr(caps, msg, td->td_lwp, uap->msg, uap->msgsize); - caps_put_msg(rcaps, msg, CAPMS_REPLY); - } - } - caps_drop(caps); -done: - rel_mplock(); - return(error); -} - -/* - * caps_sys_get(portid, msg, maxsize, msgid, ccr) - * - * Retrieve the next ready message on the port, store its message id in - * uap->msgid and return the length of the message. If the message is too - * large to fit the message id, length, and creds are still returned, but - * the message is not dequeued (the caller is expected to call again with - * a larger buffer or to reply the messageid if it does not want to handle - * the message). - * - * EWOULDBLOCK is returned if no messages are pending. Note that 0-length - * messages are perfectly acceptable so 0 can be legitimately returned. - * - * MPALMOSTSAFE - */ -int -sys_caps_sys_get(struct caps_sys_get_args *uap) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - caps_kmsg_t msg; - int error; - - if (uap->maxsize < 0) - return(EINVAL); - get_mplock(); - - if ((caps = caps_find_id(td, uap->portid)) != NULL) { - if (caps->ci_type == CAPT_FORKED) { - error = ENOTCONN; - } else if ((msg = TAILQ_FIRST(&caps->ci_msgpendq)) == NULL) { - error = EWOULDBLOCK; - } else { - error = caps_process_msg(caps, msg, uap); - } - caps_drop(caps); - } else { - error = EINVAL; - } - rel_mplock(); - return(error); -} - -/* - * caps_sys_wait(portid, msg, maxsize, msgid, ccr) - * - * Retrieve the next ready message on the port, store its message id in - * uap->msgid and return the length of the message. If the message is too - * large to fit the message id, length, and creds are still returned, but - * the message is not dequeued (the caller is expected to call again with - * a larger buffer or to reply the messageid if it does not want to handle - * the message). - * - * This function blocks until interrupted or a message is received. - * Note that 0-length messages are perfectly acceptable so 0 can be - * legitimately returned. - * - * MPALMOSTSAFE - */ -int -sys_caps_sys_wait(struct caps_sys_wait_args *uap) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - caps_kmsg_t msg; - int error; - - if (uap->maxsize < 0) - return(EINVAL); - get_mplock(); - - if ((caps = caps_find_id(td, uap->portid)) != NULL) { - if (caps->ci_type == CAPT_FORKED) { - error = ENOTCONN; - } else { - error = 0; - while ((msg = TAILQ_FIRST(&caps->ci_msgpendq)) == NULL) { - if ((error = tsleep(caps, PCATCH, "caps", 0)) != 0) - break; - } - if (error == 0) { - error = caps_process_msg(caps, msg, - (struct caps_sys_get_args *)uap); - } - } - caps_drop(caps); - } else { - error = EINVAL; - } - rel_mplock(); - return(error); -} - -static int -caps_process_msg(caps_kinfo_t caps, caps_kmsg_t msg, - struct caps_sys_get_args *uap) -{ - struct thread *td = curthread; - int error = 0; - int msgsize; - caps_kinfo_t rcaps; - - msg->km_flags |= CAPKMF_PEEKED; - msgsize = msg->km_xio.xio_bytes; - if (msgsize <= uap->maxsize) - caps_dequeue_msg(caps, msg); - - if (msg->km_xio.xio_bytes != 0) { - error = xio_copy_xtou(&msg->km_xio, 0, uap->msg, - min(msg->km_xio.xio_bytes, uap->maxsize)); - if (error) { - if (msg->km_mcaps->ci_td && msg->km_mcaps->ci_td->td_proc) { - kprintf("xio_copy_xtou: error %d from proc %d\n", - error, msg->km_mcaps->ci_td->td_proc->p_pid); - } - if (msgsize > uap->maxsize) - caps_dequeue_msg(caps, msg); - msgsize = 0; - error = 0; - } - } - - if (uap->msgid) - error = copyout(&msg->km_msgid, uap->msgid, sizeof(msg->km_msgid)); - if (uap->ccr) - error = copyout(&msg->km_ccr, uap->ccr, sizeof(msg->km_ccr)); - if (error == 0) - uap->sysmsg_result = msgsize; - - /* - * If the message was dequeued we must deal with it. - */ - if (msgsize <= uap->maxsize) { - switch(msg->km_state) { - case CAPMS_REQUEST: - case CAPMS_REQUEST_RETRY: - TAILQ_INSERT_TAIL(&caps->ci_msguserq, msg, km_node); - msg->km_flags |= CAPKMF_ONUSERQ; - break; - case CAPMS_REPLY: - case CAPMS_REPLY_RETRY: - --caps->ci_cmsgcount; - rcaps = caps_load_ccr(caps, msg, td->td_lwp, NULL, 0); - if (caps == rcaps || (rcaps->ci_flags & CAPKF_CLOSED)) { - /* degenerate disposal case */ - caps_free_msg(msg); - caps_drop(rcaps); - } else { - caps_put_msg(rcaps, msg, CAPMS_DISPOSE); - } - break; - case CAPMS_DISPOSE: - caps_free_msg(msg); - break; - } - } - return(error); -} - -/* - * caps_sys_abort(portid, msgcid, flags) - * - * Abort a previously sent message. You must still wait for the message - * to be returned after sending the abort request. This function will - * return the appropriate CAPS_ABORT_* code depending on what it had - * to do. - * - * MPALMOSTSAFE - */ -int -sys_caps_sys_abort(struct caps_sys_abort_args *uap) -{ - uap->sysmsg_result = CAPS_ABORT_NOTIMPL; - return(0); -} - -/* - * KERNEL SYSCALL SEPARATION SUPPORT FUNCTIONS - */ - -static -caps_kinfo_t -kern_caps_sys_service(const char *name, uid_t uid, gid_t gid, - struct ucred *cred, int flags, int *error) -{ - struct thread *td = curthread; - caps_kinfo_t caps; - int len; - - len = strlen(name); - - /* - * Make sure we can use the uid and gid - */ - if (cred) { - if (cred->cr_uid != 0 && uid != (uid_t)-1 && cred->cr_uid != uid) { - *error = EPERM; - return(NULL); - } - if (cred->cr_uid != 0 && gid != (gid_t)-1 && !groupmember(gid, cred)) { - *error = EPERM; - return(NULL); - } - } - - /* - * Handle CAPF_EXCL - */ - if (flags & CAPF_EXCL) { - if ((caps = caps_find(name, strlen(name), uid, gid)) != NULL) { - caps_drop(caps); - *error = EEXIST; - return(NULL); - } - } - - /* - * Create the service - */ - caps = caps_alloc(td, name, len, - uid, gid, flags & CAPF_UFLAGS, CAPT_SERVICE); - wakeup(&caps_waitsvc); - return(caps); -} - -static -caps_kinfo_t -kern_caps_sys_client(const char *name, uid_t uid, gid_t gid, - struct ucred *cred, int flags, int *error) -{ - struct thread *td = curthread; - caps_kinfo_t caps, rcaps; - int len; - - len = strlen(name); - - /* - * Locate the CAPS service (rcaps ref is for caps->ci_rcaps) - */ -again: - if ((rcaps = caps_find(name, len, uid, gid)) == NULL) { - if (flags & CAPF_WAITSVC) { - char cbuf[32]; - ksnprintf(cbuf, sizeof(cbuf), "C%s", name); - *error = tsleep(&caps_waitsvc, PCATCH, cbuf, 0); - if (*error == 0) - goto again; - } else { - *error = ENOENT; - } - return(NULL); - } - - /* - * Check permissions - */ - if (cred) { - *error = EACCES; - if ((flags & CAPF_USER) && (rcaps->ci_flags & CAPF_USER)) { - if (rcaps->ci_uid != (uid_t)-1 && rcaps->ci_uid == cred->cr_uid) - *error = 0; - } - if ((flags & CAPF_GROUP) && (rcaps->ci_flags & CAPF_GROUP)) { - if (rcaps->ci_gid != (gid_t)-1 && groupmember(rcaps->ci_gid, cred)) - *error = 0; - } - if ((flags & CAPF_WORLD) && (rcaps->ci_flags & CAPF_WORLD)) { - *error = 0; - } - if (*error) { - caps_drop(rcaps); - return(NULL); - } - } else { - *error = 0; - } - - /* - * Allocate the client side and connect to the server - */ - caps = caps_alloc(td, name, len, - uid, gid, flags & CAPF_UFLAGS, CAPT_CLIENT); - caps->ci_rcaps = rcaps; - caps->ci_flags |= CAPKF_RCAPS; - return(caps); -} - diff --git a/sys/kern/lwkt_ipiq.c b/sys/kern/lwkt_ipiq.c index 767c3d3817..9972d46443 100644 --- a/sys/kern/lwkt_ipiq.c +++ b/sys/kern/lwkt_ipiq.c @@ -51,7 +51,6 @@ #include #include #include -#include #include #include diff --git a/sys/kern/lwkt_serialize.c b/sys/kern/lwkt_serialize.c index 4e4b8aeafb..4c7f555242 100644 --- a/sys/kern/lwkt_serialize.c +++ b/sys/kern/lwkt_serialize.c @@ -30,8 +30,6 @@ * 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. - * - * $DragonFly: src/sys/kern/lwkt_serialize.c,v 1.18 2008/10/04 14:22:44 swildner Exp $ */ /* * This API provides a fast locked-bus-cycle-based serializer. It's @@ -59,7 +57,6 @@ #include #include #include -#include struct exp_backoff { int backoff; diff --git a/sys/kern/lwkt_thread.c b/sys/kern/lwkt_thread.c index 9962b4b475..5fc20617fa 100644 --- a/sys/kern/lwkt_thread.c +++ b/sys/kern/lwkt_thread.c @@ -50,7 +50,6 @@ #include #include #include -#include #include #include @@ -1709,7 +1708,6 @@ lwkt_exit(void) */ if (td->td_flags & TDF_VERBOSE) kprintf("kthread %p %s has exited\n", td, td->td_comm); - caps_exit(td); biosched_done(td); dsched_exit_thread(td); diff --git a/sys/kern/lwkt_token.c b/sys/kern/lwkt_token.c index 83eada4a0e..95a40ac676 100644 --- a/sys/kern/lwkt_token.c +++ b/sys/kern/lwkt_token.c @@ -56,7 +56,6 @@ #include #include #include -#include #include #include diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c index 013a338f64..1a87132119 100644 --- a/sys/kern/syscalls.c +++ b/sys/kern/syscalls.c @@ -462,16 +462,16 @@ const char *syscallnames[] = { "varsym_list", /* 452 = varsym_list */ "upc_register", /* 453 = upc_register */ "upc_control", /* 454 = upc_control */ - "caps_sys_service", /* 455 = caps_sys_service */ - "caps_sys_client", /* 456 = caps_sys_client */ - "caps_sys_close", /* 457 = caps_sys_close */ - "caps_sys_put", /* 458 = caps_sys_put */ - "caps_sys_reply", /* 459 = caps_sys_reply */ - "caps_sys_get", /* 460 = caps_sys_get */ - "caps_sys_wait", /* 461 = caps_sys_wait */ - "caps_sys_abort", /* 462 = caps_sys_abort */ - "caps_sys_getgen", /* 463 = caps_sys_getgen */ - "caps_sys_setgen", /* 464 = caps_sys_setgen */ + "obs_caps_sys_service", /* 455 = obsolete caps_sys_service */ + "obs_caps_sys_client", /* 456 = obsolete caps_sys_client */ + "obs_caps_sys_close", /* 457 = obsolete caps_sys_close */ + "obs_caps_sys_put", /* 458 = obsolete caps_sys_put */ + "obs_caps_sys_reply", /* 459 = obsolete caps_sys_reply */ + "obs_caps_sys_get", /* 460 = obsolete caps_sys_get */ + "obs_caps_sys_wait", /* 461 = obsolete caps_sys_wait */ + "obs_caps_sys_abort", /* 462 = obsolete caps_sys_abort */ + "obs_caps_sys_getgen", /* 463 = obsolete caps_sys_getgen */ + "obs_caps_sys_setgen", /* 464 = obsolete caps_sys_setgen */ "exec_sys_register", /* 465 = exec_sys_register */ "exec_sys_unregister", /* 466 = exec_sys_unregister */ "sys_checkpoint", /* 467 = sys_checkpoint */ diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master index 8a5a793fed..f5b01d36d7 100644 --- a/sys/kern/syscalls.master +++ b/sys/kern/syscalls.master @@ -631,16 +631,16 @@ 452 STD BSD { int varsym_list(int level, char *buf, int maxsize, int *marker); } 453 STD BSD { int upc_register(struct upcall *upc, void *ctxfunc, void *func, void *data); } 454 STD BSD { int upc_control(int cmd, int upcid, void *data); } -455 STD BSD { int caps_sys_service(const char *name, uid_t uid, gid_t gid, int upcid, int flags); } -456 STD BSD { int caps_sys_client(const char *name, uid_t uid, gid_t gid, int upcid, int flags); } -457 STD BSD { int caps_sys_close(int portid); } -458 STD BSD { off_t caps_sys_put(int portid, void *msg, int msgsize); } -459 STD BSD { int caps_sys_reply(int portid, void *msg, int msgsize, off_t msgcid); } -460 STD BSD { int caps_sys_get(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); } -461 STD BSD { int caps_sys_wait(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); } -462 STD BSD { int caps_sys_abort(int portid, off_t msgcid, int flags); } -463 STD BSD { off_t caps_sys_getgen(int portid); } -464 STD BSD { int caps_sys_setgen(int portid, off_t gen); } +455 OBSOL BSD caps_sys_service +456 OBSOL BSD caps_sys_client +457 OBSOL BSD caps_sys_close +458 OBSOL BSD caps_sys_put +459 OBSOL BSD caps_sys_reply +460 OBSOL BSD caps_sys_get +461 OBSOL BSD caps_sys_wait +462 OBSOL BSD caps_sys_abort +463 OBSOL BSD caps_sys_getgen +464 OBSOL BSD caps_sys_setgen 465 STD BSD { int exec_sys_register(void *entry); } 466 STD BSD { int exec_sys_unregister(int id); } 467 STD BSD { int sys_checkpoint(int type, int fd, pid_t pid, int retval); } diff --git a/sys/sys/caps.h b/sys/sys/caps.h deleted file mode 100644 index ad681bbde5..0000000000 --- a/sys/sys/caps.h +++ /dev/null @@ -1,194 +0,0 @@ -/* - * SYS/CAPS.H - * - * Implements an architecture independant Capability Service API - * - * $DragonFly: src/sys/sys/caps.h,v 1.11 2007/02/26 21:41:08 corecode Exp $ - */ - -#ifndef _SYS_CAPS_H_ -#define _SYS_CAPS_H_ - -#ifndef _SYS_TYPES_H_ -#include -#endif -#ifndef _SYS_MSGPORT_H_ -#include -#endif -#ifndef _SYS_XIO_H_ -#include -#endif - -typedef enum caps_msg_state { - CAPMS_REQUEST, - CAPMS_REQUEST_RETRY, /* internal / FUTURE */ - CAPMS_REPLY, - CAPMS_REPLY_RETRY, /* internal / FUTURE */ - CAPMS_DISPOSE -} caps_msg_state_t; - -typedef struct caps_msgid { - off_t c_id; - caps_msg_state_t c_state; - int c_reserved01; -} *caps_msgid_t; - -typedef enum caps_type { - CAPT_UNKNOWN, CAPT_CLIENT, CAPT_SERVICE, CAPT_REMOTE, CAPT_FORKED -} caps_type_t; - -typedef int64_t caps_gen_t; - -/* - * Note: upper 16 bits reserved for kernel use - */ -#define CAPF_UFLAGS 0xFFFF -#define CAPF_USER 0x0001 -#define CAPF_GROUP 0x0002 -#define CAPF_WORLD 0x0004 -#define CAPF_EXCL 0x0008 -#define CAPF_ANYCLIENT (CAPF_USER|CAPF_GROUP|CAPF_WORLD) -#define CAPF_WCRED 0x0010 /* waiting for cred */ -#define CAPF_NOFORK 0x0020 /* do not create a dummy entry on fork */ -#define CAPF_WAITSVC 0x0040 /* block if service not available */ -/* FUTURE: CAPF_ASYNC - support async services */ -/* FUTURE: CAPF_NOGROUPS - don't bother filling in the groups[] array */ -/* FUTURE: CAPF_TERM - send termination request to existing service */ -/* FUTURE: CAPF_TAKE - take over existing service's connections */ -/* FUTURE: CAPF_DISPOSE_IMM - need immediate dispose wakeups */ - -/* - * Abort codes - */ -#define CAPS_ABORT_NOTIMPL 0 /* abort not implemented, no action */ -#define CAPS_ABORT_RETURNED 1 /* already returned, no action */ -#define CAPS_ABORT_BEFORESERVER 2 /* caught before the server got it */ -#define CAPS_ABORT_ATSERVER 3 /* server had retrieved message */ - -#define CAPF_ABORT_HARD 0x0001 /* rip out from under server (3) */ - -#define CAPS_MAXGROUPS 16 -#define CAPS_MAXNAMELEN 64 -#define CAPS_MAXINPROG 128 - -struct thread; - -typedef struct caps_port { - struct lwkt_port cp_lport; - int cp_portid; /* caps port id */ - int cp_upcallid; /* upcall id */ -} *caps_port_t; - -typedef struct caps_cred { - pid_t pid; - uid_t uid; - uid_t euid; - gid_t gid; - int ngroups; - int cacheid; - gid_t groups[CAPS_MAXGROUPS]; -} *caps_cred_t; - -#if defined(_KERNEL) || defined(_KERNEL_STRUCTURES) - -struct proc; -struct caps_kmsg; - -TAILQ_HEAD(caps_kmsg_queue, caps_kmsg); - -/* - * caps_kinfo - Holds a client or service registration - * - * ci_msgpendq: holds the kernel copy of the message after it has been - * sent to the local port. The message is matched up against - * replies and automatically replied if the owner closes its - * connection. - */ -typedef struct caps_kinfo { - struct lwkt_port ci_lport; /* embedded local port */ - struct caps_kinfo *ci_tdnext; /* per-process list */ - struct caps_kinfo *ci_hnext; /* registration hash table */ - struct thread *ci_td; /* owner */ - struct caps_kmsg_queue ci_msgpendq; /* pending reply (just rcvd) */ - struct caps_kmsg_queue ci_msguserq; /* pending reply (user holds) */ - struct caps_kinfo *ci_rcaps; /* connected to remote */ - int ci_cmsgcount; /* client in-progress msgs */ - int ci_id; - int ci_flags; - int ci_refs; - caps_type_t ci_type; - caps_gen_t ci_gen; - uid_t ci_uid; - gid_t ci_gid; - int ci_namelen; - char ci_name[4]; /* variable length */ - /* ci_name must be last element */ -} *caps_kinfo_t; - -/* note: user flags are held in the low 16 bits */ -#define CAPKF_TDLIST 0x00010000 -#define CAPKF_HLIST 0x00020000 -#define CAPKF_FLUSH 0x00040000 -#define CAPKF_RCAPS 0x00080000 -#define CAPKF_CLOSED 0x00100000 -#define CAPKF_MWAIT 0x00200000 - -/* - * Kernel caps message. The kernel keepps track of messagse received, - * undergoing processing by the service, and returned. User-supplied data - * is copied on reception rather then transmission. - */ -typedef struct caps_kmsg { - TAILQ_ENTRY(caps_kmsg) km_node; - caps_kinfo_t km_mcaps; /* message sender */ - struct xio km_xio; /* mcaps user data */ - struct caps_cred km_ccr; /* caps cred for msg */ - struct caps_msgid km_msgid; - int km_flags; -} *caps_kmsg_t; - -#define km_state km_msgid.c_state - -#define CAPKMF_ONUSERQ 0x0001 -#define CAPKMF_ONPENDQ 0x0002 -#define CAPKMF_REPLY 0x0004 -#define CAPKMF_CDONE 0x0008 -#define CAPKMF_PEEKED 0x0010 -#define CAPKMF_ABORTED 0x0020 - -#endif - -#ifdef _KERNEL - -/* - * kernel support - */ -void caps_exit(struct thread *td); -void caps_fork(struct thread *td1, struct thread *td2); - -#else - -/* - * Userland API (libcaps) - */ -caps_port_t caps_service(const char *, uid_t, gid_t, mode_t, int); -caps_port_t caps_client(const char *, uid_t, gid_t, int); - -/* - * Syscall API - */ -int caps_sys_service(const char *, uid_t, gid_t, int, int); -int caps_sys_client(const char *, uid_t, gid_t, int, int); -off_t caps_sys_put(int, void *, int); -int caps_sys_reply(int, void *, int, off_t); -int caps_sys_get(int, void *, int, caps_msgid_t, caps_cred_t); -int caps_sys_wait(int, void *, int, caps_msgid_t, caps_cred_t); -int caps_sys_abort(int, off_t, int); -int caps_sys_setgen(int, caps_gen_t); -caps_gen_t caps_sys_getgen(int); -int caps_sys_close(int); - -#endif - -#endif - diff --git a/sys/sys/syscall.h b/sys/sys/syscall.h index ed049b483a..51feff82aa 100644 --- a/sys/sys/syscall.h +++ b/sys/sys/syscall.h @@ -294,16 +294,16 @@ #define SYS_varsym_list 452 #define SYS_upc_register 453 #define SYS_upc_control 454 -#define SYS_caps_sys_service 455 -#define SYS_caps_sys_client 456 -#define SYS_caps_sys_close 457 -#define SYS_caps_sys_put 458 -#define SYS_caps_sys_reply 459 -#define SYS_caps_sys_get 460 -#define SYS_caps_sys_wait 461 -#define SYS_caps_sys_abort 462 -#define SYS_caps_sys_getgen 463 -#define SYS_caps_sys_setgen 464 + /* 455 is obsolete caps_sys_service */ + /* 456 is obsolete caps_sys_client */ + /* 457 is obsolete caps_sys_close */ + /* 458 is obsolete caps_sys_put */ + /* 459 is obsolete caps_sys_reply */ + /* 460 is obsolete caps_sys_get */ + /* 461 is obsolete caps_sys_wait */ + /* 462 is obsolete caps_sys_abort */ + /* 463 is obsolete caps_sys_getgen */ + /* 464 is obsolete caps_sys_setgen */ #define SYS_exec_sys_register 465 #define SYS_exec_sys_unregister 466 #define SYS_sys_checkpoint 467 diff --git a/sys/sys/syscall.mk b/sys/sys/syscall.mk index 10a711d404..451f0c6dbe 100644 --- a/sys/sys/syscall.mk +++ b/sys/sys/syscall.mk @@ -234,16 +234,6 @@ MIASM = \ varsym_list.o \ upc_register.o \ upc_control.o \ - caps_sys_service.o \ - caps_sys_client.o \ - caps_sys_close.o \ - caps_sys_put.o \ - caps_sys_reply.o \ - caps_sys_get.o \ - caps_sys_wait.o \ - caps_sys_abort.o \ - caps_sys_getgen.o \ - caps_sys_setgen.o \ exec_sys_register.o \ exec_sys_unregister.o \ sys_checkpoint.o \ diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h index d3344697f5..417f18b099 100644 --- a/sys/sys/sysproto.h +++ b/sys/sys/sysproto.h @@ -1745,90 +1745,6 @@ struct upc_control_args { int upcid; char upcid_[PAD_(int)]; void * data; char data_[PAD_(void *)]; }; -struct caps_sys_service_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - const char * name; char name_[PAD_(const char *)]; - uid_t uid; char uid_[PAD_(uid_t)]; - gid_t gid; char gid_[PAD_(gid_t)]; - int upcid; char upcid_[PAD_(int)]; - int flags; char flags_[PAD_(int)]; -}; -struct caps_sys_client_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - const char * name; char name_[PAD_(const char *)]; - uid_t uid; char uid_[PAD_(uid_t)]; - gid_t gid; char gid_[PAD_(gid_t)]; - int upcid; char upcid_[PAD_(int)]; - int flags; char flags_[PAD_(int)]; -}; -struct caps_sys_close_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; -}; -struct caps_sys_put_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; - void * msg; char msg_[PAD_(void *)]; - int msgsize; char msgsize_[PAD_(int)]; -}; -struct caps_sys_reply_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; - void * msg; char msg_[PAD_(void *)]; - int msgsize; char msgsize_[PAD_(int)]; - off_t msgcid; char msgcid_[PAD_(off_t)]; -}; -struct caps_sys_get_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; - void * msg; char msg_[PAD_(void *)]; - int maxsize; char maxsize_[PAD_(int)]; - struct caps_msgid * msgid; char msgid_[PAD_(struct caps_msgid *)]; - struct caps_cred * ccr; char ccr_[PAD_(struct caps_cred *)]; -}; -struct caps_sys_wait_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; - void * msg; char msg_[PAD_(void *)]; - int maxsize; char maxsize_[PAD_(int)]; - struct caps_msgid * msgid; char msgid_[PAD_(struct caps_msgid *)]; - struct caps_cred * ccr; char ccr_[PAD_(struct caps_cred *)]; -}; -struct caps_sys_abort_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; - off_t msgcid; char msgcid_[PAD_(off_t)]; - int flags; char flags_[PAD_(int)]; -}; -struct caps_sys_getgen_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; -}; -struct caps_sys_setgen_args { -#ifdef _KERNEL - struct sysmsg sysmsg; -#endif - int portid; char portid_[PAD_(int)]; - off_t gen; char gen_[PAD_(off_t)]; -}; struct exec_sys_register_args { #ifdef _KERNEL struct sysmsg sysmsg; @@ -2916,16 +2832,6 @@ int sys_varsym_get (struct varsym_get_args *); int sys_varsym_list (struct varsym_list_args *); int sys_upc_register (struct upc_register_args *); int sys_upc_control (struct upc_control_args *); -int sys_caps_sys_service (struct caps_sys_service_args *); -int sys_caps_sys_client (struct caps_sys_client_args *); -int sys_caps_sys_close (struct caps_sys_close_args *); -int sys_caps_sys_put (struct caps_sys_put_args *); -int sys_caps_sys_reply (struct caps_sys_reply_args *); -int sys_caps_sys_get (struct caps_sys_get_args *); -int sys_caps_sys_wait (struct caps_sys_wait_args *); -int sys_caps_sys_abort (struct caps_sys_abort_args *); -int sys_caps_sys_getgen (struct caps_sys_getgen_args *); -int sys_caps_sys_setgen (struct caps_sys_setgen_args *); int sys_exec_sys_register (struct exec_sys_register_args *); int sys_exec_sys_unregister (struct exec_sys_unregister_args *); int sys_sys_checkpoint (struct sys_checkpoint_args *); diff --git a/sys/sys/sysunion.h b/sys/sys/sysunion.h index b18ba480de..7e04d0f97d 100644 --- a/sys/sys/sysunion.h +++ b/sys/sys/sysunion.h @@ -341,16 +341,6 @@ union sysunion { struct varsym_list_args varsym_list; struct upc_register_args upc_register; struct upc_control_args upc_control; - struct caps_sys_service_args caps_sys_service; - struct caps_sys_client_args caps_sys_client; - struct caps_sys_close_args caps_sys_close; - struct caps_sys_put_args caps_sys_put; - struct caps_sys_reply_args caps_sys_reply; - struct caps_sys_get_args caps_sys_get; - struct caps_sys_wait_args caps_sys_wait; - struct caps_sys_abort_args caps_sys_abort; - struct caps_sys_getgen_args caps_sys_getgen; - struct caps_sys_setgen_args caps_sys_setgen; struct exec_sys_register_args exec_sys_register; struct exec_sys_unregister_args exec_sys_unregister; struct sys_checkpoint_args sys_checkpoint; diff --git a/sys/sys/thread.h b/sys/sys/thread.h index 07792bb40a..31ad0e77d2 100644 --- a/sys/sys/thread.h +++ b/sys/sys/thread.h @@ -247,7 +247,6 @@ typedef struct lwkt_cpu_msg { * threads. */ struct md_intr_info; -struct caps_kinfo; struct thread { TAILQ_ENTRY(thread) td_threadq; @@ -293,7 +292,7 @@ struct thread { char td_comm[MAXCOMLEN+1]; /* typ 16+1 bytes */ struct thread *td_preempted; /* we preempted this thread */ struct ucred *td_ucred; /* synchronized from p_ucred */ - struct caps_kinfo *td_caps; /* list of client and server registrations */ + void *td_unused04; /* for future fields */ lwkt_tokref_t td_toks_have; /* tokens we own */ lwkt_tokref_t td_toks_stop; /* tokens we want */ struct lwkt_tokref td_toks_array[LWKT_MAXTOKENS]; diff --git a/test/caps/Makefile b/test/caps/Makefile deleted file mode 100644 index 9e2fbdbfcd..0000000000 --- a/test/caps/Makefile +++ /dev/null @@ -1,38 +0,0 @@ -# $DragonFly: src/test/caps/Makefile,v 1.8 2004/08/18 09:10:30 dillon Exp $ -# - -# thr{1,2,3} disabled (obsolete at the moment) -TARGETS= /tmp/caps_s /tmp/caps_c /tmp/caps_e /tmp/caps_d - -CFLAGS= -O2 -g -DSMP -CFLAGS+=-I${.CURDIR}/../../lib -I${.CURDIR}/../../lib/libcaps/${MACHINE_ARCH} - -all: $(TARGETS) - -#/tmp/caps1: caps1.c -# $(CC) $(CFLAGS) caps1.c -lcaps -o /tmp/caps1 -# - -/tmp/thr1: thr1.c - $(CC) $(CFLAGS) thr1.c -lcaps -o /tmp/thr1 - -/tmp/thr2: thr2.c - $(CC) $(CFLAGS) thr2.c -lcaps -o /tmp/thr2 - -/tmp/thr3: thr3.c - $(CC) $(CFLAGS) thr3.c -lcaps -o /tmp/thr3 - -/tmp/caps_s: server.c - $(CC) $(CFLAGS) server.c -o /tmp/caps_s - -/tmp/caps_c: client.c - $(CC) $(CFLAGS) client.c -o /tmp/caps_c - -/tmp/caps_e: encoder.c - $(CC) $(CFLAGS) encoder.c -lcaps -o /tmp/caps_e - -/tmp/caps_d: decoder.c - $(CC) $(CFLAGS) decoder.c -lcaps -o /tmp/caps_d - -clean: - rm -f $(TARGETS) diff --git a/test/caps/caps1.c b/test/caps/caps1.c deleted file mode 100644 index b1f00d5521..0000000000 --- a/test/caps/caps1.c +++ /dev/null @@ -1,97 +0,0 @@ -/* - * CAPS1.C - * - * Simple IPC test. /tmp/cs1 -s in one window, /tmp/cs1 -c in another. - * - * $DragonFly: src/test/caps/caps1.c,v 1.1 2003/11/24 21:15:59 dillon Exp $ - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include - -int -main(int ac, char **av) -{ - caps_port_t port; - lwkt_msg_t msg; - struct lwkt_port replyport; - struct lwkt_msg junkmsg; - int i; - int r; - int quietOpt = 0; - enum { UNKNOWN, CLIENT, SERVER } mode; - - signal(SIGPIPE, SIG_IGN); - - for (i = 1; i < ac; ++i) { - char *ptr = av[i]; - if (*ptr != '-') - continue; - ptr += 2; - switch(ptr[-1]) { - case 's': - mode = SERVER; - break; - case 'c': - mode = CLIENT; - break; - case 'q': - quietOpt = (*ptr) ? strtol(ptr, NULL, 0) : 1; - break; - } - } - - switch(mode) { - case SERVER: - port = caps_service("test", -1, 0666, 0); - if (quietOpt == 0) - printf("caps_service port %p\n", port); - while ((msg = lwkt_waitport(&port->lport, NULL)) != NULL) { - if (quietOpt == 0) { - printf("received msg %p %08x\n", msg, msg->ms_flags); - printf("replyport: %p %p\n", - msg->ms_reply_port, msg->ms_reply_port->mp_replyport); - } - msg->u.ms_result = ~msg->u.ms_result; - lwkt_replymsg(msg, 23); - } - break; - case CLIENT: - lwkt_initport(&replyport, curthread); - port = caps_client("test", -1, 0); - if (quietOpt == 0) - printf("caps_client port %p msg %p\n", port, &junkmsg); - if (port == NULL) { - printf("failed to connect\n"); - exit(1); - } - for (i = 0; ; ++i) { - lwkt_initmsg(&junkmsg, &replyport, 0); - junkmsg.u.ms_result = i; - junkmsg.ms_msgsize = sizeof(junkmsg); - junkmsg.ms_maxsize = sizeof(junkmsg); - lwkt_beginmsg(&port->lport, &junkmsg); - if (caps_client_waitreply(port, &junkmsg) == NULL) { - printf("client failed\n"); - break; - } - if (quietOpt == 0) { - printf("reply: error=%d/23 res=%d/%d\n", - junkmsg.ms_error, ~junkmsg.u.ms_result, i); - } else if (quietOpt == 1 && (i & 65535) == 0) { - printf("reply: error=%d/23 res=%d/%d\n", - junkmsg.ms_error, ~junkmsg.u.ms_result, i); - } - } - break; - } - printf("exit\n"); - return(0); -} - diff --git a/test/caps/client.c b/test/caps/client.c deleted file mode 100644 index ed160502e0..0000000000 --- a/test/caps/client.c +++ /dev/null @@ -1,80 +0,0 @@ -/* - * $DragonFly: src/test/caps/client.c,v 1.3 2004/03/31 20:27:34 dillon Exp $ - */ -#include -#include -#include -#include -#include -#include -#include -#include - -int -main(int ac, char **av) -{ - int cid; - int n; - int count = 0; - long long xcount = 0; - int lostit = 0; - int didfork = 0; - int which = 0; - char buf[256]; - struct caps_msgid msgid; - off_t msgcid; - caps_gen_t gen = 0; - caps_gen_t ngen; - - cid = caps_sys_client("test", getuid(), getgid(), 0, CAPF_ANYCLIENT); - for (;;) { - errno = 0; - if (cid >= 0) { - msgcid = caps_sys_put(cid, "xyz", 3); - ngen = caps_sys_getgen(cid); - } - if (cid < 0 || (msgcid < 0 && errno == ENOTCONN)) { - if (lostit == 0) - printf("%d client forked or lost connection, reconnecting\n", which); - lostit = 1; - caps_sys_close(cid); - cid = caps_sys_client("test", getuid(), getgid(), 0, - CAPF_ANYCLIENT | CAPF_WAITSVC); - continue; - } - if (lostit) { - printf("%d client resume on reconnect after lost connection\n", which); - lostit = 0; - } - if (ngen != gen) { - printf("%d client: note generation change %lld\n", which, ngen); - gen = ngen; - } -#ifdef DEBUG - printf("msgcid = %016llx %d\n", msgcid, errno); -#endif - n = caps_sys_wait(cid, buf, sizeof(buf), &msgid, NULL); -#ifdef DEBUG - printf("n = %d msgid=%016llx state=%d errno=%d\n", n, msgid.c_id, msgid.c_state, errno); - if (n > 0) - printf("REPLY: %*.*s\n", n, n, buf); -#endif - ++count; - ++xcount; - if ((count & 65535) == 0) - printf("%d %lld\n", which, xcount); - if (count == 100000000) - count = 0; - if (count == 1000 && didfork == 0 && which < 10) { - if (fork() == 0) { - usleep(100000); - ++which; - } else { - printf("forked pid %d client #%d\n", (int)getpid(), which + 1); - didfork = 1; - } - } - } - return(0); -} - diff --git a/test/caps/decoder.c b/test/caps/decoder.c deleted file mode 100644 index 8ecb34d954..0000000000 --- a/test/caps/decoder.c +++ /dev/null @@ -1,58 +0,0 @@ -/* - * DECODER.C - * - * Decode CAPS encoded buffers, one per line, into a struct passwd and - * report the results. - * - * $DragonFly: src/test/caps/decoder.c,v 1.1 2004/03/07 23:36:45 dillon Exp $ - */ -#include -#include -#include -#include -#include - -int -main(int ac, char **av) -{ - int i; - int n; - int error; - int len; - char buf[1024]; - struct passwd pw; - - while (fgets(buf, sizeof(buf), stdin) != NULL) { - len = strlen(buf); - bzero(&pw, sizeof(pw)); - n = caps_decode(buf, len, &pw, &caps_passwd_struct, &error); - printf("decode %d bytes error %d\n", n, error); - if (error) { - if (n > len) - n = len; - if (n && buf[n] == '\n') /* don't highlight a 'newline' */ - --n; - printf("%*.*s", n, n, buf); - printf("\033[7m%c\033[m", buf[n]); - n = len - n - 1; - if (n > 0) - printf("%*.*s", n, n, buf + len - n); - } else { - printf("{\n"); - printf(" pw_name = \"%s\"\n", pw.pw_name); - printf(" pw_passwd = \"%s\"\n", pw.pw_passwd); - printf(" pw_uid = %d\n", pw.pw_uid); - printf(" pw_gid = %d\n", pw.pw_gid); - printf(" pw_change = %08llx\n", (long long)pw.pw_change); - printf(" pw_class = \"%s\"\n", pw.pw_class); - printf(" pw_gecos = \"%s\"\n", pw.pw_gecos); - printf(" pw_dir = \"%s\"\n", pw.pw_dir); - printf(" pw_shell = \"%s\"\n", pw.pw_shell); - printf(" pw_expire = %08llx\n", (long long)pw.pw_expire); - printf("}\n"); - } - caps_struct_free_pointers(&pw, &caps_passwd_struct); - } - return(0); -} - diff --git a/test/caps/encoder.c b/test/caps/encoder.c deleted file mode 100644 index c22f22a553..0000000000 --- a/test/caps/encoder.c +++ /dev/null @@ -1,39 +0,0 @@ -/* - * ENCODER.C - * - * CAPS-Encode the passwd structure for the specified usernames, generate - * to stdout. - * - * $DragonFly: src/test/caps/encoder.c,v 1.1 2004/03/07 23:36:45 dillon Exp $ - */ -#include -#include -#include -#include -#include - -int -main(int ac, char **av) -{ - int i; - int n; - char buf[1024]; - - for (i = 1; i < ac; ++i) { - struct passwd *pw; - - if ((pw = getpwnam(av[i])) == NULL) { - printf("%s: lookup failed\n"); - continue; - } - n = caps_encode(buf, sizeof(buf), pw, &caps_passwd_struct); - if (n > sizeof(buf)) { - printf("buffer overflow during encoding\n"); - } else { - buf[n] = 0; - printf("%s\n", buf); - } - } - return(0); -} - diff --git a/test/caps/server.c b/test/caps/server.c deleted file mode 100644 index de55d83195..0000000000 --- a/test/caps/server.c +++ /dev/null @@ -1,50 +0,0 @@ -/* - * $DragonFly: src/test/caps/server.c,v 1.5 2004/08/24 13:45:54 drhodus Exp $ - */ -#include -#include -#include -#include -#include -#include -#include -#include - -int -main(int ac, char **av) -{ - int cid; - int n; - int count; - char buf[256]; - struct caps_msgid msgid; - - count = 0; - - cid = caps_sys_service("test", getuid(), getgid(), 0, CAPF_ANYCLIENT); - if (cid == -1) { - perror("caps_sys_service"); - exit(1); - } - printf("cid = %d\n", cid); - if (cid < 0) - return(0); - bzero(&msgid, sizeof(msgid)); - for (;;) { - n = caps_sys_wait(cid, buf, sizeof(buf), &msgid, NULL); -#ifdef DEBUG - printf("n = %d msgid=%016llx state=%d errno=%d\n", n, msgid.c_id, msgid.c_state, errno); - if (n > 0) - printf("BUFFER: %*.*s\n", n, n, buf); -#endif - if (msgid.c_state != CAPMS_DISPOSE) - n = caps_sys_reply(cid, "good", 4, msgid.c_id); -#ifdef DEBUG - printf("reply: n = %d\n", n); -#endif - if (++count % 1000000 == 0) - caps_sys_setgen(cid, count); - } - return(0); -} - diff --git a/test/caps/thr1.c b/test/caps/thr1.c deleted file mode 100644 index 08784a6236..0000000000 --- a/test/caps/thr1.c +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/test/caps/thr1.c,v 1.1 2003/12/07 04:26:41 dillon Exp $ - */ -#include -#include - -extern int mp_lock; - -static void thread1(void *data); -static void thread2(void *data); - -int -main(int ac, char **av) -{ - thread_t td; - thread_t td1; - thread_t td2; - - uthread_init(); - td = curthread; - printf("mainthread %p crit_count %d nest %d mp_lock %d\n", - td, td->td_pri / TDPRI_CRIT, td->td_mpcount, mp_lock - ); - lwkt_create(thread1, NULL, &td1, NULL, 0, -1, "thread1"); - lwkt_create(thread2, NULL, &td2, NULL, 0, -1, "thread2"); - printf("thread #1 %p #2 %p\n", td1, td2); - printf("switching away from main (should come back before exit)\n"); - lwkt_switch(); - printf("Switched back to main, main Exiting\n"); - exit(1); -} - -void -thread1(void *data) -{ - printf("thread1 running\n"); - printf("thread1 exiting\n"); -} - -void -thread2(void *data) -{ - printf("thread2 running\n"); - printf("thread2 exiting\n"); -} - diff --git a/test/caps/thr2.c b/test/caps/thr2.c deleted file mode 100644 index 81757470ae..0000000000 --- a/test/caps/thr2.c +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/test/caps/thr2.c,v 1.1 2003/12/07 04:26:41 dillon Exp $ - */ -#include -#include - -extern int mp_lock; - -static void thread1(void *data); -static void thread2(void *data); - -int -main(int ac, char **av) -{ - thread_t td; - thread_t td1; - thread_t td2; - - uthread_init(); - lwkt_create(thread1, NULL, &td1, NULL, 0, -1, "thread1"); - lwkt_create(thread2, NULL, &td2, NULL, 0, -1, "thread2"); - lwkt_switch(); - printf("Main Exiting\n"); - exit(1); -} - -void -thread1(void *data) -{ - int i; - for (i = 0; i < 1000000; ++i) - lwkt_switch(); - printf("done1\n"); -} - -void -thread2(void *data) -{ - int i; - for (i = 0; i < 1000000; ++i) - lwkt_switch(); - printf("done2\n"); - exit(0); -} - diff --git a/test/caps/thr3.c b/test/caps/thr3.c deleted file mode 100644 index 2af6a216b7..0000000000 --- a/test/caps/thr3.c +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Copyright (c) 2003 Matthew Dillon - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. - * - * $DragonFly: src/test/caps/thr3.c,v 1.1 2003/12/07 04:26:41 dillon Exp $ - */ -#include -#include - -extern int mp_lock; - -static void thread1(void *data); -static void thread2(void *data); - -int -main(int ac, char **av) -{ - thread_t td; - thread_t td1; - thread_t td2; - int tcpu; - - uthread_init(); - tcpu = caps_fork_vcpu(); - printf("caps_fork_vcpu %d\n", tcpu); - lwkt_create(thread1, NULL, &td1, NULL, 0, -1, "thread1"); - lwkt_create(thread2, NULL, &td2, NULL, 0, tcpu, "thread2"); - lwkt_deschedule_self(); - lwkt_switch(); - printf("Main thread resumed after all children exiting.\n"); - printf("Running test a second time to see if UPC_CONTROL_WAIT works\n"); - lwkt_create(thread1, NULL, &td1, NULL, 0, -1, "thread1"); - lwkt_create(thread2, NULL, &td2, NULL, 0, tcpu, "thread2"); - lwkt_deschedule_self(); - lwkt_switch(); - printf("Main thread resumed after second test, exiting\n"); - exit(0); -} - -void -thread1(void *data) -{ - int i; - - printf("start1 pri %d mp %d\n", curthread->td_pri, curthread->td_mpcount); - rel_mplock(); - for (i = 0; i < 100000000; ++i) - lwkt_switch(); - printf("done1 %d\n", (int)getpid()); -} - -void -thread2(void *data) -{ - int i; - - printf("start2 pri %d mp %d\n", curthread->td_pri, curthread->td_mpcount); - for (i = 0; i < 10000000; ++i) - lwkt_switch(); - printf("done2 %d\n", (int)getpid()); -} - diff --git a/usr.sbin/installer/dfuibe_installer/main.c b/usr.sbin/installer/dfuibe_installer/main.c index ed0be929cc..0221ec774a 100644 --- a/usr.sbin/installer/dfuibe_installer/main.c +++ b/usr.sbin/installer/dfuibe_installer/main.c @@ -135,6 +135,6 @@ static void usage(char **argv) { fprintf(stderr, _("Usage: %s [-o rootdir] [-r rendezvous] " - "[-t caps|npipe|tcp]\n"), argv[0]); + "[-t npipe|tcp]\n"), argv[0]); exit(1); } diff --git a/usr.sbin/installer/dfuife_curses/main.c b/usr.sbin/installer/dfuife_curses/main.c index 67c3a96342..8bc4af072e 100644 --- a/usr.sbin/installer/dfuife_curses/main.c +++ b/usr.sbin/installer/dfuife_curses/main.c @@ -122,7 +122,7 @@ static void usage(char **argv) { fprintf(stderr, _("Usage: %s " - "[-b backdrop] [-r rendezvous] [-t caps|npipe|tcp]\n"), + "[-b backdrop] [-r rendezvous] [-t npipe|tcp]\n"), argv[0]); exit(1); } diff --git a/usr.sbin/installer/libdfui/Makefile b/usr.sbin/installer/libdfui/Makefile index 704c959311..4b40a96eab 100644 --- a/usr.sbin/installer/libdfui/Makefile +++ b/usr.sbin/installer/libdfui/Makefile @@ -1,7 +1,5 @@ -# $DragonFly: src/usr.sbin/installer/libdfui/Makefile,v 1.3 2008/08/29 22:51:56 swildner Exp $ - LIB= dfui -SRCS= conn_caps.c conn_npipe.c conn_tcp.c connection.c decode.c \ +SRCS= conn_npipe.c conn_tcp.c connection.c decode.c \ dump.c encode.c form.c lang.c system.c CFLAGS+=-I${.CURDIR}/.. diff --git a/usr.sbin/installer/libdfui/README b/usr.sbin/installer/libdfui/README index 5b6bc173c0..c56194fd4f 100644 --- a/usr.sbin/installer/libdfui/README +++ b/usr.sbin/installer/libdfui/README @@ -10,8 +10,8 @@ libdfui is a LIBrary for DragonFly User Interfaces. It provides a highly abstract user interaction interface with which an application program (termed the backend) can communicate with a user via a concreate user interface terminal program (termed the frontend.) The frontend and the -backend can communicate over several kinds of transport layers (TCP, -CAPS, and Named Pipes.) The protocol is abstract enough so that the +backend can communicate over several kinds of transport layers (TCP +and Named Pipes.) The protocol is abstract enough so that the frontend can occupy nearly any medium (GUI, addressable text console, teletype, voice synthesis/recognition, etc) with little to no `fudging' of the semantics (i.e. the structure and nature of the information that diff --git a/usr.sbin/installer/libdfui/conn_caps.c b/usr.sbin/installer/libdfui/conn_caps.c deleted file mode 100644 index 6b880ff9ea..0000000000 --- a/usr.sbin/installer/libdfui/conn_caps.c +++ /dev/null @@ -1,323 +0,0 @@ -/* - * Copyright (c)2004 Cat's Eye Technologies. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 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. - * - * Neither the name of Cat's Eye Technologies nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * ``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 - * COPYRIGHT HOLDERS OR CONTRIBUTORS 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. - */ - -/* - * conn_caps.c - * $Id: conn_caps.c,v 1.12 2005/02/06 19:53:19 cpressey Exp $ - * This code was derived in part from: - * $_DragonFly: src/test/caps/client.c,v 1.3 2004/03/31 20:27:34 dillon Exp $ - * $_DragonFly: src/test/caps/server.c,v 1.4 2004/03/06 22:15:00 dillon Exp $ - * and is therefore also subject to the license conditions on those files. - */ - -#include "system.h" -#ifdef HAS_CAPS - -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include -#include - -#define NEEDS_DFUI_STRUCTURE_DEFINITIONS -#include "dfui.h" -#undef NEEDS_DFUI_STRUCTURE_DEFINITIONS -#include "encoding.h" -#include "dump.h" -#include "conn_caps.h" - -/***** BACKEND ******/ - -/** High Level **/ - -/* - * Connect to the frontend. - */ -dfui_err_t -dfui_caps_be_start(struct dfui_connection *c) -{ - T_CAPS(c)->cid = caps_sys_service(c->rendezvous, getuid(), getgid(), - 0, CAPF_ANYCLIENT); - return(T_CAPS(c)->cid < 0 ? DFUI_FAILURE : DFUI_SUCCESS); -} - -/* - * Tell the frontend that we're done and disconnect from it. - */ -dfui_err_t -dfui_caps_be_stop(struct dfui_connection *c) -{ - if (dfui_caps_be_ll_exchange(c, DFUI_BE_MSG_STOP, "")) { - caps_sys_close(T_CAPS(c)->cid); - return(DFUI_SUCCESS); - } else - return(DFUI_FAILURE); -} - -/** Low Level **/ - -/* - * Exchange a message with the frontend. This involves two receive()/reply() - * cycles: one to provide our message, one to get a reply from the frontend. - * - * Note that this does not immediately send the message to the frontend - - * it can't, because we're a service and it's a client. What it does is - * keep the message handy and wait for a frontend request to come in. It - * then replies to that request with our message. - * - * The protocol looks something like the following, using the PRESENT and - * SUBMIT exchange as an example: - * - * frontend (client) | backend (service) - * ------------------+------------------ - * - * [stage 1] - * READY --> ll_receive() - * <-- PRESENT(form) ll_reply() - * - * [stage 2] - * SUBMIT(form) --> ll_receive() - * <-- READY ll_reply() - * - * Each of those exchanges is a pair of calls, on our end, to - * dfui_caps_be_ll_receive() and dfui_caps_be_ll_reply(). - * - * The set of messages that the client can pass us is determined by - * the conversation state: - * - * o In stage 1, only READY and ABORT are meaningful. - * o After a PRESENT, the messages SUBMIT and ABORT are meaningul - * in stage 2. - * o During a PROG_*, the messages CONTINUE, CANCEL, and ABORT - * are meaningful in stage 2. - * - * If the frontend sends us with READY in stage 2, we assume it has - * fallen out of sync, so we send the same initial reply again, going - * back to stage 1 as it were. - * - * After this call, the message is available in c->ebuf. - */ -dfui_err_t -dfui_caps_be_ll_exchange(struct dfui_connection *c, char msgtype, const char *msg) -{ - char *fmsg; - - /* - * Construct our message to send. - */ - - fmsg = aura_malloc(strlen(msg) + 2, "exchange message"); - fmsg[0] = msgtype; - strcpy(fmsg + 1, msg); - - /* - * Get the frontend's message. - */ - - dfui_caps_be_ll_receive(c); - - /* - * Frontend message should have been either READY or ABORT. - * If ABORT, we get out of here pronto. - */ - - if (aura_buffer_buf(c->ebuf)[0] == DFUI_FE_MSG_ABORT) { - aura_free(fmsg, "exchange message"); - return(DFUI_FAILURE); - } - - /* XXX if (!READY) ??? */ - - do { - dfui_caps_be_ll_reply(c, fmsg); - - /* - * Here, the frontend has picked up our request and is - * processing it. We have to wait for the response. - */ - - dfui_caps_be_ll_receive(c); - - /* - * Did we get READY from this? - * If so, loop! - */ - - } while (aura_buffer_buf(c->ebuf)[0] == DFUI_FE_MSG_READY); - - fmsg[0] = DFUI_BE_MSG_READY; - fmsg[1] = '\0'; - dfui_caps_be_ll_reply(c, fmsg); - - aura_free(fmsg, "exchange message"); - return(DFUI_SUCCESS); -} - -/* - * Receive a message from the frontend. - * This call is synchronous. - * After this call, the message is available in c->ebuf. - */ -dfui_err_t -dfui_caps_be_ll_receive(struct dfui_connection *c) -{ - /* - * XXX Eventually, the message should be received directly - * into c->ebuf. For now, receive into T_CAPS(c)->buf, - * and copy into c->ebuf. - */ - do { - T_CAPS(c)->wresult = caps_sys_wait(T_CAPS(c)->cid, T_CAPS(c)->buf, - T_CAPS(c)->size, &T_CAPS(c)->msgid, NULL); - if (T_CAPS(c)->wresult < 0) - return(DFUI_FAILURE); - /* - * This might have been a CAPMS_DISPOSE message from the kernel. - * If so, just accept it and try, try again. - */ - dfui_debug("DISPOSE?<<%s>>\n", - T_CAPS(c)->msgid.c_state == CAPMS_DISPOSE ? "Yes" : "No"); - } while (T_CAPS(c)->msgid.c_state == CAPMS_DISPOSE); - - aura_buffer_set(c->ebuf, T_CAPS(c)->buf, T_CAPS(c)->wresult); - dfui_debug("RECV<<%s>>\n", aura_buffer_buf(c->ebuf)); - return(DFUI_SUCCESS); -} - -/* - * Send a NUL-terminated reply to the frontend. - */ -dfui_err_t -dfui_caps_be_ll_reply(struct dfui_connection *c, const char *fmsg) -{ - dfui_debug("SEND<<%s>>\n", fmsg); - T_CAPS(c)->wresult = caps_sys_reply(T_CAPS(c)->cid, - __DECONST(char *, fmsg), strlen(fmsg), T_CAPS(c)->msgid.c_id); - - /* - * We may get a CAPMS_DISPOSE message after this, if the client - * process is still around. If so, it'll be handled in the next - * call to dfui_caps_be_ll_receive(). - */ - - return(DFUI_SUCCESS); -} - -/******** FRONTEND ********/ - -/** High Level **/ - -dfui_err_t -dfui_caps_fe_connect(struct dfui_connection *c) -{ - T_CAPS(c)->cid = caps_sys_client(c->rendezvous, getuid(), getgid(), 0, - CAPF_ANYCLIENT | CAPF_WAITSVC); - return(T_CAPS(c)->cid > 0 ? DFUI_SUCCESS : DFUI_FAILURE); -} - -dfui_err_t -dfui_caps_fe_disconnect(struct dfui_connection *c) -{ - caps_sys_close(T_CAPS(c)->cid); - return(DFUI_SUCCESS); -} - -/** Low Level **/ - -/* - * Ask for, and subsequently receieve, a message from the backend. - * msgtype should be one of the DFUI_FE_MSG_* constants. - * This call is synchronous. - * After this call, the encoded message is available in c->ebuf. - */ -dfui_err_t -dfui_caps_fe_ll_request(struct dfui_connection *c, char msgtype, const char *msg) -{ - char *fmsg; - off_t msgcid = 0; - - /* - * First, assert that the connection is open. - */ - - if (c == NULL || T_CAPS(c)->cid < 0) - return(DFUI_FAILURE); - - /* - * Construct a message. - */ - - fmsg = aura_malloc(strlen(msg) + 2, "exchange message"); - fmsg[0] = msgtype; - strcpy(fmsg + 1, msg); - dfui_debug("SEND<<%s>>\n", fmsg); - - /* - * Send a NUL-terminated message to the backend. - */ - - errno = 0; - msgcid = caps_sys_put(T_CAPS(c)->cid, fmsg, strlen(fmsg)); - if (msgcid < 0 && errno == ENOTCONN) - return(DFUI_FAILURE); - - /* - * Receive a reply from the backend. - * If our message was a READY, this should be a message like PRESENT. - * Otherwise it should simply be a READY. - */ - - dfui_debug("WAITING<<>>\n"); - - T_CAPS(c)->wresult = caps_sys_wait(T_CAPS(c)->cid, T_CAPS(c)->buf, - T_CAPS(c)->size, &T_CAPS(c)->msgid, NULL); - if (T_CAPS(c)->wresult < 0) - return(DFUI_FAILURE); - - aura_buffer_set(c->ebuf, T_CAPS(c)->buf, T_CAPS(c)->wresult); - dfui_debug("RECV<<%s>>\n", aura_buffer_buf(c->ebuf)); - - aura_free(fmsg, "exchange message"); - - return(DFUI_SUCCESS); -} - -#endif /* HAS_CAPS */ diff --git a/usr.sbin/installer/libdfui/conn_caps.h b/usr.sbin/installer/libdfui/conn_caps.h deleted file mode 100644 index 8a35031f90..0000000000 --- a/usr.sbin/installer/libdfui/conn_caps.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (c)2004 Cat's Eye Technologies. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 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. - * - * Neither the name of Cat's Eye Technologies nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * ``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 - * COPYRIGHT HOLDERS OR CONTRIBUTORS 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. - */ - -/* - * conn_caps.h - * $Id: conn_caps.h,v 1.7 2005/02/06 19:53:19 cpressey Exp $ - */ - -#ifndef __CONN_CAPS_H_ -#define __CONN_CAPS_H_ - -#include "system.h" -#ifdef HAS_CAPS - -#include - -#include "dfui.h" - -struct dfui_conn_caps { - int cid; /* the caps id for the connection */ - int wresult; /* result of last caps_sys_wait/get */ - struct caps_msgid msgid; /* msgid of the last msg recvd */ - char *buf; /* XXX last message recvd */ - size_t size; /* XXX size of msg recv buffer */ -}; - -#define T_CAPS(c) ((struct dfui_conn_caps *)c->t_data) - -dfui_err_t dfui_caps_be_start(struct dfui_connection *); -dfui_err_t dfui_caps_be_stop(struct dfui_connection *); - -dfui_err_t dfui_caps_be_ll_exchange(struct dfui_connection *, - char, const char *); -dfui_err_t dfui_caps_be_ll_receive(struct dfui_connection *); -dfui_err_t dfui_caps_be_ll_reply(struct dfui_connection *, const char *); - -dfui_err_t dfui_caps_fe_connect(struct dfui_connection *); -dfui_err_t dfui_caps_fe_disconnect(struct dfui_connection *); - -dfui_err_t dfui_caps_fe_ll_request(struct dfui_connection *, char, const char *); - -#endif /* HAS_CAPS */ -#endif /* !__CONN_CAPS_H_ */ diff --git a/usr.sbin/installer/libdfui/connection.c b/usr.sbin/installer/libdfui/connection.c index 5078a43aa3..8d00e9359a 100644 --- a/usr.sbin/installer/libdfui/connection.c +++ b/usr.sbin/installer/libdfui/connection.c @@ -53,7 +53,6 @@ #include "encoding.h" #include "dump.h" -#include "conn_caps.h" #include "conn_npipe.h" #include "conn_tcp.h" @@ -63,9 +62,6 @@ dfui_connection_new(int transport, const char *rendezvous) struct dfui_connection *c = NULL; if ( -#ifdef HAS_CAPS - transport == DFUI_TRANSPORT_CAPS || -#endif #ifdef HAS_NPIPE transport == DFUI_TRANSPORT_NPIPE || #endif @@ -92,38 +88,6 @@ dfui_connection_new(int transport, const char *rendezvous) c->t_data = NULL; switch (transport) { -#ifdef HAS_CAPS - case DFUI_TRANSPORT_CAPS: - AURA_MALLOC(c->t_data, dfui_conn_caps); - T_CAPS(c)->cid = 0; - bzero(&T_CAPS(c)->msgid, sizeof(T_CAPS(c)->msgid)); - - /* - * XXX Ideally, this value should grow as needed. - * However, CAPS currently has a size limit of - * 128K internally. - */ - T_CAPS(c)->size = 128 * 1024; - if ((T_CAPS(c)->buf = aura_malloc(T_CAPS(c)->size, "CAPS buffer")) == NULL) { - AURA_FREE(T_CAPS(c), dfui_conn_caps); - aura_free(c->rendezvous, "rendezvous string"); - AURA_FREE(c, dfui_connection); - return(NULL); - } - - /* - * Set up dispatch functions. - */ - c->be_start = dfui_caps_be_start; - c->be_stop = dfui_caps_be_stop; - c->be_ll_exchange = dfui_caps_be_ll_exchange; - - c->fe_connect = dfui_caps_fe_connect; - c->fe_disconnect = dfui_caps_fe_disconnect; - c->fe_ll_request = dfui_caps_fe_ll_request; - break; -#endif /* HAS_CAPS */ - #ifdef HAS_NPIPE case DFUI_TRANSPORT_NPIPE: AURA_MALLOC(c->t_data, dfui_conn_npipe); @@ -176,15 +140,6 @@ dfui_connection_free(struct dfui_connection *c) return; switch (c->transport) { -#ifdef HAS_CAPS - case DFUI_TRANSPORT_CAPS: - if (T_CAPS(c) != NULL) { - if (T_CAPS(c)->buf != NULL) - aura_free(T_CAPS(c)->buf, "CAPS buffer"); - AURA_FREE(T_CAPS(c), dfui_conn_caps); - } - break; -#endif #ifdef HAS_NPIPE case DFUI_TRANSPORT_NPIPE: if (T_NPIPE(c) != NULL) { diff --git a/usr.sbin/installer/libdfui/dfui.h b/usr.sbin/installer/libdfui/dfui.h index d161709620..a155d266db 100644 --- a/usr.sbin/installer/libdfui/dfui.h +++ b/usr.sbin/installer/libdfui/dfui.h @@ -68,9 +68,8 @@ typedef int dfui_err_t; * Transports. */ -#define DFUI_TRANSPORT_CAPS 1 -#define DFUI_TRANSPORT_NPIPE 2 -#define DFUI_TRANSPORT_TCP 3 +#define DFUI_TRANSPORT_NPIPE 1 +#define DFUI_TRANSPORT_TCP 2 /* * Message types. @@ -119,7 +118,7 @@ struct dfui_progress; /* Connections */ struct dfui_connection { - int transport; /* transport layer: CAPS, NPIPE, or TCP */ + int transport; /* transport layer: NPIPE or TCP */ char *rendezvous; /* rendezvous point */ struct aura_buffer *ebuf; /* last message recvd */ int is_connected; /* was a connection actually established? */ diff --git a/usr.sbin/installer/libdfui/system.c b/usr.sbin/installer/libdfui/system.c index ec1fe23610..ff5a2d2293 100644 --- a/usr.sbin/installer/libdfui/system.c +++ b/usr.sbin/installer/libdfui/system.c @@ -30,15 +30,6 @@ ostype(void) return p; } -int -has_caps(void) -{ -#ifdef HAS_CAPS - return 1; -#endif - return 0; -} - int has_npipe(void) { @@ -68,11 +59,7 @@ has_tcp(void) int get_transport(const char *transport_name) { - if (strcmp(transport_name, "caps") == 0) { - if (has_caps()) - return DFUI_TRANSPORT_CAPS; - return(0); - } else if (strcmp(transport_name, "npipe") == 0) { + if (strcmp(transport_name, "npipe") == 0) { if (has_npipe()) return DFUI_TRANSPORT_NPIPE; return(0); diff --git a/usr.sbin/installer/libdfui/system.h b/usr.sbin/installer/libdfui/system.h index 1b1cf24703..f8dd1ea4d4 100644 --- a/usr.sbin/installer/libdfui/system.h +++ b/usr.sbin/installer/libdfui/system.h @@ -41,7 +41,6 @@ #define HAS_TCP #define HAS_NPIPE -#define HAS_CAPS #define OPERATING_SYSTEM_NAME "DragonFly BSD" #define OPERATING_SYSTEM_URL "http://www.dragonflybsd.org" @@ -49,7 +48,6 @@ char *ostype(void); int has_tcp(void); int has_npipe(void); -int has_caps(void); int get_transport(const char *); int user_get_transport(const char *);