libsysio/drivers/native/fs_native.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-2004 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 #ifdef __linux__
  45 #define _BSD_SOURCE
  46 #endif
  47
  48 #include <stdio.h>                                      /* for NULL */
  49 #include <stdlib.h>
  50 #ifdef __linux__
  51 #include <string.h>
  52 #endif
  53 #include <unistd.h>
  54 #if !(defined(REDSTORM) || defined(MAX_IOVEC))
  55 #include <limits.h>
  56 #endif
  57 #include <errno.h>
  58 #include <assert.h>
  59 #include <syscall.h>
  60 #include <sys/time.h>
  61 #include <sys/types.h>
  62 #include <sys/stat.h>
  63 #include <sys/fcntl.h>
  64 #if 0
  65 #include <sys/vfs.h>
  66 #endif
  67 #ifdef _HAVE_STATVFS
  68 #include <sys/statvfs.h>
  69 #include <sys/statfs.h>
  70 #endif
  71 #include <utime.h>
  72 #include <sys/uio.h>
  73 #include <sys/queue.h>
  74
  75 #include "sysio.h"
  76 #include "xtio.h"
  77 #include "native.h"
  78 #include "fs.h"
  79 #include "mount.h"
  80 #include "inode.h"
  81
  82 #include "fs_native.h"
  83
  84 #ifdef REDSTORM
  85 #include <sys/uio.h>
  86 #endif
  87
  88 #if defined(SYSIO_SYS_getdirentries)
  89 #define DIR_CVT_64 0
  90 #elif defined(SYSIO_SYS_getdents64)
  91 #define DIR_CVT_64 0
  92 #elif defined(SYSIO_SYS_getdents)
  93 #if defined(_LARGEFILE64_SOURCE)
  94 #define DIR_CVT_64 1
  95 /*
  96  * Kernel version of directory entry.
  97  */
  98 struct linux_dirent {
  99         unsigned long ld_ino;
 100         unsigned long ld_off;
 101         unsigned short ld_reclen;
 102         char    ld_name[1];
 103 };
 104 #include <dirent.h>
 105 #else /* !defined(_LARGEFILE64_SOURCE) */
 106 #define DIR_CVT_64 0
 107 #endif /* defined(_LARGEFILE64_SOURCE) */
 108 #else /* catch-none */
 109 #error No usable directory fill entries interface available
 110 #endif
 111
 112 /*
 113  * Native file system information we keep per FS.
 114  */
 115 struct native_filesystem {
 116         time_t  nfs_atimo;                              /* attr timeout (sec) */
 117 };
 118
 119 /*
 120  * Given fs, return driver private part.
 121  */
 122 #define FS2NFS(fs) \
 123         ((struct native_filesystem *)(fs)->fs_private)
 124
 125 /*
 126  * Native file identifiers format.
 127  */
 128 struct native_inode_identifier {
 129         dev_t   dev;                                    /* device number */
 130         ino_t   ino;                                    /* i-number */
 131 #ifdef HAVE_GENERATION
 132         unsigned int gen;                               /* generation number */
 133 #endif
 134 };
 135
 136 /*
 137  * Driver-private i-node information we keep about local host file
 138  * system objects.
 139  */
 140 struct native_inode {
 141         unsigned
 142                 ni_seekok               : 1,            /* can seek? */
 143                 ni_attrvalid            : 1,            /* cached attrs ok? */
 144                 ni_resetfpos            : 1;            /* reset fpos? */
 145         struct native_inode_identifier ni_ident;        /* unique identifier */
 146         struct file_identifier ni_fileid;               /* ditto */
 147         int     ni_fd;                                  /* host fildes */
 148         int     ni_oflags;                              /* flags, from open */
 149         unsigned ni_nopens;                             /* soft ref count */
 150         _SYSIO_OFF_T ni_fpos;                           /* current pos */
 151         time_t  ni_attrtim;                             /* attrs expire time */
 152 };
 153
 154 /*
 155  * Cached attributes usable?
 156  */
 157 #define NATIVE_ATTRS_VALID(nino, t) \
 158         ((nino)->ni_attrtim && (t) < (nino)->ni_attrtim)
 159
 160 /*
 161  * Native IO path arguments.
 162  */
 163 struct native_io {
 164         char    nio_op;                                 /* 'r' or 'w' */
 165         struct native_inode *nio_nino;                  /* native ino */
 166 };
 167
 168 static int native_inop_lookup(struct pnode *pno,
 169                               struct inode **inop,
 170                               struct intent *intnt,
 171                               const char *path);
 172 static int native_inop_getattr(struct pnode *pno,
 173                                struct inode *ino,
 174                                struct intnl_stat *stbuf);
 175 static int native_inop_setattr(struct pnode *pno,
 176                                struct inode *ino,
 177                                unsigned mask,
 178                                struct intnl_stat *stbuf);
 179 static ssize_t native_filldirentries(struct inode *ino,
 180                                      _SYSIO_OFF_T *posp,
 181                                      char *buf,
 182                                      size_t nbytes);
 183 static int native_inop_mkdir(struct pnode *pno, mode_t mode);
 184 static int native_inop_rmdir(struct pnode *pno);
 185 static int native_inop_symlink(struct pnode *pno, const char *data);
 186 static int native_inop_readlink(struct pnode *pno, char *buf, size_t bufsiz);
 187 static int native_inop_open(struct pnode *pno, int flags, mode_t mode);
 188 static int native_inop_close(struct inode *ino);
 189 static int native_inop_link(struct pnode *old, struct pnode *new);
 190 static int native_inop_unlink(struct pnode *pno);
 191 static int native_inop_rename(struct pnode *old, struct pnode *new);
 192 static int native_inop_read(struct inode *ino, struct ioctx *ioctx);
 193 static int native_inop_write(struct inode *ino, struct ioctx *ioctx);
 194 static _SYSIO_OFF_T native_inop_pos(struct inode *ino, _SYSIO_OFF_T off);
 195 static int native_inop_iodone(struct ioctx *ioctx);
 196 static int native_inop_fcntl(struct inode *ino, int cmd, va_list ap, int *rtn);
 197 static int native_inop_sync(struct inode *ino);
 198 static int native_inop_datasync(struct inode *ino);
 199 static int native_inop_ioctl(struct inode *ino,
 200                              unsigned long int request,
 201                              va_list ap);
 202 static int native_inop_mknod(struct pnode *pno, mode_t mode, dev_t dev);
 203 #ifdef _HAVE_STATVFS
 204 static int native_inop_statvfs(struct pnode *pno,
 205                                struct inode *ino,
 206                                struct intnl_statvfs *buf);
 207 #endif
 208 static void native_inop_gone(struct inode *ino);
 209
 210 static struct inode_ops native_i_ops = {
 211         native_inop_lookup,
 212         native_inop_getattr,
 213         native_inop_setattr,
 214         native_filldirentries,
 215         native_inop_mkdir,
 216         native_inop_rmdir,
 217         native_inop_symlink,
 218         native_inop_readlink,
 219         native_inop_open,
 220         native_inop_close,
 221         native_inop_link,
 222         native_inop_unlink,
 223         native_inop_rename,
 224         native_inop_read,
 225         native_inop_write,
 226         native_inop_pos,
 227         native_inop_iodone,
 228         native_inop_fcntl,
 229         native_inop_sync,
 230         native_inop_datasync,
 231         native_inop_ioctl,
 232         native_inop_mknod,
 233 #ifdef _HAVE_STATVFS
 234         native_inop_statvfs,
 235 #endif
 236         native_inop_gone
 237 };
 238
 239 static int native_fsswop_mount(const char *source,
 240                                unsigned flags,
 241                                const void *data,
 242                                struct pnode *tocover,
 243                                struct mount **mntp);
 244
 245 static struct fssw_ops native_fssw_ops = {
 246         native_fsswop_mount
 247 };
 248
 249 static void native_fsop_gone(struct filesys *fs);
 250
 251 static struct filesys_ops native_inodesys_ops = {
 252         native_fsop_gone,
 253 };
 254
 255 /*
 256  * This example driver plays a strange game. It maintains a private,
 257  * internal mount -- It's own separate, rooted, name space. The local
 258  * file system's entire name space is available via this tree.
 259  *
 260  * This simplifies the implementation. At mount time, we need to generate
 261  * a path-node to be used as a root. This allows us to look up the needed
 262  * node in the host name space and leverage a whole lot of support from
 263  * the system.
 264  */
 265 static struct mount *native_internal_mount = NULL;
 266
 267 /*
 268  * Given i-node, return driver private part.
 269  */
 270 #define I2NI(ino)       ((struct native_inode *)((ino)->i_private))
 271
 272 /*
 273  * stat -- by path.
 274  */
 275 static int
 276 native_stat(const char *path,
 277             struct inode *ino,
 278             time_t t,
 279             struct intnl_stat *buf)
 280 {
 281         struct native_inode *nino;
 282         int     err;
 283         struct _sysio_native_stat stbuf;
 284
 285         nino = ino ? I2NI(ino) : NULL;
 286
 287         if (path)
 288                 err = syscall(SYSIO_SYS_stat, path, &stbuf);
 289         else if (nino && nino->ni_fd >= 0)
 290                 err = syscall(SYSIO_SYS_fstat, nino->ni_fd, &stbuf);
 291         else
 292                 abort();
 293         if (err) {
 294                 if (nino)
 295                         nino->ni_attrtim = 0;
 296                 return -errno;
 297         }
 298         if (nino) {
 299                 nino->ni_attrtim = t;
 300                 SYSIO_COPY_STAT(&stbuf, &ino->i_stbuf);
 301                 if (buf)
 302                         *buf = ino->i_stbuf;
 303                 return 0;
 304         }
 305         if (!buf)
 306                 return 0;
 307         SYSIO_COPY_STAT(&stbuf, buf);
 308         return 0;
 309 }
 310
 311 /*
 312  * Introduce an i-node to the system.
 313  */
 314 static struct inode *
 315 native_i_new(struct filesys *fs, time_t expiration, struct intnl_stat *buf)
 316 {
 317         struct native_inode *nino;
 318         struct inode *ino;
 319
 320         nino = malloc(sizeof(struct native_inode));
 321         if (!nino)
 322                 return NULL;
 323         bzero(&nino->ni_ident, sizeof(nino->ni_ident));
 324         nino->ni_seekok = 0;
 325         nino->ni_attrvalid = 0;
 326         nino->ni_resetfpos = 0;
 327         nino->ni_ident.dev = buf->st_dev;
 328         nino->ni_ident.ino = buf->st_ino;
 329 #ifdef HAVE_GENERATION
 330         nino->ni_ident.gen = buf->st_gen;
 331 #endif
 332         nino->ni_fileid.fid_data = &nino->ni_ident;
 333         nino->ni_fileid.fid_len = sizeof(nino->ni_ident);
 334         nino->ni_fd = -1;
 335         nino->ni_oflags = 0;
 336         nino->ni_nopens = 0;
 337         nino->ni_fpos = 0;
 338         nino->ni_attrtim = expiration;
 339         ino =
 340             _sysio_i_new(fs,
 341                          &nino->ni_fileid,
 342                          buf,
 343                          0,
 344                          &native_i_ops,
 345                          nino);
 346         if (!ino)
 347                 free(nino);
 348         return ino;
 349 }
 350
 351 /*
 352  * Initialize this driver.
 353  */
 354 int
 355 _sysio_native_init()
 356 {
 357
 358         /*
 359          * Capture current process umask and reset our process umask to
 360          * zero. All permission bits to open/creat/setattr are absolute --
 361          * They've already had a umask applied, when appropriate.
 362          */
 363 #ifndef REDSTORM
 364         _sysio_umask = syscall(SYSIO_SYS_umask, 0);
 365         /*
 366          *      For Red Storm, this functionality is handled in cstart.
 367          *      The mask to be "captured" has been sent already.
 368          *      This eliminates a system call from every node!
 369          */
 370 #endif  /* REDSTORM  */
 371
 372         return _sysio_fssw_register("native", &native_fssw_ops);
 373 }
 374
 375 /*
 376  * Create private, internal, view of the hosts name space.
 377  */
 378 static int
 379 create_internal_namespace(const void *data)
 380 {
 381         char    *opts;
 382         ssize_t len;
 383         char    *cp;
 384         struct native_filesystem *nfs;
 385         int     err;
 386         struct mount *mnt;
 387         struct inode *rootino;
 388         struct pnode_base *rootpb;
 389         static struct qstr noname = { NULL, 0, 0 };
 390         struct filesys *fs;
 391         time_t  t;
 392         struct intnl_stat stbuf;
 393         unsigned long ul;
 394         static struct option_value_info v[] = {
 395                 { "atimo",      "30" },
 396                 { NULL,         NULL }
 397         };
 398
 399         if (native_internal_mount) {
 400                 /*
 401                  * Reentered!
 402                  */
 403                 abort();
 404         }
 405
 406         /*
 407          * Get mount options.
 408          */
 409         opts = NULL;
 410         if (data && (len = strlen((char *)data))) {
 411                 opts = malloc(len + 1);
 412                 if (!opts)
 413                         return -ENOMEM;
 414                 (void )strcpy(opts, data);
 415                 if (_sysio_get_args(opts, v) - opts != (ssize_t )len)
 416                         return -EINVAL;
 417         }
 418         ul = strtoul(v[0].ovi_value, &cp, 0);
 419         if (*cp != '\0' || ul >= UINT_MAX)
 420                 return -EINVAL;
 421         if (opts) {
 422                 free(opts);
 423                 opts = NULL;
 424         }
 425
 426         /*
 427          * We maintain an artificial, internal, name space in order to
 428          * have access to fully qualified path names in the various routines.
 429          * Initialize that name space now.
 430          */
 431         fs = NULL;
 432         mnt = NULL;
 433         rootino = NULL;
 434         rootpb = NULL;
 435         /*
 436          * This really should be per-mount. Hmm, but that's best done
 437          * as proper sub-mounts in the core and not this driver. We reconcile
 438          * now, here, by putting the mount options on the file system. That
 439          * means they are global and only can be passed at the initial mount.
 440          *
 441          * Maybe do it right some day?
 442          */
 443         nfs = malloc(sizeof(struct native_filesystem));
 444         if (!nfs) {
 445                 err = -ENOMEM;
 446                 goto error;
 447         }
 448         nfs->nfs_atimo = ul;
 449         if ((unsigned long)nfs->nfs_atimo != ul) {
 450                 err = -EINVAL;
 451                 goto error;
 452         }
 453         fs = _sysio_fs_new(&native_inodesys_ops, 0, nfs);
 454         if (!fs) {
 455                 err = -ENOMEM;
 456                 goto error;
 457         }
 458
 459         /*
 460          * Get root i-node.
 461          */
 462         t = _SYSIO_LOCAL_TIME();
 463         err = native_stat("/", NULL, 0, &stbuf);
 464         if (err)
 465                 goto error;
 466         rootino = native_i_new(fs, t + FS2NFS(fs)->nfs_atimo, &stbuf);
 467         if (!rootino) {
 468                 err = -ENOMEM;
 469                 goto error;
 470         }
 471
 472         /*
 473          * Generate base path-node for root.
 474          */
 475         rootpb = _sysio_pb_new(&noname, NULL, rootino);
 476         if (!rootpb) {
 477                 err = -ENOMEM;
 478                 goto error;
 479         }
 480
 481         /*
 482          * Mount it. This name space is disconnected from the
 483          * rest of the system -- Only available within this driver.
 484          */
 485         err = _sysio_do_mount(fs, rootpb, 0, NULL, &mnt);
 486         if (err)
 487                 goto error;
 488
 489         native_internal_mount = mnt;
 490         return 0;
 491 error:
 492         if (mnt) {
 493                 if (_sysio_do_unmount(mnt) != 0)
 494                         abort();
 495                 nfs = NULL;
 496                 fs = NULL;
 497                 rootpb = NULL;
 498                 rootino = NULL;
 499         }
 500         if (rootpb)
 501                 _sysio_pb_gone(rootpb);
 502         if (fs) {
 503                 FS_RELE(fs);
 504                 nfs = NULL;
 505         }
 506         if (nfs)
 507                 free(nfs);
 508         if (opts)
 509                 free(opts);
 510
 511         return err;
 512 }
 513
 514 static int
 515 native_fsswop_mount(const char *source,
 516                     unsigned flags,
 517                     const void *data,
 518                     struct pnode *tocover,
 519                     struct mount **mntp)
 520 {
 521         int     err;
 522         struct nameidata nameidata;
 523         struct mount *mnt;
 524
 525         /*
 526          * Caller must use fully qualified path names when specifying
 527          * the source.
 528          */
 529         if (*source != '/')
 530                 return -ENOENT;
 531
 532         if (!native_internal_mount) {
 533                 err = create_internal_namespace(data);
 534                 if (err)
 535                         return err;
 536         } else if (data && *(char *)data)
 537                 return -EINVAL;
 538
 539         /*
 540          * Lookup the source in the internally maintained name space.
 541          */
 542         ND_INIT(&nameidata, 0, source, native_internal_mount->mnt_root, NULL);
 543         err = _sysio_path_walk(native_internal_mount->mnt_root, &nameidata);
 544         if (err)
 545                 return err;
 546
 547         /*
 548          * Have path-node specified by the given source argument. Let the
 549          * system finish the job, now.
 550          */
 551         err =
 552             _sysio_do_mount(native_internal_mount->mnt_fs,
 553                             nameidata.nd_pno->p_base,
 554                             flags,
 555                             tocover,
 556                             &mnt);
 557         /*
 558          * Release the internal name space pnode and clean up any
 559          * aliases we might have generated. We really don't need to cache them
 560          * as they are only used at mount time..
 561          */
 562         P_RELE(nameidata.nd_pno);
 563         (void )_sysio_p_prune(native_internal_mount->mnt_root);
 564
 565         if (!err) {
 566                 FS_REF(native_internal_mount->mnt_fs);
 567                 *mntp = mnt;
 568         }
 569         return err;
 570 }
 571
 572 static int
 573 native_i_invalid(struct inode *inop, struct intnl_stat *stat)
 574 {
 575         struct native_inode *nino;
 576
 577         /*
 578          * Validate passed in inode against stat struct info
 579          */
 580         nino = I2NI(inop);
 581
 582         if (!nino->ni_attrtim ||
 583             (nino->ni_ident.dev != stat->st_dev ||
 584              nino->ni_ident.ino != stat->st_ino ||
 585 #ifdef HAVE_GENERATION
 586              nino->ni_ident.gen != stat->st_gen ||
 587 #endif
 588              ((inop)->i_stbuf.st_mode & S_IFMT) != (stat->st_mode & S_IFMT)) ||
 589             (((inop)->i_stbuf.st_rdev != stat->st_rdev) &&
 590                (S_ISCHR((inop)->i_stbuf.st_mode) ||
 591                 S_ISBLK((inop)->i_stbuf.st_mode)))) {
 592                 nino->ni_attrtim = 0;                   /* invalidate attrs */
 593                 return 1;
 594         }
 595         return 0;
 596 }
 597
 598 static struct inode *
 599 native_iget(struct filesys *fs, time_t expire, struct intnl_stat *stbp)
 600 {
 601         struct inode *ino;
 602         struct native_inode_identifier ident;
 603         struct file_identifier fileid;
 604
 605         bzero(&ident, sizeof(ident));
 606         ident.dev = stbp->st_dev;
 607         ident.ino = stbp->st_ino;
 608 #ifdef HAVE_GENERATION
 609         ident.gen = stbp->st_gen;
 610 #endif
 611         fileid.fid_data = &ident;
 612         fileid.fid_len = sizeof(ident);
 613         ino = _sysio_i_find(fs, &fileid);
 614         if (ino) {
 615                 ino->i_stbuf = *stbp;
 616                 I2NI(ino)->ni_attrtim = expire;
 617                 return ino;
 618         }
 619         return native_i_new(fs, expire, stbp);
 620 }
 621
 622 /*
 623  * Find, and validate, or create i-node by host-relative path. Returned i-node
 624  * is referenced.
 625  */
 626 static int
 627 native_ibind(struct filesys *fs,
 628              char *path,
 629              time_t t,
 630              struct inode **inop)
 631 {
 632         struct intnl_stat ostbuf, stbuf;
 633         int     err;
 634         struct inode *ino;
 635
 636         if (*inop)
 637                 ostbuf = (*inop)->i_stbuf;
 638
 639         err = native_stat(path, *inop, t, &stbuf);
 640         if (err)
 641                 return err;
 642
 643         /*
 644          * Validate?
 645          */
 646         if (*inop) {
 647                 if (!native_i_invalid(*inop, &ostbuf))
 648                         return 0;
 649                 /*
 650                  * Invalidate.
 651                  */
 652                 _sysio_i_undead(*inop);
 653                 *inop = NULL;
 654         }
 655
 656         if (!(ino = native_iget(fs, t + FS2NFS(fs)->nfs_atimo, &stbuf)))
 657                 return -ENOMEM;
 658
 659         *inop = ino;
 660         return 0;
 661 }
 662
 663 static int
 664 native_inop_lookup(struct pnode *pno,
 665                    struct inode **inop,
 666                    struct intent *intnt __IS_UNUSED,
 667                    const char *path __IS_UNUSED)
 668 {
 669         time_t  t;
 670         char    *fqpath;
 671         struct filesys *fs;
 672         int     err;
 673
 674         *inop = pno->p_base->pb_ino;
 675
 676         /*
 677          * Try to use the cached attributes unless the intent
 678          * indicates we are looking up the last component and
 679          * caller wants attributes. In that case, force a refresh.
 680          */
 681         t = _SYSIO_LOCAL_TIME();
 682         if (*inop &&
 683             (path || !intnt || (intnt->int_opmask & INT_GETATTR) == 0) &&
 684             NATIVE_ATTRS_VALID(I2NI(*inop), t))
 685                 return 0;
 686
 687         /*
 688          * Don't have an inode yet. Because we translate everything back to
 689          * a single name space for the host, we will assume the object the
 690          * caller is looking for has no existing alias in our internal
 691          * name space. We don't see the same file on different mounts in the
 692          * underlying host FS as the same file.
 693          *
 694          * The file identifier *will* be unique. It's got to have a different
 695          * dev.
 696          */
 697         fqpath = _sysio_pb_path(pno->p_base, '/');
 698         if (!fqpath)
 699                 return -ENOMEM;
 700         fs = pno->p_mount->mnt_fs;
 701         err = native_ibind(fs, fqpath, t + FS2NFS(fs)->nfs_atimo, inop);
 702         free(fqpath);
 703         if (err)
 704                 *inop = NULL;
 705         return err;
 706 }
 707
 708 static int
 709 native_inop_getattr(struct pnode *pno,
 710                     struct inode *ino,
 711                     struct intnl_stat *stat)
 712 {
 713         struct native_inode *nino;
 714         int     err;
 715
 716         /*
 717          * We just cannot use the cached attributes when getattr is
 718          * called. Had the caller felt those were sufficient then
 719          * they could have (would have?) simply used what was cached
 720          * after revalidating. In this case, there's a good chance the
 721          * caller is looking for the current time stamps and/or size. Something
 722          * pretty volatile anyway.
 723          */
 724         err = 0;                                        /* compiler cookie */
 725         if (pno) {
 726                 char    *path;
 727                 struct filesys *fs;
 728                 time_t  t;
 729
 730                 path = _sysio_pb_path(pno->p_base, '/');
 731                 if (!path)
 732                         return -ENOMEM;
 733                 fs = pno->p_mount->mnt_fs;
 734                 t = _SYSIO_LOCAL_TIME();
 735                 err = native_stat(path, ino, t + FS2NFS(fs)->nfs_atimo, stat);
 736                 free(path);
 737         } else if ((nino = I2NI(ino))->ni_fd >= 0)
 738                 /*
 739                  * Don't have access to the fs record anymore. Just
 740                  * refresh but keep the current timeout.
 741                  */
 742                 err = native_stat(NULL, ino, nino->ni_attrtim, stat);
 743         else {
 744                 /*
 745                  * Dev inodes don't open in this driver. We won't have
 746                  * a file descriptor with which to do the deed then. Satisfy
 747                  * the request from the cached copy of the attributes.
 748                  */
 749                 (void )memcpy(stat,
 750                               &ino->i_stbuf,
 751                               sizeof(struct intnl_stat));
 752                 err = 0;
 753         }
 754
 755         return err;
 756 }
 757
 758 #ifdef SYSIO_SYS_utime
 759 static int
 760 _ut(const char *path, time_t actime, time_t modtime)
 761 {
 762         struct utimbuf ut;
 763
 764         ut.actime = actime;
 765         ut.modtime = modtime;
 766         return syscall(SYSIO_SYS_utime, path, &ut);
 767 }
 768 #else
 769 static int
 770 _ut(const char *path, time_t actime, time_t modtime)
 771 {
 772         struct timeval tv[2];
 773
 774         tv[0].tv_sec = actime;
 775         tv[0].tv_usec = 0;
 776         tv[1].tv_sec = modtime;
 777         tv[1].tv_usec = 0;
 778         return syscall(SYSIO_SYS_utimes, path, &tv);
 779 }
 780 #endif
 781
 782 static int
 783 native_inop_setattr(struct pnode *pno,
 784                     struct inode *ino,
 785                     unsigned mask,
 786                     struct intnl_stat *stat)
 787 {
 788         char    *path;
 789         struct native_inode *nino;
 790         int     fd;
 791         int     err;
 792
 793         path = NULL;
 794         nino = ino ? I2NI(ino) : NULL;
 795         fd = -1;
 796         if (nino)
 797                 fd = nino->ni_fd;
 798         if (fd < 0 || mask & (SETATTR_MTIME|SETATTR_ATIME)) {
 799                 if (!pno)
 800                         return -EEXIST;
 801                 path = _sysio_pb_path(pno->p_base, '/');
 802                 if (!path)
 803                         return -ENOMEM;
 804         }
 805
 806         /*
 807          * Get current status for undo.
 808          */
 809         err = native_stat(path, ino, 0, NULL);
 810         if (err)
 811                 goto out;
 812
 813         if (mask & SETATTR_MODE) {
 814                 mode_t  mode;
 815
 816                 /*
 817                  * Alter permissions attribute.
 818                  */
 819                 mode = stat->st_mode & 07777;
 820                 err =
 821                     fd < 0
 822                       ? syscall(SYSIO_SYS_chmod, path, mode)
 823                       : syscall(SYSIO_SYS_fchmod, fd, mode);
 824                 if (err)
 825                         err = -errno;
 826         }
 827         if (err)
 828                 mask &= ~SETATTR_MODE;
 829         else if (mask & (SETATTR_MTIME|SETATTR_ATIME)) {
 830                 time_t  actime, modtime;
 831
 832                 /*
 833                  * Alter access and/or modify time attributes.
 834                  */
 835                 actime  = ino->i_stbuf.st_atime;
 836                 modtime  = ino->i_stbuf.st_mtime;
 837                 if (mask & SETATTR_ATIME)
 838                         actime = stat->st_atime;
 839                 if (mask & SETATTR_MTIME)
 840                         modtime = stat->st_mtime;
 841                 if (_ut(path, actime, modtime) != 0)
 842                         return -errno;
 843         }
 844         if (err)
 845                 mask &= ~(SETATTR_MTIME|SETATTR_ATIME);
 846         else if (mask & (SETATTR_UID|SETATTR_GID)) {
 847
 848                 /*
 849                  * Alter owner and/or group identifiers.
 850                  */
 851                 err =
 852                     fd < 0
 853                       ? syscall(SYSIO_SYS_chown,
 854                                 path,
 855                                 mask & SETATTR_UID
 856                                   ? stat->st_uid
 857                                   : (uid_t )-1,
 858                                 mask & SETATTR_GID
 859                                   ? stat->st_gid
 860                                   : (gid_t )-1)
 861                       : syscall(SYSIO_SYS_fchown,
 862                                 fd,
 863                                 mask & SETATTR_UID
 864                                   ? stat->st_uid
 865                                   : (uid_t )-1,
 866                                 mask & SETATTR_GID
 867                                   ? stat->st_gid
 868                                   : (gid_t )-1);
 869                 if (err)
 870                         err = -errno;
 871         }
 872         if (err)
 873                 mask &= ~(SETATTR_UID|SETATTR_GID);
 874         else if (mask & SETATTR_LEN) {
 875                 /*
 876                  * Do the truncate last. It can't be undone.
 877                  */
 878                  err = fd < 0
 879                            ? syscall(SYSIO_SYS_truncate, path, stat->st_size)
 880                            : syscall(SYSIO_SYS_ftruncate, fd, stat->st_size);
 881                 if (err)
 882                         err = -errno;
 883         }
 884         if (!err)
 885                 goto out;
 886         /*
 887          * Undo after error. Some or all of this might not work... We
 888          * can but try.
 889          */
 890         if (mask & (SETATTR_UID|SETATTR_GID)) {
 891                  (void )(fd < 0
 892                            ? syscall(SYSIO_SYS_chown,
 893                                      path,
 894                                      mask & SETATTR_UID
 895                                        ? ino->i_stbuf.st_uid
 896                                        : (uid_t )-1,
 897                                      mask & SETATTR_GID
 898                                        ? ino->i_stbuf.st_gid
 899                                        : (gid_t )-1)
 900                            : syscall(SYSIO_SYS_fchown,
 901                                      fd,
 902                                      mask & SETATTR_UID
 903                                        ? ino->i_stbuf.st_uid
 904                                        : (uid_t )-1,
 905                                      mask & SETATTR_GID
 906                                        ? ino->i_stbuf.st_gid
 907                                        : (gid_t )-1));
 908         }
 909         if (mask & (SETATTR_MTIME|SETATTR_ATIME))
 910                 (void )_ut(path, ino->i_stbuf.st_atime, ino->i_stbuf.st_mtime);
 911         if (mask & SETATTR_MODE) {
 912                 fd < 0
 913                   ? syscall(SYSIO_SYS_chmod, path, ino->i_stbuf.st_mode & 07777)
 914                   : syscall(SYSIO_SYS_fchmod, ino->i_stbuf.st_mode & 07777);
 915         }
 916 out:
 917         /*
 918          * We must refresh the cached attributes.
 919          */
 920         if (!err && native_stat(path, ino, _SYSIO_LOCAL_TIME(), NULL) != 0)
 921                 abort();
 922         if (path)
 923                 free(path);
 924         return err;
 925 }
 926
 927 static int
 928 native_pos(int fd, _SYSIO_OFF_T *offset, int whence)
 929 {
 930         _SYSIO_OFF_T off;
 931
 932         assert(fd >= 0);
 933         assert(*offset >= 0);
 934
 935         off = *offset;
 936 #if defined(_LARGEFILE64_SOURCE) && defined(SYSIO_SYS__llseek)
 937         {
 938                 int     err;
 939                 err =
 940                     syscall(SYSIO_SYS__llseek,
 941                             (unsigned int)fd,
 942                             (unsigned int)(off >> 32),
 943                             (unsigned int)off,
 944                             &off,
 945                             whence);
 946                 if (err == -1)
 947                         return -errno;
 948         }
 949 #else
 950         off =
 951             syscall(SYSIO_SYS_lseek,
 952                     fd,
 953                     off,
 954                     whence);
 955         if (off == -1)
 956                 return -errno;
 957 #endif
 958         *offset = off;
 959
 960         return 0;
 961 }
 962
 963 static ssize_t
 964 native_ifilldirentries(struct native_inode *nino,
 965                        _SYSIO_OFF_T *posp,
 966                        char *buf,
 967                        size_t nbytes)
 968 {
 969         int     err;
 970         ssize_t cc;
 971 #if defined(SYSIO_SYS_getdirentries)
 972         _SYSIO_OFF_T    waste;
 973 #endif
 974
 975         if (*posp < 0)
 976                 return -EINVAL;
 977
 978         /*
 979          * Stream-oriented access requires that we reposition prior to the
 980          * fill call.
 981          */
 982         assert(nino->ni_seekok);
 983         if (*posp != nino->ni_fpos || nino->ni_resetfpos) {
 984                 nino->ni_fpos = *posp;
 985                 err = native_pos(nino->ni_fd, &nino->ni_fpos, SEEK_SET);
 986                 if (err) {
 987                         nino->ni_resetfpos = 1;
 988                         return err;
 989                 }
 990                 nino->ni_resetfpos = 0;
 991         }
 992
 993         cc =
 994 #if defined(SYSIO_SYS_getdirentries)
 995             syscall(SYSIO_SYS_getdirentries,
 996                     nino->ni_fd,
 997                     buf,
 998                     nbytes,
 999                     &waste);
1000 #elif defined(SYSIO_SYS_getdents64)
1001             syscall(SYSIO_SYS_getdents64, nino->ni_fd, buf, nbytes);
1002 #elif defined(SYSIO_SYS_getdents)
1003             syscall(SYSIO_SYS_getdents, nino->ni_fd, buf, nbytes);
1004 #endif
1005
1006         if (cc < 0)
1007                 return -errno;
1008         /*
1009          * Stream-oriented access requires that we discover where we are
1010          * after the call.
1011          */
1012         if ((err = native_pos(nino->ni_fd, &nino->ni_fpos, SEEK_CUR)) != 0) {
1013                 /*
1014                  * Leave the position at the old I suppose.
1015                  */
1016                 nino->ni_resetfpos = 1;
1017                 return err;
1018         }
1019         *posp = nino->ni_fpos;
1020         return cc;
1021 }
1022
1023 static ssize_t
1024 native_filldirentries(struct inode *ino,
1025                       _SYSIO_OFF_T *posp,
1026                       char *buf,
1027                       size_t nbytes)
1028 {
1029         struct native_inode *nino = I2NI(ino);
1030 #if DIR_CVT_64
1031         char    *bp;
1032         size_t  count;
1033         struct linux_dirent *ldp;
1034         struct dirent64 *d64p;
1035         size_t  namlen;
1036         size_t  reclen;
1037 #else
1038 #define bp buf
1039 #define count nbytes
1040 #endif
1041         ssize_t cc;
1042
1043         assert(nino->ni_fd >= 0);
1044
1045 #if DIR_CVT_64
1046         count = nbytes;
1047         while (!(bp = malloc(count))) {
1048                 count /= 2;
1049                 if (count < sizeof(struct dirent))
1050                         return -ENOMEM;
1051         }
1052 #endif
1053         cc = native_ifilldirentries(nino, posp, bp, count);
1054         if (cc < 0) {
1055 #if DIR_CVT_64
1056                 free(bp);
1057 #endif
1058                 return cc;
1059         }
1060 #if DIR_CVT_64
1061         ldp = (struct linux_dirent *)bp;
1062         d64p = (struct dirent64 *)buf;
1063         while (cc) {
1064                 namlen = strlen(ldp->ld_name);
1065                 reclen = sizeof(*d64p) - sizeof(d64p->d_name) + namlen;
1066                 if (nbytes <= reclen)
1067                         break;
1068                 d64p->d_ino = ldp->ld_ino;
1069                 d64p->d_off = nino->ni_fpos = ldp->ld_off;
1070                 d64p->d_reclen =
1071                     (((reclen + sizeof(long))) / sizeof(long)) * sizeof(long);
1072                 if (nbytes < d64p->d_reclen)
1073                         d64p->d_reclen = reclen + 1;
1074                 d64p->d_type = DT_UNKNOWN;              /* you lose -- sorry. */
1075                 (void )memcpy(d64p->d_name, ldp->ld_name, namlen);
1076                 /*
1077                  * Zero pad the rest.
1078                  */
1079                 for (cp = d64p->d_name + namlen, n = d64p->d_reclen - reclen;
1080                      n;
1081                      n--)
1082                         *cp++ = 0;
1083                 cc -= ldp->ld_reclen;
1084                 ldp = (struct linux_dirent *)((char *)ldp + ldp->ld_reclen);
1085                 nbytes -= d64p->d_reclen;
1086                 d64p = (struct dirent64 *)((char *)d64p + d64p->d_reclen);
1087         }
1088         free(bp);
1089         cc =
1090             (d64p == (struct dirent64 *)buf && cc)
1091               ? -EINVAL
1092               : (char *)d64p - buf;
1093 #else
1094 #undef bp
1095 #undef count
1096 #endif
1097         return cc;
1098 }
1099
1100 static int
1101 native_inop_mkdir(struct pnode *pno, mode_t mode)
1102 {
1103         char    *path;
1104         int     err;
1105
1106         path = _sysio_pb_path(pno->p_base, '/');
1107         if (!path)
1108                 return -ENOMEM;
1109
1110         err = syscall(SYSIO_SYS_mkdir, path, mode);
1111         if (err != 0)
1112                 err = -errno;
1113         free(path);
1114         return err;
1115 }
1116
1117 static int
1118 native_inop_rmdir(struct pnode *pno)
1119 {
1120         char    *path;
1121         int     err;
1122
1123         path = _sysio_pb_path(pno->p_base, '/');
1124         if (!path)
1125                 return -ENOMEM;
1126
1127         err = syscall(SYSIO_SYS_rmdir, path);
1128         if (err != 0)
1129                 err = -errno;
1130         free(path);
1131         return err;
1132 }
1133
1134 static int
1135 native_inop_symlink(struct pnode *pno, const char *data)
1136 {
1137         char    *path;
1138         int     err;
1139
1140         path = _sysio_pb_path(pno->p_base, '/');
1141         if (!path)
1142                 return -ENOMEM;
1143
1144         err = syscall(SYSIO_SYS_symlink, data, path);
1145         if (err != 0)
1146                 err = -errno;
1147         free(path);
1148         return err;
1149 }
1150
1151 static int
1152 native_inop_readlink(struct pnode *pno, char *buf, size_t bufsiz)
1153 {
1154         char    *path;
1155         int     i;
1156
1157         path = _sysio_pb_path(pno->p_base, '/');
1158         if (!path)
1159                 return -ENOMEM;
1160         i = syscall(SYSIO_SYS_readlink, path, buf, bufsiz);
1161         if (i < 0)
1162                 i = -errno;
1163         free(path);
1164         return i;
1165 }
1166
1167 static int
1168 native_inop_open(struct pnode *pno, int flags, mode_t mode)
1169 {
1170         struct native_inode *nino;
1171         char    *path;
1172         int     fd;
1173
1174         path = _sysio_pb_path(pno->p_base, '/');
1175         if (!path)
1176                 return -ENOMEM;
1177
1178         /*
1179          * Whether the file is already open, or not, makes no difference.
1180          * Want to always give the host OS a chance to authorize in case
1181          * something has changed underneath us.
1182          */
1183         if (flags & O_WRONLY) {
1184                 /*
1185                  * Promote write-only attempt to RW.
1186                  */
1187                 flags &= ~O_WRONLY;
1188                 flags |= O_RDWR;
1189         }
1190 #ifdef O_LARGEFILE
1191         flags |= O_LARGEFILE;
1192 #endif
1193         fd = syscall(SYSIO_SYS_open, path, flags, mode);
1194         if (!pno->p_base->pb_ino && fd >= 0) {
1195                 struct filesys *fs;
1196                 int     err;
1197
1198                 /*
1199                  * Success but we need to return an i-node.
1200                  */
1201                 fs = pno->p_mount->mnt_fs;
1202                 err =
1203                     native_ibind(fs,
1204                                  path,
1205                                  _SYSIO_LOCAL_TIME() + FS2NFS(fs)->nfs_atimo,
1206                                  &pno->p_base->pb_ino);
1207                 if (err) {
1208                         (void )syscall(SYSIO_SYS_close, fd);
1209                         if (err == -EEXIST)
1210                                 abort();
1211                         fd = err;
1212                 }
1213         }
1214         free(path);
1215         if (fd < 0)
1216                 return -errno;
1217
1218         /*
1219          * Remember this new open.
1220          */
1221         nino = I2NI(pno->p_base->pb_ino);
1222         nino->ni_nopens++;
1223         assert(nino->ni_nopens);
1224
1225         if (nino->ni_fd >= 0) {
1226                 if ((nino->ni_oflags & O_RDWR) ||
1227                     (flags & (O_RDONLY|O_WRONLY|O_RDWR)) == O_RDONLY) {
1228                         /*
1229                          * Keep existing.
1230                          */
1231                         (void )syscall(SYSIO_SYS_close, fd);
1232                         return 0;
1233                 }
1234                 (void )syscall(SYSIO_SYS_close, nino->ni_fd);
1235         }
1236         /*
1237          * Invariant; First open. Must init.
1238          */
1239         nino->ni_resetfpos = 0;
1240         nino->ni_fpos = 0;
1241         nino->ni_fd = fd;
1242         /*
1243          * Need to know whether we can seek on this
1244          * descriptor.
1245          */
1246         nino->ni_seekok =
1247             native_pos(nino->ni_fd, &nino->ni_fpos, SEEK_CUR) != 0 ? 0 : 1;
1248
1249         return 0;
1250 }
1251
1252 static int
1253 native_inop_close(struct inode *ino)
1254 {
1255         struct native_inode *nino = I2NI(ino);
1256         int     err;
1257
1258         if (nino->ni_fd < 0)
1259                 abort();
1260
1261         assert(nino->ni_nopens);
1262         if (--nino->ni_nopens) {
1263                 /*
1264                  * Hmmm. We really don't need anything else. However, some
1265                  * filesystems try to implement a sync-on-close semantic.
1266                  * As this appears now, that is lost. Might want to change
1267                  * it somehow in the future?
1268                  */
1269                 return 0;
1270         }
1271
1272         err = syscall(SYSIO_SYS_close, nino->ni_fd);
1273         if (err)
1274                 return -errno;
1275
1276         nino->ni_fd = -1;
1277         nino->ni_resetfpos = 0;
1278         nino->ni_fpos = 0;
1279         return 0;
1280 }
1281
1282 static int
1283 native_inop_link(struct pnode *old, struct pnode *new)
1284 {
1285         int     err;
1286         char    *opath, *npath;
1287
1288         err = 0;
1289
1290         opath = _sysio_pb_path(old->p_base, '/');
1291         npath = _sysio_pb_path(new->p_base, '/');
1292         if (!(opath && npath)) {
1293                 err = -ENOMEM;
1294                 goto out;
1295         }
1296
1297         err = syscall(SYSIO_SYS_link, opath, npath);
1298         if (err != 0)
1299                 err = -errno;
1300
1301 out:
1302         if (opath)
1303                 free(opath);
1304         if (npath)
1305                 free(npath);
1306         return err;
1307 }
1308
1309 static int
1310 native_inop_unlink(struct pnode *pno)
1311 {
1312         char    *path;
1313         int     err = 0;
1314
1315         path = _sysio_pb_path(pno->p_base, '/');
1316         if (!path)
1317                 return -ENOMEM;
1318
1319         /*
1320          * For this driver, unlink is easy with open files. Since the
1321          * file remains open to the system, too, the descriptors are still
1322          * valid.
1323          *
1324          * Other drivers will have some difficulty here as the entry in the
1325          * file system name space must be removed without sacrificing access
1326          * to the file itself. In NFS this is done with a mechanism referred
1327          * to as a `silly delete'. The file is moved to a temporary name
1328          * (usually .NFSXXXXXX, where the X's are replaced by the PID and some
1329          * unique characters) in order to simulate the proper semantic.
1330          */
1331         if (syscall(SYSIO_SYS_unlink, path) != 0)
1332                 err = -errno;
1333         free(path);
1334         return err;
1335 }
1336
1337 static int
1338 native_inop_rename(struct pnode *old, struct pnode *new)
1339 {
1340         int     err;
1341         char    *opath, *npath;
1342
1343         opath = _sysio_pb_path(old->p_base, '/');
1344         npath = _sysio_pb_path(new->p_base, '/');
1345         if (!(opath && npath)) {
1346                 err = -ENOMEM;
1347                 goto out;
1348         }
1349
1350         err = syscall(SYSIO_SYS_rename, opath, npath);
1351         if (err != 0)
1352                 err = -errno;
1353
1354 out:
1355         if (opath)
1356                 free(opath);
1357         if (npath)
1358                 free(npath);
1359         return err;
1360 }
1361
1362 static ssize_t
1363 dopio(void *buf, size_t count, _SYSIO_OFF_T off, struct native_io *nio)
1364 {
1365         ssize_t cc;
1366
1367         if (!nio->nio_nino->ni_seekok) {
1368                 if (off != nio->nio_nino->ni_fpos) {
1369                         /*
1370                          * They're trying to reposition. Can't
1371                          * seek on this descriptor so we err out now.
1372                          */
1373                         errno = ESPIPE;
1374                         return -1;
1375                 }
1376                 cc =
1377                     syscall(nio->nio_op == 'r'
1378                               ? SYSIO_SYS_read
1379                               : SYSIO_SYS_write,
1380                             nio->nio_nino->ni_fd,
1381                             buf,
1382                             count);
1383                 if (cc > 0)
1384                         nio->nio_nino->ni_fpos += cc;
1385         } else
1386                 cc =
1387                     syscall((nio->nio_op == 'r'
1388                                ? SYSIO_SYS_pread
1389                                : SYSIO_SYS_pwrite),
1390                             nio->nio_nino->ni_fd,
1391                             buf,
1392                             count,
1393                             off);
1394
1395         return cc;
1396 }
1397
1398 static ssize_t
1399 doiov(const struct iovec *iov,
1400       int count,
1401       _SYSIO_OFF_T off,
1402       ssize_t limit,
1403       struct native_io *nio)
1404 {
1405         ssize_t cc;
1406
1407 #if !(defined(REDSTORM) || defined(MAX_IOVEC))
1408 #define MAX_IOVEC      INT_MAX
1409 #endif
1410
1411
1412         if (count <= 0)
1413                 return -EINVAL;
1414
1415         /*
1416          * Avoid the reposition call if we're already at the right place.
1417          * Allows us to access pipes and fifos.
1418          */
1419         if (off != nio->nio_nino->ni_fpos) {
1420                 int     err;
1421
1422                 err = native_pos(nio->nio_nino->ni_fd, &off, SEEK_SET);
1423                 if (err) {
1424                         nio->nio_nino->ni_resetfpos = 1;
1425                         return err;
1426                 }
1427                 nio->nio_nino->ni_resetfpos = 0;
1428                 nio->nio_nino->ni_fpos = off;
1429         }
1430
1431         /*
1432          * The {read,write}v is safe as this routine is only ever called
1433          * by _sysio_enumerate_extents() and that routine is exact. It never
1434          * passes iovectors including tails.
1435          */
1436         cc =
1437 #ifndef REDSTORM
1438             count <= MAX_IOVEC
1439               ? syscall(nio->nio_op == 'r' ? SYSIO_SYS_readv : SYSIO_SYS_writev,
1440                         nio->nio_nino->ni_fd,
1441                         iov,
1442                         count)
1443               :
1444 #endif
1445                 _sysio_enumerate_iovec(iov,
1446                                        count,
1447                                        off,
1448                                        limit,
1449                                        (ssize_t (*)(void *,
1450                                                     size_t,
1451                                                     _SYSIO_OFF_T,
1452                                                     void *))dopio,
1453                                        nio);
1454         if (cc < 0)
1455                 cc = -errno;
1456         else
1457                 nio->nio_nino->ni_fpos += cc;
1458         return cc;
1459
1460 #if !(defined(REDSTORM) || defined(MAX_IOVEC))
1461 #undef MAX_IOVEC
1462 #endif
1463 }
1464
1465 #if 0
1466 static int
1467 lockop_all(struct native_inode *nino,
1468            struct intnl_xtvec *xtv,
1469            size_t count,
1470            short op)
1471 {
1472         struct flock flock;
1473         int     err;
1474
1475         if (!count)
1476                 return -EINVAL;
1477         flock.l_type = op;
1478         flock.l_whence = SEEK_SET;
1479         while (count--) {
1480                 flock.l_start = xtv->xtv_off;
1481                 flock.l_len = xtv->xtv_len;
1482                 xtv++;
1483                 err =
1484                     syscall(SYSIO_SYS_fcntl,
1485                             nino->ni_fd,
1486                             F_SETLK,
1487                             &flock);
1488                 if (err != 0)
1489                         return -errno;
1490         }
1491         return 0;
1492 }
1493
1494 static int
1495 order_xtv(const struct intnl_xtvec *xtv1, const struct intnl_xtvec *xtv2)
1496 {
1497
1498         if (xtv1->xtv_off < xtv2->xtv_off)
1499                 return -1;
1500         if (xtv1->xtv_off > xtv2->xtv_off)
1501                 return 1;
1502         return 0;
1503 }
1504 #endif
1505
1506 static int
1507 doio(char op, struct ioctx *ioctx)
1508 {
1509         struct native_inode *nino;
1510 #if 0
1511         int     dolocks;
1512         struct intnl_xtvec *oxtv;
1513         int     err;
1514 #endif
1515         struct native_io arguments;
1516         ssize_t cc;
1517 #if 0
1518         struct intnl_xtvec *front, *rear, tmp;
1519 #endif
1520
1521         nino = I2NI(ioctx->ioctx_ino);
1522 #if 0
1523         dolocks = ioctx->ioctx_xtvlen > 1 && nino->ni_seekok;
1524         if (dolocks) {
1525                 /*
1526                  * Must lock the regions (in order!) since we can't do
1527                  * strided-IO as a single atomic operation.
1528                  */
1529                 oxtv = malloc(ioctx->ioctx_xtvlen * sizeof(struct intnl_xtvec));
1530                 if (!oxtv)
1531                         return -ENOMEM;
1532                 (void )memcpy(oxtv,
1533                               ioctx->ioctx_xtv,
1534                               ioctx->ioctx_xtvlen * sizeof(struct intnl_xtvec));
1535                 qsort(oxtv,
1536                       ioctx->ioctx_xtvlen,
1537                       sizeof(struct intnl_xtvec),
1538                       (int (*)(const void *, const void *))order_xtv);
1539                 err =
1540                     lockop_all(nino,
1541                                oxtv, ioctx->ioctx_xtvlen,
1542                                op == 'r' ? F_RDLCK : F_WRLCK);
1543                 if (err) {
1544                         free(oxtv);
1545                         return err;
1546                 }
1547         }
1548 #endif
1549         arguments.nio_op = op;
1550         arguments.nio_nino = nino;
1551         cc =
1552             _sysio_enumerate_extents(ioctx->ioctx_xtv, ioctx->ioctx_xtvlen,
1553                                      ioctx->ioctx_iov, ioctx->ioctx_iovlen,
1554                                      (ssize_t (*)(const struct iovec *,
1555                                                   int,
1556                                                   _SYSIO_OFF_T,
1557                                                   ssize_t,
1558                                                   void *))doiov,
1559                                      &arguments);
1560 #if 0
1561         if (dolocks) {
1562                 /*
1563                  * Must unlock in reverse order.
1564                  */
1565                 front = oxtv;
1566                 rear = front + ioctx->ioctx_xtvlen - 1;
1567                 while (front < rear) {
1568                         tmp = *front;
1569                         *front++ = *rear;
1570                         *rear-- = tmp;
1571                 }
1572                 if (lockop_all(nino, oxtv, ioctx->ioctx_xtvlen, F_UNLCK) != 0)
1573                         abort();
1574                 free(oxtv);
1575         }
1576 #endif
1577         if ((ioctx->ioctx_cc = cc) < 0) {
1578                 ioctx->ioctx_errno = -ioctx->ioctx_cc;
1579                 ioctx->ioctx_cc = -1;
1580         }
1581         return 0;
1582 }
1583
1584 static int
1585 native_inop_read(struct inode *ino __IS_UNUSED, struct ioctx *ioctx)
1586 {
1587
1588         return doio('r', ioctx);
1589 }
1590
1591 static int
1592 native_inop_write(struct inode *ino __IS_UNUSED, struct ioctx *ioctx)
1593 {
1594
1595         return doio('w', ioctx);
1596 }
1597
1598 static _SYSIO_OFF_T
1599 native_inop_pos(struct inode *ino, _SYSIO_OFF_T off)
1600 {
1601         struct native_inode *nino = I2NI(ino);
1602         int     err;
1603
1604         err = native_pos(nino->ni_fd, &off, SEEK_SET);
1605         return err < 0 ? err : off;
1606 }
1607
1608 static int
1609 native_inop_iodone(struct ioctx *ioctxp __IS_UNUSED)
1610 {
1611
1612         /*
1613          * It's always done in this driver. It completed when posted.
1614          */
1615         return 1;
1616 }
1617
1618 static int
1619 native_inop_fcntl(struct inode *ino,
1620                   int cmd,
1621                   va_list ap,
1622                   int *rtn)
1623 {
1624         struct native_inode *nino = I2NI(ino);
1625         long    arg;
1626         int     err;
1627
1628         if (nino->ni_fd < 0)
1629                 abort();
1630
1631         err = 0;
1632         switch (cmd) {
1633         case F_GETFD:
1634         case F_GETFL:
1635 #ifdef F_GETOWN
1636         case F_GETOWN:
1637 #endif
1638                 *rtn = syscall(SYSIO_SYS_fcntl, nino->ni_fd, cmd);
1639                 if (*rtn == -1)
1640                         err = -errno;
1641                 break;
1642         case F_DUPFD:
1643         case F_SETFD:
1644         case F_SETFL:
1645         case F_GETLK:
1646         case F_SETLK:
1647         case F_SETLKW:
1648 #ifdef F_SETOWN
1649         case F_SETOWN:
1650 #endif
1651                 arg = va_arg(ap, long);
1652                 *rtn = syscall(SYSIO_SYS_fcntl, nino->ni_fd, cmd, arg);
1653                 if (*rtn == -1)
1654                         err = -errno;
1655                 break;
1656         default:
1657                 *rtn = -1;
1658                 err = -EINVAL;
1659         }
1660         return err;
1661 }
1662
1663 static int
1664 native_inop_mknod(struct pnode *pno __IS_UNUSED,
1665                   mode_t mode __IS_UNUSED,
1666                   dev_t dev __IS_UNUSED)
1667 {
1668
1669         return -ENOSYS;
1670 }
1671
1672 #ifdef _HAVE_STATVFS
1673 static int
1674 native_inop_statvfs(struct pnode *pno,
1675                     struct inode *ino,
1676                     struct intnl_statvfs *buf)
1677 {
1678         char    *path;
1679         int    rc;
1680         struct statfs fs;
1681
1682         path = NULL;
1683         if (!ino || I2NI(ino)->ni_fd < 0) {
1684                 path = _sysio_pb_path(pno->p_base, '/');
1685                 if (!path)
1686                         return -ENOMEM;
1687         }
1688
1689         /*
1690          * The syscall interface does not support SYSIO_SYS_fstatvfs.
1691          * Should possibly return ENOSYS, but thought it
1692          * better to use SYSIO_SYS_fstatfs and fill in as much of
1693          * the statvfs structure as possible.  This allows
1694          * for more of a test of the sysio user interface.
1695          */
1696         rc =
1697             path
1698               ? syscall(SYSIO_SYS_statfs, path, &fs)
1699               : syscall(SYSIO_SYS_fstatfs, I2NI(ino)->ni_fd, &fs);
1700         if (path)
1701                 free(path);
1702         if (rc < 0)
1703                 return -errno;
1704
1705         buf->f_bsize = fs.f_bsize;  /* file system block size */
1706         buf->f_frsize = fs.f_bsize; /* file system fundamental block size */
1707         buf->f_blocks = fs.f_blocks;
1708         buf->f_bfree = fs.f_bfree;
1709         buf->f_bavail = fs.f_bavail;
1710         buf->f_files = fs.f_files;  /* Total number serial numbers */
1711         buf->f_ffree = fs.f_ffree;  /* Number free serial numbers */
1712         buf->f_favail = fs.f_ffree; /* Number free ser num for non-privileged*/
1713         buf->f_fsid = fs.f_fsid.__val[1];
1714         buf->f_flag = 0;            /* No equiv in statfs; maybe use type? */
1715         buf->f_namemax = fs.f_namelen;
1716         return 0;
1717 }
1718 #endif
1719
1720 static int
1721 native_inop_sync(struct inode *ino)
1722 {
1723         int     err;
1724
1725         assert(I2NI(ino)->ni_fd >= 0);
1726
1727         err = syscall(SYSIO_SYS_fsync, I2NI(ino)->ni_fd);
1728         if (err)
1729                 err = -errno;
1730         return err;
1731 }
1732
1733 static int
1734 native_inop_datasync(struct inode *ino)
1735 {
1736         struct native_inode *nino;
1737         int     err;
1738
1739         nino = I2NI(ino);
1740         assert(nino->ni_fd >= 0);
1741
1742 #ifdef SYSIO_SYS_fdatasync
1743         err = syscall(SYSIO_SYS_fdatasync, I2NI(ino)->ni_fd);
1744 #else
1745 #if 0
1746 #warning No fdatasync system call -- Using fsync instead!
1747 #endif
1748         err = syscall(SYSIO_SYS_fsync, I2NI(ino)->ni_fd);
1749 #endif
1750         if (err)
1751                 err = -errno;
1752         return err;
1753 }
1754
1755 #ifdef HAVE_LUSTRE_HACK
1756 static int
1757 native_inop_ioctl(struct inode *ino,
1758                   unsigned long int request,
1759                   va_list ap)
1760 {
1761         struct native_inode *nino;
1762         long arg1, arg2, arg3, arg4;
1763         int     rtn;
1764
1765         nino = I2NI(ino);
1766         assert(nino->ni_fd >= 0);
1767         arg1 = va_arg(ap, long);
1768         arg2 = va_arg(ap, long);
1769         arg3 = va_arg(ap, long);
1770         arg4 = va_arg(ap, long);
1771
1772         rtn =
1773             syscall(SYSIO_SYS_ioctl, I2NI(ino)->ni_fd, request,
1774                     arg1, arg2, arg3, arg4);
1775         if (rtn < 0)
1776                 rtn = -errno;
1777         return rtn;
1778 }
1779 #else
1780 static int
1781 native_inop_ioctl(struct inode *ino __IS_UNUSED,
1782                   unsigned long int request __IS_UNUSED,
1783                   va_list ap __IS_UNUSED)
1784 {
1785
1786         /*
1787          * I'm lazy. Maybe implemented later.
1788          */
1789         return -ENOTTY;
1790 }
1791 #endif
1792
1793 static void
1794 native_inop_gone(struct inode *ino)
1795 {
1796         struct native_inode *nino = I2NI(ino);
1797
1798         if (nino->ni_fd >= 0)
1799                 (void )syscall(SYSIO_SYS_close, nino->ni_fd);
1800
1801         free(ino->i_private);
1802 }
1803
1804 static void
1805 native_fsop_gone(struct filesys *fs __IS_UNUSED)
1806 {
1807
1808         free(fs->fs_private);
1809         /*
1810          * Do nothing. There is no private part maintained for the
1811          * native file interface.
1812          */
1813 }