--- old/usr/src/test/os-tests/tests/file-locking/util.c
          +++ new/usr/src/test/os-tests/tests/file-locking/util.c

   1    1  /*
   2    2   * This file and its contents are supplied under the terms of the
   3    3   * Common Development and Distribution License ("CDDL"), version 1.0.
   4    4   * You may only use this file in accordance with the terms of version
   5    5   * 1.0 of the CDDL.
   6    6   *
   7    7   * A full copy of the text of the CDDL should have accompanied this
   8    8   * source.  A copy of the CDDL is also available via the Internet at
   9    9   * http://www.illumos.org/license/CDDL.
  10   10   */
  11   11  
  12   12  /*
  13   13   * Copyright 2016 Joyent, Inc.
  14   14   */
  15   15  
  16   16  /*
  17   17   * Utility functions for use in both acquire-lock and runtests.
  18   18   */
  19   19  
  20   20  #include "util.h"
  21   21  #include <err.h>
  22   22  #include <errno.h>
  23   23  #include <poll.h>
  24   24  #include <stdarg.h>
  25   25  #include <stdio.h>
  26   26  #include <stdlib.h>
  27   27  #include <strings.h>
  28   28  #include <unistd.h>
  29   29  
  30   30  
  31   31  boolean_t LOG = B_FALSE;
  32   32  
  33   33  
  34   34  void
  35   35  flock_log(const char *format, ...)
  36   36  {
  37   37          va_list ap;
  38   38          if (!LOG) {
  39   39                  return;
  40   40          }
  41   41  
  42   42          va_start(ap, format);
  43   43          (void) vfprintf(stderr, format, ap);
  44   44          va_end(ap);
  45   45  }
  46   46  
  47   47  
  48   48  boolean_t
  49   49  flock_nodata(int fd)
  50   50  {
  51   51          struct pollfd pfd = { fd, POLLIN, 0 };
  52   52          int ret = poll(&pfd, 1, 1000);
  53   53  
  54   54          if (ret == -1) {
  55   55                  err(EXIT_FAILURE, "poll failed");
  56   56          }
  57   57  
  58   58          return (ret == 0);
  59   59  }
  60   60  
  61   61  
  62   62  void
  63   63  flock_block(int fd)
  64   64  {
  65   65          char buf[1];
  66   66          int ret = 0;
  67   67          while (ret < 1) {
  68   68                  ret = read(fd, buf, 1);
  69   69                  if (ret == -1) {
  70   70                          if (errno == EINTR)
  71   71                                  continue;
  72   72                          err(EXIT_FAILURE, "read failed");
  73   73                  }
  74   74          }
  75   75  }
  76   76  
  77   77  
  78   78  void
  79   79  flock_alert(int fd)
  80   80  {
  81   81          int ret = 0;
  82   82          while (ret < 1) {
  83   83                  ret = write(fd, "1", 1);
  84   84                  if (ret == -1) {
  85   85                          if (errno == EINTR)
  86   86                                  continue;
  87   87                          err(EXIT_FAILURE, "write failed");
  88   88                  }
  89   89          }
  90   90  }
  91   91  
  92   92  
  93   93  lock_style_t
  94   94  flock_styleenum(char *stylestr)
  95   95  {
  96   96          if (strcmp(stylestr, "posix") == 0) {
  97   97                  return (LSTYLE_POSIX);
  98   98          } else if (strcmp(stylestr, "ofd") == 0) {
  99   99                  return (LSTYLE_OFD);
 100  100          } else if (strcmp(stylestr, "flock") == 0) {
 101  101                  return (LSTYLE_FLOCK);
 102  102          } else {
 103  103                  errx(EXIT_FAILURE, BAD_LOCK_MESSAGE);
 104  104                  return (LSTYLE_LAST);
 105  105          }
 106  106  }
 107  107  
 108  108  
 109  109  char *
 110  110  flock_stylestr(lock_style_t style)
 111  111  {
 112  112          switch (style) {
 113  113          case LSTYLE_POSIX:
 114  114                  return ("posix");
 115  115          case LSTYLE_OFD:
 116  116                  return ("ofd");
 117  117          case LSTYLE_FLOCK:
 118  118                  return ("flock");
 119  119          default:
 120  120                  abort();
 121  121                  return ("<unreachable>");
 122  122          }
 123  123  }
 124  124  
 125  125  
 126  126  char *
 127  127  flock_stylename(lock_style_t style)
 128  128  {
 129  129          switch (style) {
 130  130          case LSTYLE_POSIX:
 131  131                  return ("fcntl(2) POSIX");
 132  132          case LSTYLE_OFD:
 133  133                  return ("fcntl(2) OFD");
 134  134          case LSTYLE_FLOCK:
 135  135                  return ("flock(3C)");
 136  136          default:
 137  137                  abort();
 138  138                  return ("<unreachable>");
 139  139          }
 140  140  }
 141  141  
 142  142  
 143  143  void
 144  144  flock_reinit(struct flock *flp, int ltype)
 145  145  {
 146  146          bzero(flp, sizeof (*flp));
 147  147          flp->l_type = ltype;
 148  148  }
 149  149  
 150  150  
 151  151  char *
 152  152  flock_cmdname(int cmd)
 153  153  {
 154  154          switch (cmd) {
 155  155          case F_SETLK:
 156  156                  return ("F_SETLK");
 157  157          case F_OFD_SETLK:
 158  158                  return ("F_OFD_SETLK");
 159  159          case F_SETLKW:
 160  160                  return ("F_SETLKW");
 161  161          case F_OFD_SETLKW:
 162  162                  return ("F_OFD_SETLKW");
 163  163          case F_GETLK:
 164  164                  return ("F_GETLK");
 165  165          case F_OFD_GETLK:
 166  166                  return ("F_OFD_GETLK");
 167  167          case F_FLOCK:
 168  168                  return ("F_FLOCK");
 169  169          case F_FLOCKW:
 170  170                  return ("F_FLOCKW");
 171  171          default:
 172  172                  abort();
 173  173                  return ("<unreachable>");
 174  174          }
 175  175  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX