libsysio/src/fcntl.c

   1 /*
   2  *    This Cplant(TM) source code is the property of Sandia National
   3  *    Laboratories.
   4  *
   5  *    This Cplant(TM) source code is copyrighted by Sandia National
   6  *    Laboratories.
   7  *
   8  *    The redistribution of this Cplant(TM) source code is subject to the
   9  *    terms of the GNU Lesser General Public License
  10  *    (see cit/LGPL or http://www.gnu.org/licenses/lgpl.html)
  11  *
  12  *    Cplant(TM) Copyright 1998-2005 Sandia Corporation.
  13  *    Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
  14  *    license for use of this work by or on behalf of the US Government.
  15  *    Export of this program may require a license from the United States
  16  *    Government.
  17  */
  18
  19 /*
  20  * This library is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU Lesser General Public
  22  * License as published by the Free Software Foundation; either
  23  * version 2.1 of the License, or (at your option) any later version.
  24  *
  25  * This library is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  28  * Lesser General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU Lesser General Public
  31  * License along with this library; if not, write to the Free Software
  32  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  33  *
  34  * Questions or comments about this library should be sent to:
  35  *
  36  * Lee Ward
  37  * Sandia National Laboratories, New Mexico
  38  * P.O. Box 5800
  39  * Albuquerque, NM 87185-1110
  40  *
  41  * lee@sandia.gov
  42  */
  43
  44 #include <string.h>
  45 #include <stdlib.h>
  46 #include <errno.h>
  47 #include <assert.h>
  48 #include <sys/types.h>
  49 #include <sys/stat.h>
  50 #include <unistd.h>
  51 #include <fcntl.h>
  52 #include <sys/queue.h>
  53
  54 #include "sysio.h"
  55 #include "inode.h"
  56 #include "file.h"
  57
  58 #include "sysio-symbols.h"
  59
  60 #ifdef HAVE_LUSTRE_HACK
  61 #include <sys/syscall.h>
  62 #include <native.h>
  63 #endif
  64
  65 #ifdef HAVE_LUSTRE_HACK
  66 static int
  67 _sysio_lustre_fcntl(int fd, int cmd, va_list ap, int *rtn)
  68 {
  69         long arg = va_arg(ap, long);
  70
  71         *rtn = syscall(SYSIO_SYS_fcntl, fd, cmd, arg);
  72         return *rtn == -1 ? -errno : 0;
  73 }
  74 #endif
  75
  76 static int
  77 _sysio_fcntl_raw_call(struct inode *ino, int *r, int cmd, ...)
  78 {
  79         va_list ap;
  80         int     err;
  81
  82         va_start(ap, cmd);
  83         err = ino->i_ops.inop_fcntl(ino, cmd, ap, r);
  84         va_end(ap);
  85         return err;
  86 }
  87
  88 /*
  89  * Convert offsets to absolute, when appropriate, and call appropriate driver
  90  * to complete the fcntl lock function. If successful, convert
  91  * returned values back to appropriate form.
  92  */
  93 static int
  94 _sysio_fcntl_lock(struct file *fil, int cmd, struct _SYSIO_FLOCK *fl)
  95 {
  96         struct _SYSIO_FLOCK flock;
  97         _SYSIO_OFF_T pos;
  98         int     err;
  99         int     rtn;
 100
 101         /*
 102          * The drivers will not have a clue as to the
 103          * current position of the file pointer. We need to
 104          * convert relative whence values to absolute
 105          * file adresses for them, then.
 106          */
 107         flock = *fl;
 108         switch (flock.l_whence) {
 109         case SEEK_SET:
 110                 /*
 111                  * At least parameter check this one, too.
 112                  */
 113         case SEEK_CUR:
 114         case SEEK_END:
 115                 pos =
 116                     _sysio_lseek_prepare(fil,
 117                                          flock.l_start,
 118                                          flock.l_whence,
 119                                          _SEEK_MAX(fil));
 120                 if (pos < 0)
 121                         return (int )pos;
 122                 flock.l_start = pos;
 123                 flock.l_whence = SEEK_SET;
 124                 break;
 125         default:
 126                 return -EINVAL;
 127         }
 128         err =
 129             _sysio_fcntl_raw_call(fil->f_ino, &rtn, cmd, &flock);
 130         if (err)
 131                 return err;
 132         /*
 133          * Ugh, convert back to relative form.
 134          */
 135         switch (fl->l_whence) {
 136         case SEEK_SET:
 137                 break;
 138         case SEEK_CUR:
 139                 fl->l_start = flock.l_start;
 140                 fl->l_start -= fil->f_pos;
 141                 break;
 142         case SEEK_END:
 143                 fl->l_start = flock.l_start;
 144                 fl->l_start -=
 145                     fil->f_ino->i_stbuf.st_size;
 146                 break;
 147         default:
 148                 abort();
 149         }
 150         /*
 151          * Return success.
 152          */
 153         return 0;
 154 }
 155
 156 static int
 157 _sysio_vfcntl(int fd, int cmd, va_list ap)
 158 {
 159         int     err;
 160         int     rtn;
 161         struct file *fil;
 162         SYSIO_INTERFACE_DISPLAY_BLOCK;
 163
 164         SYSIO_INTERFACE_ENTER;
 165         err = 0;
 166         fil = _sysio_fd_find(fd);
 167         if (!fil) {
 168 #ifdef HAVE_LUSTRE_HACK
 169                 err = _sysio_lustre_fcntl(fd, cmd, ap, &rtn);
 170                 goto out;
 171 #else
 172                 rtn = -1;
 173                 err = -EBADF;
 174                 goto out;
 175 #endif
 176         }
 177
 178         switch (cmd) {
 179
 180             case F_DUPFD:
 181                 {
 182                         long    newfd;
 183
 184                         newfd = va_arg(ap, long);
 185                         if (newfd != (int )newfd || newfd < 0) {
 186                                 rtn = -1;
 187                                 err = -EBADF;
 188                                 goto out;
 189                         }
 190                         rtn = _sysio_fd_dup(fd, (int )newfd, 0);
 191                         if (rtn < 0) {
 192                                 err = rtn;
 193                                 rtn = -1;
 194                         }
 195                 }
 196                 break;
 197 #if !(defined(_LARGEFILE64_SOURCE) || F_GETLK64 == F_GETLK)
 198             case F_GETLK:
 199             case F_SETLK:
 200             case F_SETLKW:
 201                 {
 202                         struct intnl_stat buf;
 203                         struct flock *fl;
 204 #ifdef _LARGEFILE64_SOURCE
 205                         struct _SYSIO_FLOCK flock64;
 206 #endif
 207
 208                         /*
 209                          * Refresh the cached attributes.
 210                          */
 211                         err =
 212                             fil->f_ino->i_ops.inop_getattr(NULL,
 213                                                            fil->f_ino,
 214                                                            &buf);
 215                         if (err) {
 216                                 rtn = -1;
 217                                 break;
 218                         }
 219                         /*
 220                          * Copy args to a temp and normalize.
 221                          */
 222                         fl = va_arg(ap, struct flock *);
 223 #ifdef _LARGEFILE64_SOURCE
 224                         flock64.l_type = fl->l_type;
 225                         flock64.l_whence = fl->l_whence;
 226                         flock64.l_start = fl->l_start;
 227                         flock64.l_len = fl->l_len;
 228                         flock64.l_pid = fl->l_pid;
 229                         err = _sysio_fcntl_lock(fil, cmd, &flock64);
 230 #else
 231                         err = _sysio_fcntl_lock(fil, cmd, fl);
 232 #endif
 233                         if (err < 0) {
 234                                 rtn = -1;
 235                                 break;
 236                         }
 237 #ifdef _LARGEFILE64_SOURCE
 238                         /*
 239                          * Copy back. Note that the fcntl_lock call
 240                          * should have ensured that no overflow was possible.
 241                          */
 242                         fl->l_type = flock64.l_type;
 243                         fl->l_whence = flock64.l_whence;
 244                         fl->l_start = flock64.l_start;
 245                         assert(fl->l_start == flock64.l_start);
 246                         fl->l_len = flock64.l_len;
 247                         assert(fl->l_len == flock64.l_len);
 248                         fl->l_pid = flock64.l_pid;
 249 #endif
 250                         rtn = 0;
 251                 }
 252                 break;
 253 #endif /* !(_LARGEFILE64_SOURCE || F_GETLK64 == F_GETLK) */
 254 #ifdef _LARGEFILE64_SOURCE
 255             case F_GETLK64:
 256             case F_SETLK64:
 257             case F_SETLKW64:
 258                         {
 259                                 struct flock64 *fl64;
 260
 261                                 fl64 = va_arg(ap, struct flock64 *);
 262                                 err = _sysio_fcntl_lock(fil, cmd, fl64);
 263                                 rtn = err ? -1 : 0;
 264                         }
 265                 break;
 266 #endif
 267             default:
 268                 err = fil->f_ino->i_ops.inop_fcntl(fil->f_ino, cmd, ap, &rtn);
 269                 break;
 270         }
 271
 272 out:
 273         SYSIO_INTERFACE_RETURN(rtn, err);
 274 }
 275
 276 int
 277 SYSIO_INTERFACE_NAME(fcntl)(int fd, int cmd, ...)
 278 {
 279         va_list ap;
 280         int     err;
 281
 282         va_start(ap, cmd);
 283         err = _sysio_vfcntl(fd, cmd, ap);
 284         va_end(ap);
 285         return err;
 286 }
 287
 288 sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(fcntl),
 289                      SYSIO_INTERFACE_NAME(fcntl64))
 290
 291 #ifdef __GLIBC__
 292 #undef __fcntl
 293 sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(fcntl),
 294                      PREPEND(__, SYSIO_INTERFACE_NAME(fcntl)))
 295 #endif
 296
 297 #ifdef BSD
 298 #undef _fcntl
 299 sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(fcntl),
 300                      PREPEND(_, SYSIO_INTERFACE_NAME(fcntl)))
 301 #endif