usr/src/lib/libilb/common/ilb_comm.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <stdlib.h>
  28 #include <strings.h>
  29 #include <unistd.h>
  30 #include <stddef.h>
  31 #include <assert.h>
  32 #include <sys/types.h>
  33 #include <sys/socket.h>
  34 #include <thread.h>
  35 #include <synch.h>
  36 #include <libilb_impl.h>
  37 #include <libilb.h>
  38
  39 /* Assertion: the calling thread has a hold on the handle */
  40 static void
  41 i_ilb_socket_set_err(ilb_handle_t h, ilb_status_t err)
  42 {
  43         ilb_handle_impl_t       *hi = (ilb_handle_impl_t *)h;
  44
  45         if (h == ILB_INVALID_HANDLE)
  46                 return;
  47         hi->h_valid = B_FALSE;
  48         hi->h_error = err;
  49 }
  50
  51 ilb_status_t
  52 ilb_open(ilb_handle_t *hp)
  53 {
  54         ilb_handle_impl_t       *hi = NULL;
  55         int                     s = -1;
  56         struct sockaddr_un sa = {AF_UNIX, SOCKET_PATH};
  57         ilb_status_t            rc = ILB_STATUS_OK;
  58         int                     sobufsz;
  59
  60         if (hp == NULL)
  61                 return (ILB_STATUS_EINVAL);
  62
  63         hi = calloc(sizeof (*hi), 1);
  64         if (hi == NULL)
  65                 return (ILB_STATUS_ENOMEM);
  66
  67         if (cond_init(&hi->h_cv, USYNC_THREAD, NULL) != 0) {
  68                 rc = ILB_STATUS_INTERNAL;
  69                 goto out;
  70         }
  71
  72         if (mutex_init(&hi->h_lock, USYNC_THREAD | LOCK_ERRORCHECK, NULL)
  73             != 0) {
  74                 rc = ILB_STATUS_INTERNAL;
  75                 goto out;
  76         }
  77
  78         hi->h_busy = B_FALSE;
  79
  80         if ((s = socket(PF_UNIX, SOCK_SEQPACKET, 0)) == -1 ||
  81             connect(s, (struct sockaddr *)&sa, sizeof (sa.sun_path))
  82             == -1) {
  83                 rc = ILB_STATUS_SOCKET;
  84                 goto out;
  85         }
  86
  87         /* The socket buffer must be at least the max size of a message */
  88         sobufsz = ILBD_MSG_SIZE;
  89         if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sobufsz,
  90             sizeof (sobufsz)) != 0) {
  91                 rc = ILB_STATUS_SOCKET;
  92                 (void) close(s);
  93                 goto out;
  94         }
  95         if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &sobufsz,
  96             sizeof (sobufsz)) != 0) {
  97                 rc = ILB_STATUS_SOCKET;
  98                 (void) close(s);
  99                 goto out;
 100         }
 101
 102         hi->h_socket = s;
 103         hi->h_valid = B_TRUE;
 104
 105 out:
 106         if (rc != ILB_STATUS_OK && s != -1)
 107                 (void) close(s);
 108
 109         if (rc == ILB_STATUS_OK) {
 110                 *hp = (ilb_handle_t)hi;
 111         } else {
 112                 free(hi);
 113                 *hp = ILB_INVALID_HANDLE;
 114         }
 115         return (rc);
 116 }
 117
 118 ilb_status_t
 119 ilb_close(ilb_handle_t h)
 120 {
 121         ilb_handle_impl_t       *hi = (ilb_handle_impl_t *)h;
 122
 123         if (h == ILB_INVALID_HANDLE)
 124                 return (ILB_STATUS_EINVAL);
 125
 126         if (mutex_lock(&hi->h_lock) != 0)
 127                 return (ILB_STATUS_INTERNAL);
 128
 129         /* Somebody has done a close, no need to do anything. */
 130         if (hi->h_closing) {
 131                 return (ILB_STATUS_OK);
 132         } else {
 133                 hi->h_closing = B_TRUE;
 134                 hi->h_error = ILB_STATUS_HANDLE_CLOSING;
 135         }
 136
 137         /* Wait until there is nobody waiting. */
 138         while (hi->h_waiter > 0) {
 139                 if (cond_wait(&hi->h_cv, &hi->h_lock) != 0) {
 140                         (void) mutex_unlock(&hi->h_lock);
 141                         return (ILB_STATUS_INTERNAL);
 142                 }
 143         }
 144         /* No one is waiting, proceed to free the handle. */
 145
 146         (void) close(hi->h_socket);
 147         (void) mutex_destroy(&hi->h_lock);
 148         (void) cond_destroy(&hi->h_cv);
 149         free(hi);
 150         return (ILB_STATUS_OK);
 151 }
 152
 153 /*
 154  * Unified routine to communicate with ilbd.
 155  *
 156  * If ic is non-NULL, it means that the caller wants to send something
 157  * to ilbd and expects a reply.  If ic is NULL, it means that the caller
 158  * only expects to receive from ilbd.
 159  *
 160  * The rbuf is the buffer supplied by the caller for receiving.  If it
 161  * is NULL, it means that there is no reply expected.
 162  *
 163  * This function will not close() the socket to kernel unless there is
 164  * an error.  If the transaction only consists of one exchange, the caller
 165  * can use i_ilb_close_comm() to close() the socket when done.
 166  */
 167 ilb_status_t
 168 i_ilb_do_comm(ilb_handle_t h, ilb_comm_t *ic, size_t ic_sz, ilb_comm_t *rbuf,
 169     size_t *rbufsz)
 170 {
 171         ilb_status_t            rc = ILB_STATUS_OK;
 172         int                     r, s;
 173         ilb_handle_impl_t       *hi = (ilb_handle_impl_t *)h;
 174
 175         assert(rbuf != NULL);
 176         if (h == ILB_INVALID_HANDLE)
 177                 return (ILB_STATUS_EINVAL);
 178
 179         if (mutex_lock(&hi->h_lock) != 0)
 180                 return (ILB_STATUS_INTERNAL);
 181
 182         hi->h_waiter++;
 183         while (hi->h_busy) {
 184                 if (cond_wait(&hi->h_cv, &hi->h_lock) != 0) {
 185                         hi->h_waiter--;
 186                         (void) cond_signal(&hi->h_cv);
 187                         (void) mutex_unlock(&hi->h_lock);
 188                         return (ILB_STATUS_INTERNAL);
 189                 }
 190         }
 191
 192         if (!hi->h_valid || hi->h_closing) {
 193                 hi->h_waiter--;
 194                 (void) cond_signal(&hi->h_cv);
 195                 (void) mutex_unlock(&hi->h_lock);
 196                 return (hi->h_error);
 197         }
 198
 199         hi->h_busy = B_TRUE;
 200         (void) mutex_unlock(&hi->h_lock);
 201
 202         s = hi->h_socket;
 203
 204         r = send(s, ic, ic_sz, 0);
 205         if (r < ic_sz) {
 206                 rc = ILB_STATUS_WRITE;
 207                 goto socket_error;
 208         }
 209         rc = ILB_STATUS_OK;
 210
 211         if ((r = recv(s, rbuf, *rbufsz, 0)) <= 0) {
 212                 rc = ILB_STATUS_READ;
 213         } else {
 214                 *rbufsz = r;
 215                 goto out;
 216         }
 217
 218 socket_error:
 219         i_ilb_socket_set_err(h, rc);
 220
 221 out:
 222         (void) mutex_lock(&hi->h_lock);
 223         hi->h_busy = B_FALSE;
 224         hi->h_waiter--;
 225         (void) cond_signal(&hi->h_cv);
 226         (void) mutex_unlock(&hi->h_lock);
 227
 228         return (rc);
 229 }
 230
 231 void
 232 i_ilb_close_comm(ilb_handle_t h)
 233 {
 234         (void) ilb_close(h);
 235 }