qdevices/qdevice-net-poll.c

   1 /*
   2  * Copyright (c) 2015-2017 Red Hat, Inc.
   3  *
   4  * All rights reserved.
   5  *
   6  * Author: Jan Friesse (jfriesse@redhat.com)
   7  *
   8  * This software licensed under BSD license, the text of which follows:
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions are met:
  12  *
  13  * - Redistributions of source code must retain the above copyright notice,
  14  *   this list of conditions and the following disclaimer.
  15  * - Redistributions in binary form must reproduce the above copyright notice,
  16  *   this list of conditions and the following disclaimer in the documentation
  17  *   and/or other materials provided with the distribution.
  18  * - Neither the name of the Red Hat, Inc. nor the names of its
  19  *   contributors may be used to endorse or promote products derived from this
  20  *   software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  32  * THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include "qdevice-cmap.h"
  36 #include "qdevice-net-poll.h"
  37 #include "qdevice-log.h"
  38 #include "qdevice-net-send.h"
  39 #include "qdevice-net-socket.h"
  40 #include "qdevice-votequorum.h"
  41 #include "qdevice-ipc.h"
  42 #include "qdevice-net-poll-array-user-data.h"
  43 #include "qdevice-heuristics.h"
  44 #include "qdevice-heuristics-cmd.h"
  45
  46 /*
  47  * Needed for creating nspr handle from unix fd
  48  */
  49 #include <private/pprio.h>
  50
  51 static void
  52 qdevice_net_poll_read_socket(struct qdevice_net_instance *instance)
  53 {
  54
  55         if (qdevice_net_socket_read(instance) == -1) {
  56                 instance->schedule_disconnect = 1;
  57         }
  58 }
  59
  60 static void
  61 qdevice_net_poll_read_votequorum(struct qdevice_net_instance *instance)
  62 {
  63
  64         if (qdevice_votequorum_dispatch(instance->qdevice_instance_ptr) == -1) {
  65                 instance->schedule_disconnect = 1;
  66                 instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_COROSYNC_CONNECTION_CLOSED;
  67         }
  68 }
  69
  70 static void
  71 qdevice_net_poll_read_cmap(struct qdevice_net_instance *instance)
  72 {
  73
  74         if (qdevice_cmap_dispatch(instance->qdevice_instance_ptr) == -1) {
  75                 instance->schedule_disconnect = 1;
  76                 instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_COROSYNC_CONNECTION_CLOSED;
  77         }
  78 }
  79
  80 static void
  81 qdevice_net_poll_write_socket(struct qdevice_net_instance *instance, const PRPollDesc *pfd)
  82 {
  83         int res;
  84
  85         if (instance->state == QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT) {
  86                 res = nss_sock_non_blocking_client_succeeded(pfd);
  87                 if (res == -1) {
  88                         /*
  89                          * Connect failed -> try next
  90                          */
  91                         res = nss_sock_non_blocking_client_try_next(&instance->non_blocking_client);
  92                         if (res == -1) {
  93                                 qdevice_log_nss(LOG_ERR, "Can't connect to qnetd host.");
  94                                 nss_sock_non_blocking_client_destroy(&instance->non_blocking_client);
  95                         }
  96                 } else if (res == 0) {
  97                         /*
  98                          * Poll again
  99                          */
 100                 } else if (res == 1) {
 101                         /*
 102                          * Connect success
 103                          */
 104                         instance->socket = instance->non_blocking_client.socket;
 105                         nss_sock_non_blocking_client_destroy(&instance->non_blocking_client);
 106                         instance->non_blocking_client.socket = NULL;
 107
 108                         instance->state = QDEVICE_NET_INSTANCE_STATE_SENDING_PREINIT_REPLY;
 109
 110                         qdevice_log(LOG_DEBUG, "Sending preinit msg to qnetd");
 111                         if (qdevice_net_send_preinit(instance) != 0) {
 112                                 instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
 113                                 instance->schedule_disconnect = 1;
 114                         }
 115                 } else {
 116                         qdevice_log(LOG_CRIT, "Unhandled nss_sock_non_blocking_client_succeeded");
 117                         exit(1);
 118                 }
 119         } else {
 120                 if (qdevice_net_socket_write(instance) == -1) {
 121                         instance->schedule_disconnect = 1;
 122                 }
 123         }
 124 }
 125
 126 static void
 127 qdevice_net_poll_err_socket(struct qdevice_net_instance *instance, const PRPollDesc *pfd)
 128 {
 129
 130         if (instance->state == QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT) {
 131                 /*
 132                  * Workaround for RHEL<7. Pollout is never set for nonblocking connect (doesn't work
 133                  * only with poll, select works as expected!???).
 134                  * So test if client is still valid and if pollout was not already called (ensured
 135                  * by default because of order in PR_Poll).
 136                  * If both applies it's possible to emulate pollout set by calling poll_write.
 137                  */
 138                 if (!instance->non_blocking_client.destroyed) {
 139                         qdevice_net_poll_write_socket(instance, pfd);
 140                 }
 141         } else {
 142                 qdevice_log(LOG_ERR, "POLL_ERR (%u) on main socket", pfd->out_flags);
 143
 144                 instance->schedule_disconnect = 1;
 145                 instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_SERVER_CLOSED_CONNECTION;
 146         }
 147 }
 148
 149 static void
 150 qdevice_net_poll_read_heuristics_log(struct qdevice_net_instance *instance)
 151 {
 152         int res;
 153
 154         res = qdevice_heuristics_log_read_from_pipe(&instance->qdevice_instance_ptr->heuristics_instance);
 155         if (res == -1) {
 156                 instance->schedule_disconnect = 1;
 157                 instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_WORKER_CLOSED;
 158         }
 159 }
 160
 161 static void
 162 qdevice_net_poll_read_heuristics_cmd(struct qdevice_net_instance *instance)
 163 {
 164         int res;
 165
 166         res = qdevice_heuristics_cmd_read_from_pipe(&instance->qdevice_instance_ptr->heuristics_instance);
 167         if (res == -1) {
 168                 instance->schedule_disconnect = 1;
 169                 instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_WORKER_CLOSED;
 170         }
 171 }
 172
 173 static void
 174 qdevice_net_poll_write_heuristics_cmd(struct qdevice_net_instance *instance)
 175 {
 176         int res;
 177
 178         res = qdevice_heuristics_cmd_write(&instance->qdevice_instance_ptr->heuristics_instance);
 179         if (res == -1) {
 180                 instance->schedule_disconnect = 1;
 181                 instance->disconnect_reason =
 182                     QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_CANT_SEND_RECEIVE_MSG;
 183         }
 184 }
 185
 186 static void
 187 qdevice_net_poll_read_ipc_socket(struct qdevice_net_instance *instance)
 188 {
 189         struct unix_socket_client *client;
 190         PRFileDesc *prfd;
 191         struct qdevice_ipc_user_data *user_data;
 192
 193         if (qdevice_ipc_accept(instance->qdevice_instance_ptr, &client) != 0) {
 194                 return ;
 195         }
 196
 197         prfd = PR_CreateSocketPollFd(client->socket);
 198         if (prfd == NULL) {
 199                 qdevice_log_nss(LOG_CRIT, "Can't create NSPR poll fd for IPC client. "
 200                     "Disconnecting client");
 201                 qdevice_ipc_client_disconnect(instance->qdevice_instance_ptr, client);
 202
 203                 return ;
 204         }
 205
 206         user_data = (struct qdevice_ipc_user_data *)client->user_data;
 207         user_data->model_data = (void *)prfd;
 208 }
 209
 210 static PRPollDesc *
 211 qdevice_net_pr_poll_array_create(struct qdevice_net_instance *instance)
 212 {
 213         struct pr_poll_array *poll_array;
 214         PRPollDesc *poll_desc;
 215         struct qdevice_net_poll_array_user_data *user_data;
 216         struct unix_socket_client *ipc_client;
 217         const struct unix_socket_client_list *ipc_client_list;
 218         struct qdevice_ipc_user_data *qdevice_ipc_user_data;
 219
 220         poll_array = &instance->poll_array;
 221         ipc_client_list = &instance->qdevice_instance_ptr->local_ipc.clients;
 222
 223         if (qdevice_ipc_is_closed(instance->qdevice_instance_ptr)) {
 224                 qdevice_log(LOG_DEBUG, "Local socket is closed");
 225                 instance->schedule_disconnect = 1;
 226                 instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_LOCAL_SOCKET_CLOSED;
 227
 228                 return (NULL);
 229         }
 230
 231         pr_poll_array_clean(poll_array);
 232
 233         if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 234                 return (NULL);
 235         }
 236         poll_desc->fd = instance->votequorum_poll_fd;
 237         poll_desc->in_flags = PR_POLL_READ;
 238         user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM;
 239
 240         if (!instance->qdevice_instance_ptr->sync_in_progress) {
 241                 if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 242                         return (NULL);
 243                 }
 244                 poll_desc->fd = instance->cmap_poll_fd;
 245                 poll_desc->in_flags = PR_POLL_READ;
 246                 user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP;
 247         }
 248
 249         if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 250                 return (NULL);
 251         }
 252         poll_desc->fd = instance->ipc_socket_poll_fd;
 253         poll_desc->in_flags = PR_POLL_READ;
 254         user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET;
 255
 256         if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 257                 return (NULL);
 258         }
 259
 260         poll_desc->fd = instance->heuristics_pipe_log_recv_poll_fd;
 261         poll_desc->in_flags = PR_POLL_READ;
 262         user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV;
 263
 264         if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 265                 return (NULL);
 266         }
 267
 268         poll_desc->fd = instance->heuristics_pipe_cmd_recv_poll_fd;
 269         poll_desc->in_flags = PR_POLL_READ;
 270         user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV;
 271
 272         if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 273                 return (NULL);
 274         }
 275
 276         if (!send_buffer_list_empty(
 277             &instance->qdevice_instance_ptr->heuristics_instance.cmd_out_buffer_list)) {
 278                 poll_desc->fd = instance->heuristics_pipe_cmd_send_poll_fd;
 279                 poll_desc->in_flags = PR_POLL_WRITE;
 280                 user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND;
 281
 282                 if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 283                         return (NULL);
 284                 }
 285         }
 286
 287         if (instance->state != QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT ||
 288             !instance->non_blocking_client.destroyed) {
 289                 if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 290                         return (NULL);
 291                 }
 292
 293                 user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET;
 294
 295                 if (instance->state == QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT) {
 296                         poll_desc->fd = instance->non_blocking_client.socket;
 297                         poll_desc->in_flags = PR_POLL_WRITE | PR_POLL_EXCEPT;
 298                 } else {
 299                         poll_desc->fd = instance->socket;
 300                         poll_desc->in_flags = PR_POLL_READ;
 301
 302                         if (!send_buffer_list_empty(&instance->send_buffer_list)) {
 303                                 poll_desc->in_flags |= PR_POLL_WRITE;
 304                         }
 305                 }
 306         }
 307
 308         TAILQ_FOREACH(ipc_client, ipc_client_list, entries) {
 309                 if (!ipc_client->reading_line && !ipc_client->writing_buffer) {
 310                         continue;
 311                 }
 312
 313                 if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
 314                         return (NULL);
 315                 }
 316
 317                 qdevice_ipc_user_data = (struct qdevice_ipc_user_data *)ipc_client->user_data;
 318                 poll_desc->fd = (PRFileDesc *)qdevice_ipc_user_data->model_data;
 319                 if (ipc_client->reading_line) {
 320                         poll_desc->in_flags |= PR_POLL_READ;
 321                 }
 322
 323                 if (ipc_client->writing_buffer) {
 324                         poll_desc->in_flags |= PR_POLL_WRITE;
 325                 }
 326
 327                 user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT;
 328                 user_data->ipc_client = ipc_client;
 329         }
 330
 331         pr_poll_array_gc(poll_array);
 332
 333         return (poll_array->array);
 334 }
 335
 336 int
 337 qdevice_net_poll(struct qdevice_net_instance *instance)
 338 {
 339         PRPollDesc *pfds;
 340         PRFileDesc *prfd;
 341         PRInt32 poll_res;
 342         ssize_t i;
 343         struct qdevice_net_poll_array_user_data *user_data;
 344         struct unix_socket_client *ipc_client;
 345         struct qdevice_ipc_user_data *qdevice_ipc_user_data;
 346         int case_processed;
 347
 348         pfds = qdevice_net_pr_poll_array_create(instance);
 349         if (pfds == NULL) {
 350                 return (-1);
 351         }
 352
 353         instance->schedule_disconnect = 0;
 354
 355         if ((poll_res = PR_Poll(pfds, pr_poll_array_size(&instance->poll_array),
 356             timer_list_time_to_expire(&instance->main_timer_list))) > 0) {
 357                 for (i = 0; i < pr_poll_array_size(&instance->poll_array); i++) {
 358                         user_data = pr_poll_array_get_user_data(&instance->poll_array, i);
 359
 360                         ipc_client = user_data->ipc_client;
 361
 362                         if (pfds[i].out_flags & PR_POLL_READ) {
 363                                 case_processed = 0;
 364
 365                                 switch (user_data->type) {
 366                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET:
 367                                         case_processed = 1;
 368                                         qdevice_net_poll_read_socket(instance);
 369                                         break;
 370                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM:
 371                                         case_processed = 1;
 372                                         qdevice_net_poll_read_votequorum(instance);
 373                                         break;
 374                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP:
 375                                         case_processed = 1;
 376                                         qdevice_net_poll_read_cmap(instance);
 377                                         break;
 378                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET:
 379                                         case_processed = 1;
 380                                         qdevice_net_poll_read_ipc_socket(instance);
 381                                         break;
 382                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT:
 383                                         case_processed = 1;
 384                                         qdevice_ipc_io_read(instance->qdevice_instance_ptr, ipc_client);
 385                                         break;
 386                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND:
 387                                         /*
 388                                          * Read on heuristics cmd send fd shouldn't happen
 389                                          */
 390                                         break;
 391                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV:
 392                                         case_processed = 1;
 393                                         qdevice_net_poll_read_heuristics_cmd(instance);
 394                                         break;
 395                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV:
 396                                         case_processed = 1;
 397                                         qdevice_net_poll_read_heuristics_log(instance);
 398                                         break;
 399                                 /*
 400                                  * Default is not defined intentionally. Compiler shows warning when
 401                                  * new poll_array_user_data_type is added
 402                                  */
 403                                 }
 404
 405                                 if (!case_processed) {
 406                                         qdevice_log(LOG_CRIT, "Unhandled read on poll descriptor %u", i);
 407                                         exit(1);
 408                                 }
 409                         }
 410
 411                         if (!instance->schedule_disconnect && pfds[i].out_flags & PR_POLL_WRITE) {
 412                                 case_processed = 0;
 413
 414                                 switch (user_data->type) {
 415                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET:
 416                                         case_processed = 1;
 417                                         qdevice_net_poll_write_socket(instance, &pfds[i]);
 418                                         break;
 419                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT:
 420                                         case_processed = 1;
 421                                         qdevice_ipc_io_write(instance->qdevice_instance_ptr, ipc_client);
 422                                         break;
 423                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND:
 424                                         case_processed = 1;
 425                                         qdevice_net_poll_write_heuristics_cmd(instance);
 426                                         break;
 427                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM:
 428                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP:
 429                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET:
 430                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV:
 431                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV:
 432                                         /*
 433                                          * Write on votequorum, cmap, ipc socket and
 434                                          * heuristics log shouldn't happen.
 435                                          */
 436                                         break;
 437                                 /*
 438                                  * Default is not defined intentionally. Compiler shows warning when
 439                                  * new poll_array_user_data_type is added
 440                                  */
 441                                 }
 442
 443                                 if (!case_processed) {
 444                                         qdevice_log(LOG_CRIT, "Unhandled write on poll descriptor %u", i);
 445                                         exit(1);
 446                                 }
 447                         }
 448
 449                         if (!instance->schedule_disconnect &&
 450                             (pfds[i].out_flags & (PR_POLL_ERR|PR_POLL_NVAL|PR_POLL_HUP|PR_POLL_EXCEPT)) &&
 451                             !(pfds[i].out_flags & (PR_POLL_READ|PR_POLL_WRITE))) {
 452                                 case_processed = 0;
 453
 454                                 switch (user_data->type) {
 455                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET:
 456                                         case_processed = 1;
 457                                         qdevice_net_poll_err_socket(instance, &pfds[i]);
 458                                         break;
 459                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET:
 460                                         case_processed = 1;
 461                                         if (pfds[i].out_flags != PR_POLL_NVAL) {
 462                                                 qdevice_log(LOG_CRIT, "POLLERR (%u) on local socket",
 463                                                     pfds[i].out_flags);
 464                                                 exit(1);
 465                                         } else {
 466                                                 qdevice_log(LOG_DEBUG, "Local socket is closed");
 467                                                 instance->schedule_disconnect = 1;
 468                                                 instance->disconnect_reason =
 469                                                     QDEVICE_NET_DISCONNECT_REASON_LOCAL_SOCKET_CLOSED;
 470                                         }
 471                                         break;
 472                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT:
 473                                         case_processed = 1;
 474                                         qdevice_log(LOG_DEBUG, "POLL_ERR (%u) on ipc client socket. "
 475                                             "Disconnecting.",  pfds[i].out_flags);
 476                                         ipc_client->schedule_disconnect = 1;
 477                                         break;
 478                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM:
 479                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP:
 480                                         case_processed = 1;
 481                                         qdevice_log(LOG_DEBUG, "POLL_ERR (%u) on corosync socket. "
 482                                             "Disconnecting.",  pfds[i].out_flags);
 483
 484                                         instance->schedule_disconnect = 1;
 485                                         instance->disconnect_reason =
 486                                                 QDEVICE_NET_DISCONNECT_REASON_COROSYNC_CONNECTION_CLOSED;
 487                                         break;
 488                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV:
 489                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV:
 490                                 case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND:
 491                                         case_processed = 1;
 492
 493                                         /*
 494                                          * Closed pipe doesn't mean return of PR_POLL_READ. To display
 495                                          * better log message, we call read log as if POLL_READ would
 496                                          * be set.
 497                                          */
 498                                         qdevice_net_poll_read_heuristics_log(instance);
 499
 500                                         qdevice_log(LOG_DEBUG, "POLL_ERR (%u) on heuristics pipe. "
 501                                             "Disconnecting.",  pfds[i].out_flags);
 502
 503                                         instance->schedule_disconnect = 1;
 504                                         instance->disconnect_reason =
 505                                                 QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_WORKER_CLOSED;
 506                                         break;
 507                                 /*
 508                                  * Default is not defined intentionally. Compiler shows warning when
 509                                  * new poll_array_user_data_type is added
 510                                  */
 511                                 }
 512
 513                                 if (!case_processed) {
 514                                         qdevice_log(LOG_CRIT, "Unhandled error on poll descriptor %u", i);
 515                                         exit(1);
 516                                 }
 517                         }
 518
 519                         if (user_data->type == QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT &&
 520                             ipc_client->schedule_disconnect) {
 521                                 qdevice_ipc_user_data = (struct qdevice_ipc_user_data *)ipc_client->user_data;
 522                                 prfd = (PRFileDesc *)qdevice_ipc_user_data->model_data;
 523
 524                                 if (PR_DestroySocketPollFd(prfd) != PR_SUCCESS) {
 525                                         qdevice_log_nss(LOG_WARNING, "Unable to destroy client IPC poll socket fd");
 526                                 }
 527
 528                                 qdevice_ipc_client_disconnect(instance->qdevice_instance_ptr, ipc_client);
 529                         }
 530                 }
 531         }
 532
 533         if (!instance->schedule_disconnect) {
 534                 timer_list_expire(&instance->main_timer_list);
 535         }
 536
 537         if (instance->schedule_disconnect) {
 538                 /*
 539                  * Schedule disconnect can be set by this function, by some timer_list callback
 540                  * or cmap/votequorum callbacks
 541                  */
 542                 return (-1);
 543         }
 544
 545         return (0);
 546 }