src/afs/HPUX/osi_vnodeops.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /* This is a placeholder for routines unique to the port of AFS to hp-ux*/
  11
  12 #include <afsconfig.h>
  13 #include "afs/param.h"
  14
  15
  16 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  17 #include "afsincludes.h"        /* Afs-based standard headers */
  18 #include "afs/afs_stats.h"      /* statistics stuff */
  19
  20 #include <sys/uio.h>
  21 #include <sys/vfs.h>
  22 #include <sys/mount.h>
  23 #include <sys/vnode.h>
  24 #include <sys/pathname.h>
  25
  26 extern struct vfsops Afs_vfsops;
  27 extern int afs_hp_strategy();
  28 extern int afs_bmap(), afs_badop(), afs_noop(), afs_lockf();
  29 extern int afs_pagein();
  30 extern int afs_pageout();
  31 extern int afs_ioctl();
  32 extern int afs_prealloc();
  33 extern int afs_mapdbd();
  34 extern int afs_mmap();
  35 extern int afs_cachelimit();
  36 extern int afs_vm_checkpage();
  37 extern int afs_vm_fscontiguous();
  38 extern int afs_vm_stopio();
  39 extern int afs_read_ahead();
  40 extern int afs_unmap();
  41 extern int afs_release();
  42 extern int afs_swapfs_len();
  43 extern int afs_readdir2();
  44 extern int afs_readdir();
  45 extern int afs_readdir3();
  46 extern int afs_pathconf();
  47 extern int afs_close();
  48
  49 #define vtoblksz(vp)    ((vp)->v_vfsp->vfs_bsize)
  50
  51 #if defined(AFS_HPUX110_ENV)
  52 /* We no longer need to lock on the VM Empire,
  53  * or at least that is what is claimed.
  54  * so we will noopt the vmemp_ routines
  55  * This needs to be looked at closer.
  56  */
  57 #define vmemp_lockx()
  58 #undef  vmemp_returnx
  59 #define vmemp_returnx(a) return(a)
  60 #define vmemp_unlockx()
  61 #endif
  62
  63 #if !defined(AFS_HPUX110_ENV)
  64 /*
  65  * Copy an mbuf to the contiguous area pointed to by cp.
  66  * Skip <off> bytes and copy <len> bytes.
  67  * Returns the number of bytes not transferred.
  68  * The mbuf is NOT changed.
  69  */
  70 int
  71 m_cpytoc(m, off, len, cp)
  72      struct mbuf *m;
  73      int off, len;
  74      caddr_t cp;
  75 {
  76     int ml;
  77
  78     if (m == NULL || off < 0 || len < 0 || cp == NULL)
  79         osi_Panic("m_cpytoc");
  80     while (off && m)
  81         if (m->m_len <= off) {
  82             off -= m->m_len;
  83             m = m->m_next;
  84             continue;
  85         } else
  86             break;
  87     if (m == NULL)
  88         return (len);
  89
  90     ml = MIN(len, m->m_len - off);
  91     memcpy(cp, mtod(m, caddr_t) + off, (u_int) ml);
  92     cp += ml;
  93     len -= ml;
  94     m = m->m_next;
  95
  96     while (len && m) {
  97         ml = m->m_len;
  98         memcpy(cp, mtod(m, caddr_t), (u_int) ml);
  99         cp += ml;
 100         len -= ml;
 101         m = m->m_next;
 102     }
 103
 104     return (len);
 105 }
 106 #endif
 107
 108 /*
 109  *  Note that the standard Sun vnode interface doesn't haven't an vop_lockf(), so this code is
 110  * totally new.  This came about because HP-UX has lockf() implemented as
 111  * a system call while Sun has it implemented as a library (apparently).
 112  * To handle this, we have to translate the lockf() request into an
 113  * fcntl() looking request, and then translate the results back if necessary.
 114  * we call afs_lockctl() directly .
 115  */
 116 afs_lockf(vp, flag, len, cred, fp, LB, UB)
 117      struct vnode *vp;
 118      int flag;
 119      afs_ucred_t *cred;
 120      struct file *fp;
 121      k_off_t len, LB, UB;
 122 {
 123     /*for now, just pretend it works */
 124     struct k_flock flock;
 125     int cmd, code;
 126
 127     /*
 128      * Create a flock structure and translate the lockf request
 129      * into an appropriate looking fcntl() type request for afs_lockctl()
 130      */
 131     flock.l_whence = 0;
 132     flock.l_len = len;
 133     flock.l_start = fp->f_offset;
 134     /* convert negative lengths to positive */
 135     if (flock.l_len < 0) {
 136         flock.l_start += flock.l_len;
 137         flock.l_len = -(flock.l_len);
 138     }
 139     /*
 140      * Adjust values to look like fcntl() requests.
 141      * All locks are write locks, only F_LOCK requests
 142      * are blocking.  F_TEST has to be translated into
 143      * a get lock and then back again.
 144      */
 145     flock.l_type = F_WRLCK;
 146     cmd = F_SETLK;
 147     switch (flag) {
 148     case F_ULOCK:
 149         flock.l_type = F_UNLCK;
 150         break;
 151     case F_LOCK:
 152         cmd = F_SETLKW;
 153         break;
 154     case F_TEST:
 155         cmd = F_GETLK;
 156         break;
 157     }
 158     u.u_error = mp_afs_lockctl(vp, &flock, cmd, fp->f_cred);
 159     if (u.u_error) {
 160         return (u.u_error);     /* some other error code */
 161     }
 162     /*
 163      * if request is F_TEST, and GETLK changed
 164      * the lock type to ULOCK, then return 0, else
 165      * set errno to EACCESS and return.
 166      */
 167     if (flag == F_TEST && flock.l_type != F_UNLCK) {
 168         u.u_error = EACCES;
 169         return (u.u_error);
 170     }
 171     return (0);
 172 }
 173
 174
 175 #if defined(AFS_HPUX1122_ENV)
 176 #include "machine/vm/vmparam.h"
 177 #else
 178 #include "../machine/vmparam.h" /* For KERNELSPACE */
 179 #endif
 180 #include "h/debug.h"
 181 #include "h/types.h"
 182 #if !defined(AFS_HPUX1123_ENV)
 183         /* 11.23 is using 64 bit in many cases */
 184 #define kern_daddr_t daddr_t
 185 #endif
 186 #include "h/param.h"
 187 #include "h/vmmac.h"
 188 #include "h/time.h"
 189 #include "ufs/inode.h"
 190 #include "ufs/fs.h"
 191 #include "h/dbd.h"
 192 #if defined(AFS_HPUX1123_ENV)
 193 dbd_t       *finddbd();
 194 #endif /* AFS_HPUX1123_ENV */
 195 #include "h/vfd.h"
 196 #include "h/region.h"
 197 #include "h/pregion.h"
 198 #include "h/vmmeter.h"
 199 #include "h/user.h"
 200 #include "h/sysinfo.h"
 201 #include "h/pfdat.h"
 202 #if !defined(AFS_HPUX1123_ENV)
 203 #include "h/tuneable.h"
 204 #endif
 205 #include "h/buf.h"
 206 #include "netinet/in.h"
 207
 208 /* a freelist of one */
 209 struct buf *afs_bread_freebp = 0;
 210
 211 /*
 212  *  Only rfs_read calls this, and it only looks at bp->b_un.b_addr.
 213  *  Thus we can use fake bufs (ie not from the real buffer pool).
 214  */
 215 afs_bread(vp, lbn, bpp)
 216      struct vnode *vp;
 217      kern_daddr_t lbn;
 218      struct buf **bpp;
 219 {
 220     int offset, fsbsize, error;
 221     struct buf *bp;
 222     struct iovec iov;
 223     struct uio uio;
 224
 225     memset(&uio, 0, sizeof(uio));
 226     memset(&iov, 0, sizeof(iov));
 227
 228     AFS_STATCNT(afs_bread);
 229     fsbsize = vp->v_vfsp->vfs_bsize;
 230     offset = lbn * fsbsize;
 231     if (afs_bread_freebp) {
 232         bp = afs_bread_freebp;
 233         afs_bread_freebp = 0;
 234     } else {
 235         bp = (struct buf *)AFS_KALLOC(sizeof(*bp));
 236         bp->b_un.b_addr = (caddr_t) AFS_KALLOC(fsbsize);
 237     }
 238
 239     iov.iov_base = bp->b_un.b_addr;
 240     iov.iov_len = fsbsize;
 241     uio.afsio_iov = &iov;
 242     uio.afsio_iovcnt = 1;
 243     uio.afsio_seg = AFS_UIOSYS;
 244     uio.afsio_offset = offset;
 245     uio.afsio_resid = fsbsize;
 246     uio.uio_fpflags = 0;
 247     *bpp = 0;
 248
 249     error = afs_read(VTOAFS(vp), &uio, p_cred(u.u_procp), 0);
 250     if (error) {
 251         afs_bread_freebp = bp;
 252         return error;
 253     }
 254     if (*bpp) {
 255         afs_bread_freebp = bp;
 256     } else {
 257         *(struct buf **)&bp->b_vp = bp; /* mark as fake */
 258         *bpp = bp;
 259     }
 260     return 0;
 261 }
 262
 263 afs_brelse(vp, bp)
 264      struct vnode *vp;
 265      struct buf *bp;
 266 {
 267     AFS_STATCNT(afs_brelse);
 268
 269     if ((struct buf *)bp->b_vp != bp) { /* not fake */
 270         ufs_brelse(bp->b_vp, bp);
 271     } else if (afs_bread_freebp) {
 272         AFS_KFREE(bp->b_un.b_addr, vp->v_vfsp->vfs_bsize);
 273         AFS_KFREE(bp, sizeof(*bp));
 274     } else {
 275         afs_bread_freebp = bp;
 276     }
 277 }
 278
 279
 280 afs_bmap(avc, abn, anvp, anbn)
 281      struct vcache *avc;
 282      kern_daddr_t abn, *anbn;
 283      struct vcache **anvp;
 284 {
 285     AFS_STATCNT(afs_bmap);
 286     if (anvp)
 287         *anvp = avc;
 288     if (anbn)
 289         *anbn = abn * (8192 / DEV_BSIZE);       /* in 512 byte units */
 290     return 0;
 291 }
 292
 293 afs_inactive(avc, acred)
 294      struct vcache *avc;
 295      afs_ucred_t *acred;
 296 {
 297     struct vnode *vp = AFSTOV(avc);
 298     ulong_t context;
 299     lock_t *sv_lock;
 300     if (afs_shuttingdown)
 301         return;
 302
 303     /*
 304      * In Solaris and HPUX s800 and HP-UX10.0 they actually call us with
 305      * v_count 1 on last reference!
 306      */
 307     MP_H_SPINLOCK_USAV(vn_h_sl_pool, vp, &sv_lock, &context);
 308     if (avc->vrefCount < 1)
 309         osi_Panic("afs_inactive : v_count < 1\n");
 310
 311     /*
 312      * If more than 1 don't unmap the vnode but do decrement the ref count
 313      */
 314     vp->v_count--;
 315     if (vp->v_count > 0) {
 316         MP_SPINUNLOCK_USAV(sv_lock, context);
 317         return 0;
 318     }
 319     MP_SPINUNLOCK_USAV(sv_lock, context);
 320     afs_InactiveVCache(avc, acred);
 321     return 0;
 322 }
 323
 324
 325 int
 326 mp_afs_open(struct vnode **avcp, int aflags, afs_ucred_t *acred)
 327 {
 328     int code;
 329
 330     AFS_GLOCK();
 331     code = afs_open(avcp, aflags, acred);
 332     AFS_GUNLOCK();
 333     return (code);
 334 }
 335
 336 int
 337 mp_afs_close(struct vnode *avcp, int aflags, afs_ucred_t *acred)
 338 {
 339     int code;
 340
 341     AFS_GLOCK();
 342     code = afs_close(avcp, aflags, acred);
 343     AFS_GUNLOCK();
 344     return (code);
 345 }
 346
 347 int
 348 mp_afs_rdwr(struct vnode *avcp, struct uio *uio, enum uio_rw arw,
 349             int aio, afs_ucred_t *acred)
 350 {
 351     int code;
 352     long save_resid;
 353
 354     AFS_GLOCK();
 355     save_resid = uio->uio_resid;
 356     code = afs_rdwr(avcp, uio, arw, aio, acred);
 357     if (arw == UIO_WRITE && code == ENOSPC) {
 358         /* HP clears code if any data written. */
 359         uio->uio_resid = save_resid;
 360     }
 361     AFS_GUNLOCK();
 362     return (code);
 363 }
 364
 365 int
 366 mp_afs_getattr(struct vnode *avcp, struct vattr *attrs,
 367                afs_ucred_t *acred, enum vsync unused1)
 368 {
 369     int code;
 370
 371     AFS_GLOCK();
 372     code = afs_getattr(avcp, attrs, acred);
 373     AFS_GUNLOCK();
 374     return (code);
 375 }
 376
 377 int
 378 mp_afs_setattr(struct vnode *avcp, struct vattr *attrs,
 379                afs_ucred_t *acred, int unused1)
 380 {
 381     int code;
 382
 383     AFS_GLOCK();
 384     code = afs_setattr(avcp, attrs, acred);
 385     AFS_GUNLOCK();
 386     return (code);
 387 }
 388
 389 int
 390 mp_afs_access(struct vnode *avcp, int mode, afs_ucred_t *acred)
 391 {
 392     int code;
 393
 394     AFS_GLOCK();
 395     code = afs_access(avcp, mode, acred);
 396     AFS_GUNLOCK();
 397     return (code);
 398 }
 399
 400 int
 401 mp_afs_lookup(struct vnode *adp, char *aname,
 402               struct vnode **avcp, afs_ucred_t *acred,
 403               struct vnode *unused1)
 404 {
 405     int code;
 406
 407     AFS_GLOCK();
 408     code = afs_lookup(adp, aname, avcp, acred);
 409     AFS_GUNLOCK();
 410     return (code);
 411 }
 412
 413 int
 414 mp_afs_create(struct vnode *adp, char *aname, struct vattr *attrs,
 415               enum vcexcl aexcl, int amode, struct vnode **avcp,
 416               afs_ucred_t *acred)
 417 {
 418     int code;
 419
 420     AFS_GLOCK();
 421     code = afs_create(adp, aname, attrs, aexcl, amode, avcp, acred);
 422     AFS_GUNLOCK();
 423     return (code);
 424 }
 425
 426
 427 int
 428 mp_afs_remove(struct vnode *adp, char *aname,
 429               afs_ucred_t *acred)
 430 {
 431     int code;
 432
 433     AFS_GLOCK();
 434     code = afs_remove(adp, aname, acred);
 435     AFS_GUNLOCK();
 436     return (code);
 437 }
 438
 439 int
 440 mp_afs_link(struct vnode *avc, struct vnode *adp,
 441             char *aname, afs_ucred_t *acred)
 442 {
 443     int code;
 444
 445     AFS_GLOCK();
 446     code = afs_link(avc, adp, aname, acred);
 447     AFS_GUNLOCK();
 448     return (code);
 449 }
 450
 451 int
 452 mp_afs_rename(struct vnode *aodp, char *aname1,
 453               struct vnode *andp, char *aname2,
 454               afs_ucred_t *acred)
 455 {
 456     int code;
 457
 458     AFS_GLOCK();
 459     code = afs_rename(aodp, aname1, andp, aname2, acred);
 460     AFS_GUNLOCK();
 461     return (code);
 462 }
 463
 464 int
 465 mp_afs_mkdir(struct vnode *adp, char *aname, struct vattr *attrs,
 466              struct vnode **avcp, afs_ucred_t *acred)
 467 {
 468     int code;
 469
 470     AFS_GLOCK();
 471     code = afs_mkdir(adp, aname, attrs, avcp, acred);
 472     AFS_GUNLOCK();
 473     return (code);
 474 }
 475
 476
 477 int
 478 mp_afs_rmdir(struct vnode *adp, char *aname, afs_ucred_t *acred)
 479 {
 480     int code;
 481
 482     AFS_GLOCK();
 483     code = afs_rmdir(adp, aname, acred);
 484     AFS_GUNLOCK();
 485     return (code);
 486 }
 487
 488
 489 int
 490 mp_afs_readdir(struct vnode *avc, struct uio *auio,
 491                afs_ucred_t *acred)
 492 {
 493     int code;
 494
 495     AFS_GLOCK();
 496     code = afs_readdir(avc, auio, acred);
 497     AFS_GUNLOCK();
 498     return (code);
 499 }
 500
 501 int
 502 mp_afs_symlink(struct vnode *adp, char *aname, struct vattr *attrs,
 503                char *atargetName, afs_ucred_t *acred)
 504 {
 505     int code;
 506
 507     AFS_GLOCK();
 508     code = afs_symlink(adp, aname, attrs, atargetName, NULL, acred);
 509     AFS_GUNLOCK();
 510     return (code);
 511 }
 512
 513
 514 int
 515 mp_afs_readlink(struct vnode *avc, struct uio *auio,
 516                 afs_ucred_t *acred)
 517 {
 518     int code;
 519
 520     AFS_GLOCK();
 521     code = afs_readlink(avc, auio, acred);
 522     AFS_GUNLOCK();
 523     return (code);
 524 }
 525
 526 int
 527 mp_afs_fsync(struct vnode *avc, afs_ucred_t *acred, int unused1)
 528 {
 529     int code;
 530
 531     AFS_GLOCK();
 532     code = afs_fsync(avc, acred);
 533     AFS_GUNLOCK();
 534     return (code);
 535 }
 536
 537 int
 538 mp_afs_bread(struct vnode *avc, kern_daddr_t lbn, struct buf **bpp,
 539              struct vattr *unused1, struct ucred *unused2)
 540 {
 541     int code;
 542
 543     AFS_GLOCK();
 544     code = afs_bread(avc, lbn, bpp);
 545     AFS_GUNLOCK();
 546     return (code);
 547 }
 548
 549 int
 550 mp_afs_brelse(struct vnode *avc, struct buf *bp)
 551 {
 552     int code;
 553
 554     AFS_GLOCK();
 555     code = afs_brelse(avc, bp);
 556     AFS_GUNLOCK();
 557     return (code);
 558 }
 559
 560
 561 int
 562 mp_afs_inactive(struct vnode *avc, afs_ucred_t *acred)
 563 {
 564     int code;
 565
 566     AFS_GLOCK();
 567     code = afs_inactive(avc, acred);
 568     AFS_GUNLOCK();
 569     return (code);
 570 }
 571
 572 int
 573 mp_afs_lockctl(struct vnode *avc, struct flock *af, int cmd,
 574                afs_ucred_t *acred, struct file *unused1, off_t unused2,
 575                off_t unused3)
 576 {
 577     int code;
 578
 579     AFS_GLOCK();
 580     code = afs_lockctl(avc, af, cmd, acred);
 581     AFS_GUNLOCK();
 582     return (code);
 583 }
 584
 585 int
 586 mp_afs_fid(struct vnode *avc, struct fid **fidpp)
 587 {
 588     int code;
 589
 590     AFS_GLOCK();
 591     code = afs_fid(avc, fidpp);
 592     AFS_GUNLOCK();
 593     return (code);
 594 }
 595
 596 int
 597 mp_afs_readdir2(struct vnode *avc, struct uio *auio,
 598                 afs_ucred_t *acred)
 599 {
 600     int code;
 601
 602     AFS_GLOCK();
 603     code = afs_readdir2(avc, auio, acred);
 604     AFS_GUNLOCK();
 605     return (code);
 606 }
 607
 608
 609 struct vnodeops Afs_vnodeops = {
 610     mp_afs_open,
 611     mp_afs_close,
 612     mp_afs_rdwr,
 613     afs_ioctl,
 614     afs_noop,
 615     mp_afs_getattr,
 616     mp_afs_setattr,
 617     mp_afs_access,
 618     mp_afs_lookup,
 619     mp_afs_create,
 620     mp_afs_remove,
 621     mp_afs_link,
 622     mp_afs_rename,
 623     mp_afs_mkdir,
 624     mp_afs_rmdir,
 625     afs_readdir,
 626     mp_afs_symlink,
 627     mp_afs_readlink,
 628     mp_afs_fsync,
 629     mp_afs_inactive,
 630     afs_bmap,
 631     afs_hp_strategy,
 632 #if     !defined(AFS_NONFSTRANS)
 633     /* on HPUX102 the nfs translator calls afs_bread but does
 634      * not call afs_brelse. Hence we see a memory leak. If the
 635      * VOP_BREAD() call fails, then nfs does VOP_RDWR() to get
 636      * the same data : this is the path we follow now. */
 637     afs_noop,
 638     afs_noop,
 639 #else
 640     mp_afs_bread,
 641     mp_afs_brelse,
 642 #endif
 643     afs_badop,                  /* pathsend */
 644     afs_noop,                   /* setacl */
 645     afs_noop,                   /* getacl */
 646     afs_pathconf,
 647     afs_pathconf,
 648     mp_afs_lockctl,
 649     afs_lockf,                  /* lockf */
 650     mp_afs_fid,
 651     afs_noop,                   /*fsctl */
 652     afs_badop,
 653     afs_pagein,
 654     afs_pageout,
 655     NULL,
 656     NULL,
 657     afs_prealloc,
 658     afs_mapdbd,
 659     afs_mmap,
 660     afs_cachelimit,
 661     afs_vm_checkpage,
 662     afs_vm_fscontiguous,
 663     afs_vm_stopio,
 664     afs_read_ahead,
 665     afs_release,
 666     afs_unmap,
 667     afs_swapfs_len,
 668     mp_afs_readdir2,
 669     afs_readdir3,
 670 };
 671
 672 struct vnodeops *afs_ops = &Afs_vnodeops;
 673
 674 /* vnode file operations, and our own */
 675 extern int vno_rw();
 676 extern int vno_ioctl();
 677 extern int vno_select();
 678 extern int afs_closex();
 679 extern int vno_close();
 680 struct fileops afs_fileops = {
 681     vno_rw,
 682     vno_ioctl,
 683     vno_select,
 684     afs_close,
 685 };
 686
 687 #define vtoblksz(vp)    ((vp)->v_vfsp->vfs_bsize)
 688
 689 /*
 690  ********************************************************************
 691  ****
 692  ****                   afspgin_setup_io_ranges ()
 693  ****    similar to:    nfspgin_setup_io_ranges ()
 694  ********************************************************************
 695  */
 696 pgcnt_t
 697 afspgin_setup_io_ranges(vfspage_t * vm_info, pgcnt_t bpages, k_off_t isize,
 698                         pgcnt_t startindex)
 699 {
 700     pgcnt_t file_offset = VM_FILE_OFFSET(vm_info);
 701     pgcnt_t minpage;            /* first page to bring in */
 702     pgcnt_t maxpage;            /* one past last page to bring in */
 703     pgcnt_t maxpagein;
 704     pgcnt_t multio_maxpage;
 705     kern_daddr_t start_blk;
 706     dbd_t *dbd;
 707     expnd_flags_t up_reason, down_reason;
 708     int count = 1;
 709     int indx = 0;
 710     int max_num_io;
 711     int dbdtype;
 712     preg_t *prp;
 713
 714     VM_GET_IO_INFO(vm_info, maxpagein, max_num_io);
 715
 716     /*
 717      * We do not go past the end of the current pregion nor past the end
 718      * of the current file.
 719      */
 720
 721     maxpage = startindex + (bpages - (startindex + file_offset) % bpages);
 722     maxpage = vm_reset_maxpage(vm_info, maxpage);
 723     maxpage = MIN(maxpage, (pgcnt_t) btorp(isize) - file_offset);
 724     maxpage = MIN(maxpage, startindex + maxpagein);
 725     multio_maxpage = maxpage = vm_maxpage(vm_info, maxpage);
 726
 727     if (!maxpage)
 728         return (0);
 729
 730     VASSERT(maxpage >= startindex);
 731
 732     /*
 733      * Expanding the fault will create calls to FINDENTRY() for new
 734      * pages, which will obsolete "dbd", so copy what it points to
 735      * and clear it to prevent using stale data.
 736      */
 737
 738     prp = VM_PRP(vm_info);
 739     dbdtype = DBD_TYPE(vm_info);
 740     start_blk = DBD_DATA(vm_info);
 741     vm_info->dbd = NULL;
 742     vm_info->vfd = NULL;
 743     VASSERT(dbdtype != DBD_NONE);
 744
 745     if (max_num_io == 1) {
 746         /*
 747          * We need to set up one I/O: First we attempt to expand the
 748          * I/O forward. Then we expand the I/O backwards.
 749          */
 750         count =
 751             expand_faultin_up(vm_info, dbdtype, (int)bpages, maxpage, count,
 752                               startindex, start_blk, &up_reason);
 753         maxpage = startindex + count;
 754         VASSERT(maxpage <= startindex + maxpagein);
 755         minpage = startindex - (startindex + file_offset) % bpages;
 756         minpage = MAX(minpage, maxpage - maxpagein);
 757         VASSERT(startindex >= VM_BASE_OFFSET(vm_info));
 758         minpage = vm_minpage(vm_info, minpage);
 759         VASSERT(minpage <= startindex);
 760         count =
 761             expand_faultin_down(vm_info, dbdtype, (int)bpages, minpage, count,
 762                                 &startindex, &start_blk, &down_reason);
 763         VM_SET_IO_STARTINDX(vm_info, 0, startindex);
 764         VM_SET_IO_STARTBLK(vm_info, 0, start_blk);
 765         VM_SET_IO_COUNT(vm_info, 0, count);
 766         VM_SET_NUM_IO(vm_info, 1);
 767     }
 768
 769     if (max_num_io > 1) {
 770         /*
 771          * We need to set up multiple I/O information; beginning
 772          * with the startindex, we will expand upwards. The expansion
 773          * could stop for one of 2 reasons; we take the appropriate
 774          * action in each of these cases:
 775          *      o VM reasons: abort setting up the multiple I/O
 776          *        information and return to our caller indicating
 777          *        that "retry" is required.
 778          *      o pagelimit: set up the next I/O info [we may have
 779          *        reached multio_maxpage at this point].
 780          * Note that expansion involves no more than a block at a time;
 781          * hence it could never stop due to "discontiguous block"
 782          * reason.
 783          */
 784         startindex = minpage = vm_minpage(vm_info, 0);
 785         for (indx = 0; (indx < max_num_io) && (startindex < multio_maxpage);
 786              indx++, startindex += count) {
 787             dbd = FINDDBD(prp->p_reg, startindex);
 788             start_blk = dbd->dbd_data;
 789             maxpage =
 790                 startindex + (bpages - (startindex + file_offset) % bpages);
 791             maxpage = min(maxpage, multio_maxpage);
 792             count =
 793                 expand_faultin_up(vm_info, dbdtype, bpages, maxpage,
 794                                   1 /* count */ ,
 795                                   startindex, start_blk, &up_reason);
 796             VM_SET_IO_STARTINDX(vm_info, indx, startindex);
 797             VM_SET_IO_STARTBLK(vm_info, indx, start_blk);
 798             VM_SET_IO_COUNT(vm_info, indx, count);
 799             if (up_reason & VM_REASONS)
 800                 break;
 801             VASSERT(!(up_reason & NONCONTIGUOUS_BLOCK));
 802             VASSERT(up_reason & PAGELIMIT);
 803         }
 804         if (startindex < multio_maxpage) {
 805             VM_MULT_IO_FAILURE(vm_info);
 806             VM_REINIT_FAULT_DBDVFD(vm_info);
 807             return (0);         /* retry */
 808         }
 809         count = maxpagein;
 810         VM_SET_NUM_IO(vm_info, indx);
 811     }
 812
 813     /*
 814      * Tell VM where the I/O intends to start.  This may be different
 815      * from the faulting point.
 816      */
 817
 818     VM_SET_STARTINDX(vm_info, VM_GET_IO_STARTINDX(vm_info, 0));
 819
 820     return (count);
 821
 822 }
 823
 824 /*
 825  ********************************************************************
 826  ****
 827  ****                   afspgin_blkflsh ()
 828  ****   similar to:     nfspgin_blkflsh ()
 829  ********************************************************************
 830  */
 831 retval_t
 832 afspgin_blkflsh(vfspage_t * vm_info, struct vnode * devvp, pgcnt_t * num_4k)
 833 {
 834     int flush_reslt = 0;
 835     pgcnt_t count = *num_4k;
 836     pgcnt_t page_count;
 837     int indx = 0;
 838     int num_io = VM_GET_NUM_IO(vm_info);
 839
 840     /*
 841      * On this blkflush() we don't want to purge the buffer cache and we do
 842      * want to wait, so the flags are '0'.
 843      */
 844
 845     for (indx = 0; indx < num_io; indx++) {
 846         flush_reslt =
 847             blkflush(devvp, (kern_daddr_t) VM_GET_IO_STARTBLK(vm_info, indx),
 848                      ptob(VM_GET_IO_COUNT(vm_info, indx)), 0,
 849                      VM_REGION(vm_info));
 850         if (flush_reslt) {
 851             vm_lock(vm_info);
 852             if (vm_page_now_valid(vm_info, &page_count)) {
 853                 vm_release_memory(vm_info);
 854                 vm_release_structs(vm_info);
 855                 *num_4k = page_count;
 856                 return (VM_PAGE_PRESENT);
 857             }
 858             return (VM_RETRY);
 859         }
 860     }
 861     return (VM_DONE);
 862 }
 863
 864 /*
 865  ********************************************************************
 866  ****
 867  ****                   afspgin_io ()
 868  ****    similar to:    nfspgin_io ()
 869  ********************************************************************
 870  */
 871 int
 872 afspgin_io(vfspage_t * vm_info, struct vnode *devvp, pgcnt_t bpages,
 873            pgcnt_t maxpagein, pgcnt_t count)
 874 {
 875     int i;
 876     int error = 0;
 877     caddr_t vaddr = VM_ADDR(vm_info);
 878     caddr_t virt_addr = VM_MAPPED_ADDR(vm_info);
 879     pagein_info_t *io = VM_PAGEIN_INFO(vm_info);
 880     preg_t *prp = VM_PRP(vm_info);
 881     int wrt = VM_WRT(vm_info);
 882     space_t space = VM_SPACE(vm_info);
 883     int num_io = VM_GET_NUM_IO(vm_info);
 884
 885 #ifdef notdef                   /* Not used in AFS */
 886     /*
 887      * With VM_READ_AHEAD_ALLOWED() macro, check if read-ahead should
 888      * be used in this case.
 889      *
 890      * Unlike UFS, NFS does not start the faulting page I/O
 891      * asynchronously. Why?  Asynchronous requests are handled by the
 892      * biod's.  It doesn't make sense to queue up the faulting request
 893      * behind other asynchrnous requests.  This is not true for UFS
 894      * where the asynchrnous request is immediately handled.
 895      */
 896
 897     if ((VM_READ_AHEAD_ALLOWED(vm_info)) && (nfs_read_ahead_on)
 898         && (NFS_DO_READ_AHEAD) && (should_do_read_ahead(prp, vaddr))) {
 899
 900         pgcnt_t max_rhead_io;
 901         caddr_t rhead_vaddr;
 902         pgcnt_t total_rheads_allowed;
 903
 904         /*
 905          * Determine the maximum amount of read-ahead I/O.
 906          */
 907         total_rheads_allowed = maxpagein - count;
 908
 909         /*
 910          * If the count is less than a block, raise it to one.
 911          */
 912         if (total_rheads_allowed < bpages)
 913             total_rheads_allowed = bpages;
 914
 915         max_rhead_io = total_rheads_allowed;
 916         rhead_vaddr = VM_MAPPED_ADDR(vm_info) + (count * NBPG);
 917         error =
 918             nfs_read_ahead(vm_info->vp, prp, wrt, space, rhead_vaddr,
 919                            &max_rhead_io);
 920
 921         /*
 922          * Set the next fault location.  If read_ahead launches any
 923          * I/O it will adjust it accordingly.
 924          */
 925         vm_info->prp->p_nextfault = vm_info->startindex + count;
 926
 927         /*
 928          * Now perform the faulting I/O synchronously.
 929          */
 930         vm_unlock(vm_info);
 931
 932         error =
 933             syncpageio((swblk_t) VM_GET_IO_STARTBLK(vm_info, 0),
 934                        VM_MAPPED_SPACE(vm_info), VM_MAPPED_ADDR(vm_info),
 935                        (int)ptob(count), B_READ, devvp,
 936                        B_vfs_pagein | B_pagebf, VM_REGION(vm_info));
 937     } else
 938 #endif
 939     {
 940         virt_addr = VM_MAPPED_ADDR(vm_info);
 941         vm_unlock(vm_info);
 942         for (i = 0; i < num_io; i++) {
 943             /*
 944              * REVISIT -- investigate doing asyncpageio().
 945              */
 946             error |= (io[i].error =
 947                       syncpageio((swblk_t) VM_GET_IO_STARTBLK(vm_info, i),
 948                                  VM_MAPPED_SPACE(vm_info), virt_addr,
 949                                  (int)ptob(VM_GET_IO_COUNT(vm_info, i)),
 950                                  B_READ, devvp, B_vfs_pagein | B_pagebf,
 951                                  VM_REGION(vm_info)));
 952             virt_addr += ptob(VM_GET_IO_COUNT(vm_info, i));
 953         }
 954         /*
 955          * Set the next fault location.  If read_ahead launches any
 956          * I/O it will adjust it accordingly.
 957          */
 958         vm_info->prp->p_nextfault = vm_info->startindex + count;
 959     }
 960
 961     return (error);
 962 }
 963
 964 /*
 965  ********************************************************************
 966  ****
 967  ****                   afspgin_update_dbd ()
 968  ****    similar to:    nfspgin_update_dbd ()
 969  ********************************************************************
 970  */
 971 void
 972 afspgin_update_dbd(vfspage_t * vm_info, int bsize)
 973 {
 974     k_off_t off;
 975     pgcnt_t count = bsize / NBPG;
 976     k_off_t rem;
 977     pgcnt_t m;
 978     pgcnt_t pgindx;
 979     kern_daddr_t blkno;
 980     int num_io = VM_GET_NUM_IO(vm_info);
 981     int i;
 982
 983     for (i = 0; i < num_io; i++) {
 984
 985         pgindx = VM_GET_IO_STARTINDX(vm_info, i);
 986         off = vnodindx(VM_REGION(vm_info), pgindx);
 987         rem = off % bsize;
 988         blkno = VM_GET_IO_STARTBLK(vm_info, i);
 989
 990         VASSERT(bsize % NBPG == 0);
 991         VASSERT(rem % NBPG == 0);
 992
 993         pgindx -= (pgcnt_t) btop(rem);
 994         blkno -= (kern_daddr_t) btodb(rem);
 995
 996         /*
 997          * This region could start in mid-block.  If so, pgindx
 998          * could be less than 0, so we adjust pgindx and blkno back
 999          * up so that pgindx is 0.
1000          */
1001
1002         if (pgindx < 0) {
1003             pgcnt_t prem;
1004             prem = 0 - pgindx;
1005             pgindx = 0;
1006             count -= prem;
1007             blkno += btodb(ptob(prem));
1008         }
1009
1010         for (m = 0; m < count && pgindx < VM_REGION_SIZE(vm_info);
1011              m++, pgindx++, blkno += btodb(NBPG)) {
1012             /*
1013              * Note:  since this only changes one block, it
1014              * assumes only one block was faulted in.  Currently
1015              * this is always true for remote files, and we only
1016              * get here for remote files, so everything is ok.
1017              */
1018             vm_mark_dbd(vm_info, pgindx, blkno);
1019         }
1020     }
1021 }
1022
1023 int
1024 afs_pagein(vp, prp, wrt, space, vaddr, ret_startindex)
1025      struct vnode *vp;
1026      preg_t *prp;
1027      int wrt;
1028      space_t space;
1029      caddr_t vaddr;
1030      pgcnt_t *ret_startindex;
1031 {
1032     pgcnt_t startindex;
1033     pgcnt_t pgindx = *ret_startindex;
1034     pgcnt_t maxpagein;
1035     struct vnode *devvp;
1036     pgcnt_t count;
1037     kern_daddr_t start_blk = 0;
1038     int bsize;
1039     int error;
1040     k_off_t isize;
1041     int shared;                 /* writable memory mapped file */
1042     retval_t retval = 0;
1043     pgcnt_t ok_dbd_limit = 0;   /* last dbd that we can trust */
1044     pgcnt_t bpages;             /* number of pages per block */
1045     pgcnt_t page_count;
1046     vfspage_t *vm_info = NULL;
1047     int done;
1048
1049     struct vattr va;
1050
1051     caddr_t nvaddr;
1052     space_t nspace;
1053     int change_to_fstore = 0;   /* need to change dbds to DBD_FSTORE */
1054     int flush_start_blk = 0;
1055     int flush_end_blk = 0;
1056
1057     int i, j;
1058
1059     AFS_STATCNT(afs_pagein);
1060     vmemp_lockx();              /* lock down VM empire */
1061
1062     /* Initialize the VM info structure */
1063     done =
1064         vm_pagein_init(&vm_info, prp, pgindx, space, vaddr, wrt, 0,
1065                        LGPG_ENABLE);
1066
1067     /* Check to see if we slept and the page was falted in. */
1068     if (done) {
1069         vm_release_structs(vm_info);
1070         vmemp_returnx(1);
1071     }
1072
1073     vp = VM_GET_PAGEIN_VNODE(vm_info);
1074     VASSERT(vp != NULL);
1075     shared = VM_SHARED_OBJECT(vm_info);
1076     VASSERT(DBD_TYPE(vm_info) != DBD_NONE);
1077
1078     /*
1079      * Get the devvp and block size for this vnode type
1080      */
1081     devvp = vp;
1082     bsize = vp->v_vfsp->vfs_bsize;
1083     if (bsize <= 0 || (bsize & (DEV_BSIZE - 1)))
1084         osi_Panic("afs_pagein: bsize is zero or not a multiple of DEV_BSIZE");
1085
1086     bpages = (pgcnt_t) btop(bsize);
1087     VASSERT(bpages > 0);
1088     VM_SET_FS_MAX_PAGES(vm_info, bpages);
1089
1090     /* this trace cannot be here because the afs_global lock might not be
1091      * held at this point. We hold the vm global lock throughout
1092      * this procedure ( and not the AFS global lock )
1093      * afs_Trace4(afs_iclSetp, CM_TRACE_HPPAGEIN, ICL_TYPE_POINTER, (afs_int32) vp,
1094      * ICL_TYPE_LONG, DBD_TYPE(vm_info), ICL_TYPE_LONG, bpages,
1095      * ICL_TYPE_LONG, shared);
1096      */
1097     /* Come here if we have to release the region lock before
1098      * locking pages.  This can happen in memreserve() and
1099      * blkflush().
1100      */
1101   retry:
1102     /*
1103      * For remote files like ours, we want to check to see if the file has shrunk.
1104      * If so, we should invalidate any pages past the end.  In the name
1105      * of efficiency, we only do this if the page we want to fault is
1106      * past the end of the file.
1107      */
1108     {
1109         if (VOP_GETATTR(vp, &va, kt_cred(u.u_kthreadp), VIFSYNC) != 0) {
1110             VM_ZOMBIE_OBJECT(vm_info);
1111             vm_release_memory(vm_info);
1112             vm_release_structs(vm_info);
1113             vmemp_returnx(0);
1114         }
1115         isize = va.va_size;
1116         if (vnodindx(VM_REGION(vm_info), pgindx) >= isize) {
1117             /*
1118              * The file has shrunk and someone is trying to access a
1119              * page past the end of the object.  Shrink the object back
1120              * to its currrent size, send a SIGBUS to the faulting
1121              * process and return.
1122              *
1123              * We must release the region lock before calling mtrunc(),
1124              * since mtrunc() locks all the regions that are using this
1125              * file.
1126              */
1127             vm_release_memory(vm_info);
1128             vm_truncate_region(vm_info, isize);
1129             vm_release_structs(vm_info);
1130             vmemp_returnx(-SIGBUS);
1131         }
1132     }
1133
1134     maxpagein = vm_pick_maxpagein(vm_info);
1135     if (vm_wait_for_memory(vm_info, maxpagein, 1)) {
1136         /* Check to see if we should continue faulting.  */
1137         if (vm_page_now_valid(vm_info, &page_count)) {
1138             vm_release_memory(vm_info);
1139             vm_release_structs(vm_info);
1140             vmemp_returnx(page_count);
1141         }
1142     }
1143     if (count = vm_no_io_required(vm_info)) {
1144         /* Release any excess memory.  */
1145         vm_release_memory(vm_info);
1146         vm_release_structs(vm_info);
1147         vmemp_returnx(count);
1148     }
1149 #ifdef OSDEBUG
1150     /*
1151      * We should never have DBD_HOLE pages in a non-MMF region.
1152      */
1153     if (!shared)
1154         VASSERT(dbd->dbd_type != DBD_HOLE);
1155 #endif
1156     VASSERT(DBD_TYPE(vm_info) != DBD_NONE);
1157
1158     startindex = *ret_startindex;
1159
1160     /*
1161      * If the page we want is in memory already, take it
1162      */
1163     if (VM_MEMORY_RESERVED(vm_info) < maxpagein) {
1164         /* pick up the rest of memory now.  */
1165         if (vm_wait_for_memory(vm_info, maxpagein, 0)) {
1166             if (vm_page_now_valid(vm_info, &page_count)) {
1167                 vm_release_memory(vm_info);
1168                 vm_release_structs(vm_info);
1169                 vmemp_returnx(page_count);
1170             }
1171             goto retry;
1172         }
1173     }
1174
1175     if (!
1176         (count =
1177          afspgin_setup_io_ranges(vm_info, bpages, isize, startindex))) {
1178         goto retry;
1179     }
1180
1181     startindex = VM_GET_STARTINDX(vm_info);
1182
1183     VASSERT(maxpagein >= count);
1184
1185     /*
1186      * Release the memory we won't need.
1187      */
1188     if (count < maxpagein) {
1189         vm_release_excess_memory(vm_info,
1190                                  (VM_MEMORY_RESERVED(vm_info) - count));
1191     }
1192
1193     retval = afspgin_blkflsh(vm_info, devvp, &count);
1194
1195     if (retval == VM_RETRY) {
1196         goto retry;
1197     }
1198
1199     if (retval == VM_PAGE_PRESENT)
1200         return (count);
1201
1202 #if 0
1203     /*
1204      * The definition of krusage_cntr_t is in h/kmetric.h, which
1205      * is not shipped.  Since it's just statistics, we punt and do
1206      * not update it.  If it's a problem we'll need to get HP to export
1207      * an interface that we can use to increment the counter.
1208      */
1209
1210     /* It's a real fault, not a reclaim */
1211     {
1212         krusage_cntr_t *temp;
1213         temp = kt_cntrp(u.u_kthreadp);
1214         temp->krc_majflt++;
1215     }
1216 #endif
1217
1218     /*
1219      * Tell VM where the I/O intends to start.  This may be different
1220      * from the faulting point.
1221      */
1222
1223     /*
1224      * vm_prepare_io will fill the region with pages and release the
1225      * region lock.
1226      */
1227     vm_prepare_io(vm_info, &count);
1228
1229     /*
1230      * Count may have been adjusted, check to make sure it's non-zero.
1231      */
1232     if (count == 0) {
1233         if (vm_retry(vm_info)) {
1234             goto retry;
1235         }
1236
1237         /*
1238          * Release resources and retry the fault.  Release any excess
1239          * memory.
1240          */
1241
1242         vm_release_memory(vm_info);
1243         vm_release_structs(vm_info);
1244         vmemp_returnx(0);
1245     }
1246
1247     error = afspgin_io(vm_info, devvp, bpages, maxpagein, count);
1248
1249     if ((VM_IS_ZOMBIE(vm_info)) || (error)) {
1250         retval = -SIGBUS;
1251         VM_ZOMBIE_OBJECT(vm_info);
1252         goto backout;
1253     }
1254     /*
1255      * For a writable memory mapped file that is remote we must
1256      * detect potential holes in the file and force allocation of
1257      * disk space on the remote system.  Unfortunately, there is
1258      * no easy way to do this, so this gets a little ugly.
1259      */
1260     if (shared && wrt) {
1261         /*
1262          * See if The user wants to write to this page.  Write some
1263          * minimal amount of data back to the remote file to
1264          * force allocation of file space.  We only need to
1265          * write a small amount, since holes are always at
1266          * least one filesystem block in size.
1267          */
1268         error = vm_alloc_hole(vm_info);
1269
1270         /*
1271          * If some sort of I/O error occurred we generate a
1272          * SIGBUS for the process that caused the write,
1273          * undo our page locks, etc and return.
1274          */
1275         if ((VM_IS_ZOMBIE(vm_info)) || (error)) {
1276             VM_ZOMBIE_OBJECT(vm_info);
1277             retval = -SIGBUS;
1278             goto backout;
1279         }
1280
1281         /*
1282          * Change these dbds to DBD_FSTORE.  We cannot do it here,
1283          * since the region must be locked, and it is not locked
1284          * at the moment.  We cannot lock the region yet, as we
1285          * first have to release the page locks.
1286          */
1287         change_to_fstore = 1;
1288     }
1289
1290     vm_finish_io(vm_info, count);
1291
1292     /*
1293      * Acquire the lock before we play around with changing the vfd's.
1294      */
1295     vm_lock(vm_info);
1296
1297     if (change_to_fstore)
1298         afspgin_update_dbd(vm_info, bsize);
1299
1300 #if defined(AFS_HPUX110_ENV)
1301     getppdp()->cnt.v_exfod += count;
1302 #else
1303     mpproc_info[getprocindex()].cnt.v_exfod += count;
1304 #endif
1305     vmemp_unlockx();            /* free up VM empire */
1306     *ret_startindex = startindex;
1307
1308     /*
1309      * In case we have any excess memory...
1310      */
1311     if (VM_MEMORY_RESERVED(vm_info))
1312         vm_release_memory(vm_info);
1313     vm_release_structs(vm_info);
1314
1315     return count;
1316
1317   backout:
1318
1319     vm_finish_io_failed(vm_info, count);
1320
1321     vm_lock(vm_info);
1322
1323     vm_undo_validation(vm_info, count);
1324
1325     /*
1326      * In case we have any excess memory...
1327      */
1328     if (VM_MEMORY_RESERVED(vm_info))
1329         vm_release_memory(vm_info);
1330     vm_release_structs(vm_info);
1331
1332     vmemp_unlockx();            /* free up VM empire */
1333     return retval;
1334 }
1335
1336 int
1337 afs_pageout(vp, prp, start, end, flags)
1338      struct vnode *vp;          /* not used */
1339      preg_t *prp;
1340      pgcnt_t start;
1341      pgcnt_t end;
1342      int flags;
1343 {
1344     struct vnode *filevp;
1345     struct vnode *devvp;
1346     pgcnt_t i;
1347     int steal;
1348     int vhand;
1349     int hard;
1350     int *piocnt;                /* wakeup counter used if PAGEOUT_WAIT */
1351     struct ucred *old_cred;
1352     vfspage_t vm_info;
1353     fsdata_t args;
1354
1355     int inode_changed = 0;
1356     int file_is_remote;
1357     struct inode *ip;
1358
1359     AFS_STATCNT(afs_pageout);
1360
1361     steal = (flags & PAGEOUT_FREE);
1362     vhand = (flags & PAGEOUT_VHAND);
1363     hard = (flags & PAGEOUT_HARD);
1364
1365     vmemp_lockx();
1366
1367     /*  Initialize the VM info structure.  */
1368     vm_pageout_init(&vm_info, prp, start, end, 0, 0, 0, flags);
1369
1370     /*
1371      * If the region is marked "don't swap", then don't steal any pages
1372      * from it.  We can, however, write dirty pages out to disk (only if
1373      * PAGEOUT_FREE is not set).
1374      */
1375     if (vm_no_pageout(&vm_info)) {
1376         vmemp_unlockx();
1377         return (0);
1378     }
1379
1380     /*
1381      * If caller wants to wait until the I/O is complete.
1382      */
1383     vm_setup_wait_for_io(&vm_info);
1384
1385     filevp = VM_GET_PAGEOUT_VNODE(&vm_info);    /* always page out to back store */
1386     VASSERT(filevp != NULL);
1387
1388     memset((caddr_t) & args, 0, sizeof(fsdata_t));
1389     args.remote_down = 0;       /* assume remote file servers are up */
1390     args.remote = 1;            /* we are remote */
1391     args.bsize = 0;             /* filled up later by afs_vm_checkpage() */
1392
1393     if (filevp->v_fstype == VUFS) {
1394         ip = VTOI(filevp);
1395         devvp = ip->i_devvp;
1396         file_is_remote = 0;
1397     } else {
1398         file_is_remote = 1;
1399         devvp = filevp;
1400
1401         /*
1402          * If we are vhand(), and this is an NFS file, we need to
1403          * see if the NFS server is "down".  If so, we decide
1404          * if we will try to talk to it again, or defer pageouts
1405          * of dirty NFS pages until a future time.
1406          */
1407 #ifdef  notdef
1408         if (vhand && filevp->v_fstype == VNFS && vtomi(filevp)->mi_down
1409             && vtomi(filevp)->mi_hard) {
1410             extern afs_int32 vhand_nfs_retry;
1411             /*
1412              * If there is still time left on our timer, we will
1413              * not talk to this server right now.
1414              */
1415             if (vhand_nfs_retry > 0)
1416                 args.remote_down = 1;
1417         }
1418 #endif
1419     }
1420
1421     /*
1422      * Initialize args.  We set bsize to 0 to tell vfs_vfdcheck() that
1423      * it must get the file size and other attributes if it comes across
1424      * a dirty page.
1425      */
1426     vm_info.fs_data = (caddr_t) & args;
1427
1428     /* this trace cannot be here because the afs_global lock might not be
1429      * held at this point. We hold the vm global lock throughout
1430      * this procedure ( and not the AFS global lock )
1431      * afs_Trace4(afs_iclSetp, CM_TRACE_HPPAGEOUT, ICL_TYPE_POINTER, (afs_int32) filevp,
1432      * ICL_TYPE_LONG, start, ICL_TYPE_LONG, end, ICL_TYPE_LONG, flags);
1433      */
1434
1435     i = start;
1436
1437     while (i <= end) {
1438         struct buf *bp;
1439         k_off_t start;
1440         pgcnt_t npages;
1441         k_off_t nbytes;
1442         int error;
1443
1444         extern int pageiodone();
1445         space_t nspace;
1446         caddr_t nvaddr;
1447
1448         /*
1449          * Ask the VM system to find the next run of pages.
1450          */
1451         vm_find_next_range(&vm_info, i, end);
1452
1453         /*
1454          * It's possible that the remote file shrunk in size.  Check the flags
1455          * to see if the request was beyond the end of the file.  If it was,
1456          * truncate the region to the file size and continue.  We could be on a
1457          * run so after trunction continue, there may be some I/O to write
1458          * out.
1459          */
1460         if (VM_FS_FLAGS(&vm_info) & PAGEOUT_TRUNCATE) {
1461             pgcnt_t pglen = (pgcnt_t) btorp(args.isize);
1462
1463             /*
1464              * This page is past the end of the file.  Unlock this page
1465              * (region_trunc will throw it away) and then call
1466              * region_trunc() to invalidate all pages past the new end of
1467              * the file.
1468              */
1469             region_trunc(VM_REGION(&vm_info), pglen, pglen + 1);
1470
1471             /*
1472              * remove the truncation flag.
1473              */
1474             VM_UNSETFS_FLAGS(&vm_info, PAGEOUT_TRUNCATE);
1475         }
1476
1477         if (VM_NO_PAGEOUT_RUN(&vm_info))
1478             break;
1479
1480         /*
1481          * We have a run of dirty pages [args.start...args.end].
1482          */
1483         VASSERT(filevp->v_fstype != VCDFS);
1484         VASSERT((filevp->v_vfsp->vfs_flag & VFS_RDONLY) == 0);
1485         VASSERT(VM_GET_NUM_IO(&vm_info) == 1);
1486
1487         /*
1488          * We will be doing an I/O on the region, let the VM system know.
1489          */
1490         (void)vm_up_physio_count(&vm_info);
1491
1492         /*
1493          * Okay, get set to perform the I/O.
1494          */
1495         inode_changed = 1;
1496         npages =
1497             (VM_END_PAGEOUT_INDX(&vm_info) + 1) -
1498             VM_START_PAGEOUT_INDX(&vm_info);
1499
1500         /*
1501          * Allocate and initialize an I/O buffer.
1502          */
1503         bp = bswalloc();
1504         vm_init_bp(&vm_info, bp);       /* Let the VM system initialize */
1505
1506         /* Identify this buffer for KI */
1507         bp->b_bptype = B_vfs_pageout | B_pagebf;
1508
1509         if (steal)
1510             bp->b_flags = B_CALL | B_BUSY | B_PAGEOUT;  /* steal pages */
1511         else
1512             bp->b_flags = B_CALL | B_BUSY;      /* keep pages */
1513
1514         /*
1515          * If we are vhand paging over NFS, we will wait for the I/O
1516          * to complete.
1517          */
1518         if (vhand && filevp->v_fstype == VNFS) {
1519             bp->b_flags &= ~B_CALL;
1520         } else {
1521             bp->b_iodone = (int (*)())pageiodone;
1522         }
1523
1524         /*
1525          * Make sure we do not write past the end of the file.
1526          */
1527         nbytes = ptob(npages);
1528         start = vnodindx(VM_REGION(&vm_info), vm_info.start);
1529         if (start + nbytes > args.isize) {
1530 #ifdef OSDEBUG
1531             /*
1532              * The amount we are off better not be bigger than a
1533              * filesystem block.
1534              */
1535             if (start + nbytes - args.isize >= args.bsize) {
1536                 osi_Panic("afs_pageout: remainder too large");
1537             }
1538 #endif
1539             /*
1540              * Reset the size of the I/O as necessary.  For remote
1541              * files, we set the size to the exact number of bytes to
1542              * the end of the file.  For local files, we round this up
1543              * to the nearest DEV_BSIZE chunk since disk I/O must always
1544              * be in multiples of DEV_BSIZE.  In this case, we do not
1545              * bother to zero out the data past the "real" end of the
1546              * file, this is done when the data is read (either through
1547              * mmap() or by normal file system access).
1548              */
1549             if (file_is_remote)
1550                 nbytes = args.isize - start;
1551             else
1552                 nbytes = roundup(args.isize - start, DEV_BSIZE);
1553         }
1554
1555         /*
1556          * Now get ready to perform the I/O
1557          */
1558         if (!vm_protect_pageout(&vm_info, npages)) {
1559             VASSERT(vhand);
1560             vm_undo_invalidation(&vm_info, vm_info.start, vm_info.end);
1561             vm_finish_io_failed(&vm_info, npages);
1562             bswfree(bp);
1563             break;
1564         }
1565         /*
1566          * If this is an NFS write by vhand(), we will not be calling
1567          * pageiodone().  asyncpageio() increments parolemem for us
1568          * if bp->b_iodone is pageiodone, so we must do it manually
1569          * if pageiodone() will not be called automatically.
1570          */
1571         if (!(bp->b_flags & B_CALL) && steal) {
1572             ulong_t context;
1573
1574             SPINLOCK_USAV(pfdat_lock, context);
1575             parolemem += btorp(nbytes);
1576             SPINUNLOCK_USAV(pfdat_lock, context);
1577         }
1578         blkflush(devvp, VM_START_PAGEOUT_BLK(&vm_info), (long)nbytes,
1579                  (BX_NOBUFWAIT | BX_PURGE), VM_REGION(&vm_info));
1580
1581         /*
1582          * If vhand is the one paging things out, and this is an NFS
1583          * file, we need to temporarily become a different user so
1584          * that we are not trying to page over NFS as root.  We use
1585          * the user credentials associated with the writable file
1586          * pointer that is in the psuedo-vas for this MMF.
1587          *
1588          * NOTE: we are currently using "va_rss" to store the ucred
1589          *       value in the vas (this should be fixed in 10.0).
1590          */
1591         old_cred = kt_cred(u.u_kthreadp);
1592         if (vhand) {
1593 #if defined(AFS_HPUX1123_ENV)
1594                 /*
1595                  * DEE - 1123 does not have the vas.h, and it looks
1596                  * we should never be called with a NFS type file anyway.
1597                  * so where did this come from? Was it copied from NFS?
1598                  * I assume it was, so we will add an assert for now
1599                  * and see if the code runs at all.
1600                  */
1601                 VASSERT(filevp->v_fstype != VNFS);
1602 #else
1603             set_kt_cred(u.u_kthreadp, filevp->v_vas->va_cred);
1604
1605             /*
1606              * If root was the one who opened the mmf for write,
1607              * va_cred will be NULL.  So reset kt_cred(u.u_kthreadp) to what it
1608              * was.  We will page out as root, but that is the
1609              * correct thing to do in this case anyway.
1610              */
1611             if (kt_cred(u.u_kthreadp) == NULL)
1612                 set_kt_cred(u.u_kthreadp, old_cred);
1613 #endif
1614         }
1615
1616         /*
1617          * Really do the I/O.
1618          */
1619         error =
1620             asyncpageio(bp, VM_START_PAGEOUT_BLK(&vm_info),
1621                         VM_MAPPED_SPACE(&vm_info), VM_MAPPED_ADDR(&vm_info),
1622                         (int)nbytes, B_WRITE, devvp);
1623
1624         VASSERT(error == 0);
1625
1626 #ifdef  notdef
1627         /*
1628          * If we are vhand paging over NFS we want to wait for the
1629          * I/O to complete and take the appropriate actions if an
1630          * error is encountered.
1631          */
1632         if (vhand) {
1633             if (waitforpageio(bp) && nfs_mi_harddown(filevp)) {
1634                 /*
1635                  * The server is down, ignore this failure, and
1636                  * try again later. (rfscall() has set our retry
1637                  * timer).
1638                  */
1639                 fsdata.remote_down = 1;
1640                 pageiocleanup(bp, 0);
1641
1642                 /*
1643                  * vm_vfdcheck() has cleared the valid bit on the
1644                  * vfds for these pages.  We must go back and set the
1645                  * valid bit, as the pages are really not gone.
1646                  *
1647                  * NOTE: we can do this because we still hold (and have
1648                  * not released) the region lock.
1649                  */
1650                 if (steal)
1651                     vm_undo_invalidation(&vm_info, vm_info.start,
1652                                          vm_info.end);
1653             } else {
1654                 /*
1655                  * The I/O succeeded, or we had an error that we do
1656                  * not want to defer until later.  Call pageidone()
1657                  * to handle things.
1658                  */
1659                 pageiodone(bp);
1660             }
1661         }
1662 #endif
1663
1664         /*
1665          * And restore our credentials to what they were.
1666          */
1667         set_kt_cred(u.u_kthreadp, old_cred);
1668
1669         /*
1670          * If we reserved memory in vfs_vfdcheck(), (only for NFS) we
1671          * can now unreserve it.
1672          */
1673         if (vm_info.vm_flags & PAGEOUT_RESERVED) {
1674             vm_info.vm_flags &= ~PAGEOUT_RESERVED;
1675             vm_release_malloc_memory();
1676         }
1677
1678         /*
1679          * Update statistics
1680          */
1681         if (steal) {
1682             if (flags & PF_DEACT) {
1683 #if defined(AFS_HPUX110_ENV)
1684                 getppdp()->cnt.v_pswpout += npages;
1685 #else
1686                 mpproc_info[getprocindex()].cnt.v_pswpout += npages;
1687 #endif
1688 /*              sar_bswapout += ptod(npages);*/
1689             } else if (vhand) {
1690 #if defined(AFS_HPUX110_ENV)
1691                 getppdp()->cnt.v_pgout++;
1692                 getppdp()->cnt.v_pgpgout += npages;
1693 #else
1694                 mpproc_info[getprocindex()].cnt.v_pgout++;
1695                 mpproc_info[getprocindex()].cnt.v_pgpgout += npages;
1696 #endif
1697             }
1698         }
1699
1700         /*
1701          * If time and patience have delivered enough
1702          * pages, then quit now while we are ahead.
1703          */
1704         if (VM_STOP_PAGING(&vm_info))
1705             break;
1706
1707         i = VM_END_PAGEOUT_INDX(&vm_info) - VM_BASE_OFFSET(&vm_info) + 1;
1708     }
1709
1710     vm_finish_pageout(&vm_info);        /* update vhand's stealscan */
1711
1712     vmemp_unlockx();
1713
1714     /*
1715      * If we wanted to wait for the I/O to complete, sleep on piocnt.
1716      * We must decrement it by one first, and then make sure that it
1717      * is non-zero before going to sleep.
1718      */
1719     vm_wait_for_io(&vm_info);
1720
1721     if (inode_changed && !file_is_remote) {
1722         imark(ip, IUPD | ICHG);
1723         iupdat(ip, 0, 0);
1724     }
1725     return 0;
1726 }
1727
1728 int
1729 afs_mapdbd(filevp, offset, bn, flags, hole, startidx, endidx)
1730      struct vnode *filevp;
1731      off_t offset;
1732      kern_daddr_t *bn;          /* Block number. */
1733      int flags;                 /* B_READ or B_WRITE */
1734      int *hole;                 /* To be used for read-ahead. */
1735      pgcnt_t *startidx;         /* To be used for read-ahead. */
1736      pgcnt_t *endidx;           /* To be used for read-ahead. */
1737 {
1738     kern_daddr_t lbn, local_bn;
1739     int on;
1740     int err;
1741     long bsize = vtoblksz(filevp) & ~(DEV_BSIZE - 1);
1742
1743     if (startidx)
1744         *startidx = (pgcnt_t) (offset / NBPG);
1745     if (endidx)
1746         *endidx = (pgcnt_t) (offset / NBPG);
1747     if (hole)
1748         *hole = 0;              /* Can't have holes. */
1749     if (bsize <= 0)
1750         osi_Panic("afs_mapdbd: zero size");
1751
1752     lbn = (kern_daddr_t) (offset / bsize);
1753     on = offset % bsize;
1754
1755     err = VOP_BMAP(filevp, lbn, NULL, &local_bn, flags);
1756     VASSERT(err == 0);
1757
1758     /*
1759      * We can never get a bn less than zero on remote files.
1760      */
1761     VASSERT(local_bn >= 0);
1762
1763     local_bn = local_bn + btodb(on);
1764     *bn = local_bn;
1765
1766     return (0);
1767 }
1768
1769 /*
1770  * Return values:
1771  *      1: The blocks are contiguous.
1772  *      0: The blocks are not contiguous.
1773  */
1774 int
1775 afs_vm_fscontiguous(vp, args, cur_data)
1776      struct vnode *vp;
1777      vfspage_t *args;
1778      u_int cur_data;
1779 {
1780     if (cur_data == (VM_END_PAGEOUT_BLK(args) + btodb(NBPG))) {
1781         return (1);
1782     } else {
1783         return (0);
1784     }
1785 }
1786
1787 /*
1788  * Return values:
1789  *      1: Stop, this page is the last in the block.
1790  *      0: Continue on
1791  * Terminate requests at filesystem block boundaries
1792  */
1793 afs_vm_stopio(vp, args)
1794      struct vnode *vp;
1795      vfspage_t *args;
1796 {
1797     fsdata_t *fsdata = (fsdata_t *) args->fs_data;
1798
1799 #if defined(AFS_HPUX1123_ENV)
1800         uint64_t tmpdb;
1801         tmpdb = VM_END_PAGEOUT_BLK(args);
1802
1803         if ((dbtob(tmpdb) + NBPG) % (fsdata->bsize) == 0)
1804 #else
1805     if ((dbtob(VM_END_PAGEOUT_BLK(args)) + NBPG) % (fsdata->bsize) == 0)
1806 #endif /* AFS_HPUX1123_ENV */
1807         {
1808         return (1);
1809     } else {
1810         return (0);
1811     }
1812 }
1813
1814 /*
1815  *      afs_vm_checkpage is called by the VM while collecting a run of
1816  *      pages on a pageout.  afs_vm_checkpage() is called for each page
1817  *      VM wants to write to disk.
1818  */
1819 afs_vm_checkpage(vp, args, pgindx, cur_data)
1820      struct vnode *vp;
1821      vfspage_t *args;
1822      pgcnt_t pgindx;
1823      int cur_data;
1824 {
1825     fsdata_t *fsdata = (fsdata_t *) args->fs_data;
1826
1827     if (fsdata->remote_down) {  /* never happens for AFS */
1828         /*
1829          * The remote system is down.
1830          */
1831         VASSERT(args->run == 0);
1832         return 1;
1833     }
1834     /*
1835      * A dirty page.  If we have not yet determined the file size and
1836      * other attributes that we need to write out pages (the block
1837      * size and ok_dbd_limit), get that information now.
1838      */
1839     if (fsdata->bsize == 0) {
1840         k_off_t isize;
1841         long bsize;
1842         struct vattr va;
1843         struct vnode *filevp;
1844         /*
1845          * Get the various attributes about the file.  Store them
1846          * in args for the next time around.
1847          */
1848         filevp = args->vp;
1849
1850         bsize = vtoblksz(filevp);
1851         args->maxpgs = (pgcnt_t) btop(bsize);
1852
1853         if (VOP_GETATTR(filevp, &va, kt_cred(u.u_kthreadp), VIFSYNC) != 0) {
1854             /*
1855              * The VOP_GETATTR() failed.
1856              * we are vhand, and this is a hard mount, we will
1857              * skip dirty pages for a while and try again later.
1858              */
1859             if (args->vm_flags & PAGEOUT_VHAND) {
1860                 VASSERT(args->run == 0);
1861                 return 1;
1862             }
1863             /*
1864              * This is a "soft" mount, or some other error was
1865              * returned from the server.  Mark this region
1866              * as a zombie, and free this dirty page.
1867              */
1868             VM_ZOMBIE_OBJECT(args);
1869
1870             /*
1871              * The caller will see r_zomb and remove the page
1872              * appropriately.
1873              */
1874             return (1);
1875         }
1876         isize = va.va_size;
1877         fsdata->isize = isize;
1878         fsdata->bsize = bsize;
1879         fsdata->remote = 1;
1880     }
1881     /*
1882      * See if the file has shrunk (this could have happened
1883      * asynchronously because of NFS or DUX).  If so, invalidate
1884      * all of the pages past the end of the file. This is only
1885      * needed for remote files, as local files are truncated
1886      * synchronously.
1887      */
1888
1889     if (vnodindx(VM_REGION(args), pgindx) > fsdata->isize) {
1890         /*
1891          * This page is past the end of the file.  Unlock this page
1892          * (region_trunc will throw it away) and then call region_trunc()
1893          * to invalidate all pages past the new end of the file.
1894          */
1895         VM_SETFS_FLAGS(args, PAGEOUT_TRUNCATE);
1896         return (1);
1897     }
1898 #ifdef notdef
1899     if ((args->vm_flags & PAGEOUT_VHAND)
1900         && (!(args->vm_flags & PAGEOUT_RESERVED))
1901         && (!(VM_IS_ZOMBIE(args)))) {
1902         VASSERT(args->run == 0);
1903         if (vm_reserve_malloc_memory(NFS_PAGEOUT_MEM)) {
1904             /*
1905              * Got enough memory to pageout.  Mark the fact that we did
1906              * a sysprocmemreserve(), so that we can sysprocmemunreserve() it
1907              * later (in remote_pageout()).
1908              */
1909             args->vm_flags |= PAGEOUT_RESERVED;
1910         } else {
1911             /*
1912              * We do not have enough memory to do this pageout.  By
1913              * definition, we do not yet have a run, so we just unlock
1914              * this page and tell foreach_valid() to continue scanning.
1915              * If we come across another dirty page, we will try to
1916              * reserve memory again.  That is okay, in fact some memory
1917              * may have freed up (as earlier pageouts complete under
1918              * interrupt).
1919              */
1920             return 1;
1921         }
1922     }
1923 #endif
1924     return (0);
1925 }
1926
1927 afs_swapfs_len(bp)
1928      struct buf *bp;
1929 {
1930     long fs_bsize;
1931     long max_size;
1932     long bnrem;
1933
1934     fs_bsize = vtoblksz(bp->b_vp);
1935     /*
1936      * Check to see if we are starting mid block.  If so, then
1937      * we must return the remainder of the block or less depending
1938      * on the length.
1939      */
1940     bnrem = bp->b_offset % fs_bsize;
1941     if (bnrem) {
1942         max_size = fs_bsize - bnrem;
1943     } else {
1944         max_size = fs_bsize;
1945     }
1946
1947     if (bp->b_bcount > max_size) {
1948         return (max_size);
1949     } else {
1950         return (bp->b_bcount);
1951     }
1952 }
1953
1954 afs_mmap(vp, off, size_bytes, access)
1955      struct vnode *vp;
1956      u_int off;
1957 #if defined(AFS_HPUX1111_ENV)
1958      u_long size_bytes;
1959 #else
1960      u_int size_bytes;
1961 #endif
1962      int access;
1963 {
1964     long bsize = vtoblksz(vp);
1965
1966     if (bsize % NBPG != 0) {
1967         return (EINVAL);
1968     }
1969
1970     return (0);
1971 }
1972
1973 afs_cachelimit(vp, len, location)
1974      struct vnode *vp;
1975      k_off_t len;
1976      int *location;
1977 {
1978     /*
1979      * Disk addresses are logical, not physical, so fragments are
1980      * transparent.
1981      */
1982     *location = btorp(len) + 1;
1983 }
1984
1985 afs_release(vp)
1986      struct vnode *vp;
1987 {
1988     return (0);
1989 }
1990
1991 int
1992 afs_unmap(vp, off, size_bytes, access)
1993      struct vnode *vp;
1994      u_int off;
1995 #if defined(AFS_HPUX1111_ENV)
1996      u_long size_bytes;
1997 #else
1998      u_int size_bytes;
1999 #endif
2000      int access;
2001 {
2002     return 0;
2003 }
2004
2005 int
2006 afs_read_ahead(vp, prp, wrt, space, vaddr, rhead_cnt)
2007      struct vnode *vp;
2008      preg_t *prp;
2009      int wrt;
2010      space_t space;
2011      caddr_t vaddr;
2012      pgcnt_t *rhead_cnt;
2013 {
2014     printf("afs_read_ahead returning 0 \n");
2015     return 0;
2016 }
2017
2018 int
2019 afs_prealloc(vp, size, ignore_minfree, reserved)
2020      struct vnode *vp;
2021       /* DEE on 11.22 following is off_t */
2022      size_t size;
2023      int ignore_minfree;
2024      int reserved;
2025 {
2026     printf("afs_prealloc returning ENOSPC\n");
2027     return ENOSPC;
2028 }
2029
2030 int
2031 afs_ioctl(vp, com, data, flag, cred)
2032      struct vnode *vp;
2033      int com;
2034      caddr_t data;
2035      int flag;
2036      struct ucred *cred;
2037 {
2038     int error;
2039     struct afs_ioctl afsioctl, *ai;
2040
2041     AFS_STATCNT(afs_ioctl);
2042
2043     /* The call must be a VICEIOCTL call */
2044     if (((com >> 8) & 0xff) == 'V') {
2045 #ifdef notdef
2046         /* AFS_COPYIN returns error 14. Copy data in instead */
2047         AFS_COPYIN(data, (caddr_t) & afsioctl, sizeof(afsioctl), error);
2048         if (error)
2049             return (error);
2050 #endif
2051         ai = (struct afs_ioctl *)data;
2052         afsioctl.in = ai->in;
2053         afsioctl.out = ai->out;
2054         afsioctl.in_size = ai->in_size;
2055         afsioctl.out_size = ai->out_size;
2056         error = HandleIoctl(VTOAFS(vp), com, &afsioctl);
2057         return (error);
2058     }
2059     return (ENOTTY);
2060 }
2061
2062 #if defined(AFS_HPUX1111_ENV)
2063 /* looks like even if appl is 32 bit, we need to round to 8 bytes */
2064 /* This had no effect, it must not be being used */
2065
2066 #define roundtoint(x)   (((x) + (sizeof(long) - 1)) & ~(sizeof(long) - 1))
2067 #define reclen(dp)      roundtoint(((dp)->d_namlen + 1 + (sizeof(u_long)) +\
2068                                 sizeof(u_int) + 2 * sizeof(u_short)))
2069 #else
2070
2071 #define roundtoint(x)   (((x) + (sizeof(int) - 1)) & ~(sizeof(int) - 1))
2072 #define reclen(dp)      roundtoint(((dp)->d_namlen + 1 + (sizeof(u_long)) +\
2073                                 2 * sizeof(u_short)))
2074 #endif
2075
2076 int
2077 afs_readdir(vp, uiop, cred)
2078      struct vnode *vp;
2079      struct uio *uiop;
2080      struct ucred *cred;
2081 {
2082     struct uio auio;
2083     struct iovec aiov;
2084     caddr_t ibuf, obuf, ibufend, obufend;
2085     struct __dirent32 *idp;
2086     struct dirent *odp;
2087     int count, outcount;
2088     dir_off_t offset;
2089     uint64_t tmp_offset;
2090
2091     memset(&auio, 0, sizeof(auio));
2092     memset(&aiov, 0, sizeof(aiov));
2093
2094     count = uiop->uio_resid;
2095     /* Allocate temporary space for format conversion */
2096     ibuf = kmem_alloc(2 * count);       /* overkill - fix later */
2097     obuf = kmem_alloc(count + sizeof(struct dirent));
2098     aiov.iov_base = ibuf;
2099     aiov.iov_len = count;
2100     auio.uio_iov = &aiov;
2101     auio.uio_iovcnt = 1;
2102     offset = auio.uio_offset = uiop->uio_offset;
2103     auio.uio_seg = UIOSEG_KERNEL;
2104     auio.uio_resid = count;
2105     auio.uio_fpflags = 0;
2106
2107     u.u_error = mp_afs_readdir2(vp, &auio, cred);
2108     if (u.u_error)
2109         goto out;
2110
2111     /* Convert entries from __dirent32 to dirent format */
2112
2113     for (idp = (struct __dirent32 *)ibuf, odp =
2114          (struct dirent *)obuf, ibufend =
2115          ibuf + (count - auio.uio_resid), obufend = obuf + count;
2116          (caddr_t) idp < ibufend;
2117          idp = (struct __dirent32 *)((caddr_t) idp + idp->__d_reclen), odp =
2118          (struct dirent *)((caddr_t) odp + odp->d_reclen)) {
2119         odp->d_ino = idp->__d_ino;
2120         odp->d_namlen = idp->__d_namlen;
2121         (void)strcpy(odp->d_name, idp->__d_name);
2122         odp->d_reclen = reclen(odp);
2123         if ((caddr_t) odp + odp->d_reclen > obufend)
2124             break;
2125         /* record offset *after* we're sure to use this entry */
2126         memcpy((char *)&tmp_offset, (char *)&idp->__d_off, sizeof tmp_offset);
2127         offset = tmp_offset;
2128     }
2129
2130     outcount = (caddr_t) odp - obuf;
2131     AFS_UIOMOVE(obuf, outcount, UIO_READ, uiop, u.u_error);
2132     if (u.u_error)
2133         goto out;
2134     uiop->uio_offset = offset;
2135   out:
2136     kmem_free(ibuf, count);
2137     kmem_free(obuf, count + sizeof(struct dirent));
2138     return u.u_error;
2139 }
2140
2141
2142 #define roundtolong(x)   (((x) + (sizeof(long) - 1)) & ~(sizeof(long) - 1))
2143 #define reclen_dirent64(dp)      roundtolong(((dp)->__d_namlen + 1 + (2*sizeof(u_long)) +\
2144                                 2 * sizeof(u_short)))
2145
2146 int
2147 afs_readdir3(vp, uiop, cred)
2148      struct vnode *vp;
2149      struct uio *uiop;
2150      struct ucred *cred;
2151 {
2152     struct uio auio;
2153     struct iovec aiov;
2154     caddr_t ibuf, obuf, ibufend, obufend;
2155     struct __dirent32 *idp;
2156     struct __dirent64 *odp;
2157     int count, outcount;
2158     dir_off_t offset;
2159
2160     memset(&auio, 0, sizeof(auio));
2161     memset(&aiov, 0, sizeof(aiov));
2162
2163     count = uiop->uio_resid;
2164     /* Allocate temporary space for format conversion */
2165     ibuf = kmem_alloc(2 * count);       /* overkill - fix later */
2166     obuf = kmem_alloc(count + sizeof(struct __dirent64));
2167     aiov.iov_base = ibuf;
2168     aiov.iov_len = count;
2169     auio.uio_iov = &aiov;
2170     auio.uio_iovcnt = 1;
2171     offset = auio.uio_offset = uiop->uio_offset;
2172     auio.uio_seg = UIOSEG_KERNEL;
2173     auio.uio_resid = count;
2174     auio.uio_fpflags = 0;
2175
2176     u.u_error = mp_afs_readdir2(vp, &auio, cred);
2177     if (u.u_error)
2178         goto out;
2179
2180     /* Convert entries from __dirent32 to __dirent64 format */
2181
2182     for (idp = (struct __dirent32 *)ibuf, odp =
2183          (struct __dirent64 *)obuf, ibufend =
2184          ibuf + (count - auio.uio_resid), obufend = obuf + count;
2185          (caddr_t) idp < ibufend;
2186          idp = (struct __dirent32 *)((caddr_t) idp + idp->__d_reclen), odp =
2187          (struct __dirent64 *)((caddr_t) odp + odp->__d_reclen)) {
2188         memcpy((char *)&odp->__d_off, (char *)&idp->__d_off,
2189                sizeof odp->__d_off);
2190         odp->__d_ino = idp->__d_ino;
2191         odp->__d_namlen = idp->__d_namlen;
2192         (void)strcpy(odp->__d_name, idp->__d_name);
2193         odp->__d_reclen = reclen_dirent64(odp);
2194         if ((caddr_t) odp + odp->__d_reclen > obufend)
2195             break;
2196         /* record offset *after* we're sure to use this entry */
2197         offset = odp->__d_off;
2198     }
2199
2200     outcount = (caddr_t) odp - obuf;
2201     AFS_UIOMOVE(obuf, outcount, UIO_READ, uiop, u.u_error);
2202     if (u.u_error)
2203         goto out;
2204     uiop->uio_offset = offset;
2205   out:
2206     kmem_free(ibuf, count);
2207     kmem_free(obuf, count + sizeof(struct __dirent64));
2208     return u.u_error;
2209 }
2210
2211 #define AFS_SV_SEMA_HASH 1
2212 #define AFS_SV_SEMA_HASH_DEBUG 0
2213
2214 #if AFS_SV_SEMA_HASH
2215 /* This portion of the code was originally used to implement
2216  * thread specific storage for the semaphore save area. However,
2217  * there were some spare fields in the proc structure, this is
2218  * now being used for the saving semapores.  Hence, this portion of
2219  * the code is no longer used.
2220  */
2221
2222 /* This portion of the code implements thread specific information.
2223  * The thread id is passed in as the key. The semaphore saved area
2224  * is hashed on this key.
2225  */
2226
2227 /* why is this hash table required ?
2228  * The AFS code is written in such a way that a GLOCK() is done in
2229  * one function and the GUNLOCK() is done in another function further
2230  * down the call chain. The GLOCK() call has to save the current
2231  * semaphore status before acquiring afs_global_sema. The GUNLOCK
2232  * has to release afs_global_sema and reacquire the sempahore status
2233  * that existed before the corresponding GLOCK. If GLOCK() and
2234  * GUNLOCK() were called in the same function, the GLOCK call could
2235  * have stored the saved sempahore status in a local variable and the
2236  * corresponding GUNLOCK() call could have restored the original
2237  * status from this local variable. But this is not the case with
2238  * AFS code. Hence, we have to implement a thread specific semaphore
2239  * save area. This is implemented as a hash table. The key is the
2240  * thread id.
2241  */
2242
2243 /* In order for multithreaded processes to work, the sv_sema structures
2244  * must be saved on a per-thread basis, not a per-process basis.  There
2245  * is no per-thread storage available to hijack in the OS per-thread
2246  * data structures (e.g. struct user) so we revive this code.
2247  * I removed the upper limit on the memory consumption since we don't
2248  * know how many threads there will be.  Now the code first checks the
2249  * freeList.  If that fails it then tries garbage collecting.  If that
2250  * doesn't free up anything then it allocs what it needs.
2251  */
2252
2253 #define ELEMENT         sv_sema_t
2254 #define KEY             tid_t
2255 #define Hash(xx)        (  (xx) % sizeOfHashTable )
2256 #define hashLockInit(xx) initsema(&xx,1, FILESYS_SEMA_PRI, FILESYS_SEMA_ORDER)
2257 #define hashLock(xx)    MP_PSEMA(&xx)
2258 #define hashUnlock(xx)  MP_VSEMA(&xx)
2259
2260 typedef struct elem {
2261     struct elem *next;
2262     ELEMENT element;
2263     KEY key;
2264     int refCnt;
2265 } Element;
2266
2267 typedef struct bucket {
2268     sema_t lock;
2269     Element *element;
2270 } Bucket;
2271
2272 static int sizeOfHashTable;
2273 static Bucket *hashTable;
2274
2275 static int currentSize = 0;
2276 static Element *freeList;       /* free list */
2277
2278 #pragma align 64
2279 static sema_t afsHashLock = { 0 };      /* global lock for hash table */
2280
2281 static void afsHashGarbageCollect();
2282
2283 /*
2284 ** The global lock protects the global data structures,
2285 ** e.g. freeList and currentSize.
2286 ** The bucket lock protects the link list hanging off that bucket.
2287 ** The lock hierarchy : one can obtain the bucket lock while holding
2288 ** the global lock, but not vice versa.
2289 */
2290
2291
2292 void
2293 afsHash(int nbuckets)
2294 {                               /* allocate the hash table */
2295     int i;
2296
2297 #if AFS_SV_SEMA_HASH_DEBUG
2298     printf("afsHash: enter\n");
2299 #endif
2300
2301     sizeOfHashTable = nbuckets;
2302     currentSize = nbuckets * sizeof(Bucket);
2303
2304     if (hashTable)
2305         osi_Panic("afs: SEMA Hashtable already created\n");
2306
2307     hashTable = (Bucket *) AFS_KALLOC(sizeOfHashTable * sizeof(Bucket));
2308     if (!hashTable)
2309         osi_Panic("afs: cannot create SEMA Hashtable\n");
2310
2311     /* initialize the hash table and associated locks */
2312     memset(hashTable, 0, sizeOfHashTable * sizeof(Bucket));
2313     for (i = 0; i < sizeOfHashTable; i++)
2314         hashLockInit(hashTable[i].lock);
2315     hashLockInit(afsHashLock);
2316
2317 #if AFS_SV_SEMA_HASH_DEBUG
2318     printf("afsHash: exit\n");
2319 #endif
2320 }
2321
2322 ELEMENT *
2323 afsHashInsertFind(KEY key)
2324 {
2325     int index;
2326     Element *ptr;
2327
2328 #if AFS_SV_SEMA_HASH_DEBUG
2329     printf("afsHashInsertFind: %d\n", key);
2330 #endif
2331     if (!hashTable)
2332         osi_Panic("afs: afsHashInsertFind: no hashTable\n");
2333
2334     index = Hash(key);          /* get bucket number */
2335     hashLock(hashTable[index].lock);    /* lock this bucket */
2336     ptr = hashTable[index].element;
2337
2338     /* if it is already there */
2339     while (ptr) {
2340         if (ptr->key == key) {
2341             ptr->refCnt++;      /* hold it */
2342             hashUnlock(hashTable[index].lock);
2343 #if AFS_SV_SEMA_HASH_DEBUG
2344             printf("afsHashInsertFind: %d FOUND\n", key);
2345 #endif
2346             return &(ptr->element);
2347         } else {
2348             ptr = ptr->next;
2349         }
2350     }
2351
2352     hashUnlock(hashTable[index].lock);
2353
2354     /*  if something exists in the freeList, take it from there */
2355     ptr = NULL;
2356     hashLock(afsHashLock);
2357
2358     if (freeList) {
2359         ptr = freeList;         /* reuse entry */
2360         freeList = freeList->next;
2361     } else {
2362         afsHashGarbageCollect();        /* afsHashLock locked */
2363         if (freeList) {
2364             ptr = freeList;     /* reuse entry */
2365             freeList = freeList->next;
2366         } else {
2367             ptr = (Element *) AFS_KALLOC(sizeof(Element));
2368         }
2369     }
2370
2371     currentSize += sizeof(Element);     /* update memory used */
2372     hashUnlock(afsHashLock);
2373
2374     if (!ptr)
2375         osi_Panic("afs: SEMA Hashtable cannot create new entry\n");
2376     /* create new entry */
2377     ptr->key = key;
2378     memset(&ptr->element, 0, sizeof(ptr->element));
2379     ptr->refCnt = 1;            /* this guy */
2380
2381     /* insert new entry in bucket */
2382     hashLock(hashTable[index].lock);    /* lock this bucket */
2383     ptr->next = hashTable[index].element;
2384     hashTable[index].element = ptr;
2385     hashUnlock(hashTable[index].lock);
2386
2387 #if AFS_SV_SEMA_HASH_DEBUG
2388     printf("afsHashInsertFind: %d MADE\n", key);
2389 #endif
2390
2391     return &(ptr->element);
2392 }
2393
2394 ELEMENT *
2395 afsHashFind(KEY key)
2396 {
2397     int index;
2398     Element *ptr;
2399
2400 #if AFS_SV_SEMA_HASH_DEBUG
2401     printf("afsHashFind: %d\n", key);
2402 #endif
2403     if (!hashTable)
2404         osi_Panic("afs: afsHashFind: no hashTable\n");
2405
2406     index = Hash(key);          /* get bucket number */
2407     hashLock(hashTable[index].lock);    /* lock this bucket */
2408     ptr = hashTable[index].element;
2409
2410     /* it should be in the hash table */
2411     while (ptr) {
2412         if (ptr->key == key) {
2413             if (ptr->refCnt <= 0)
2414                 osi_Panic("afs: SEMA HashTable entry already released\n");
2415             hashUnlock(hashTable[index].lock);
2416 #if AFS_SV_SEMA_HASH_DEBUG
2417             printf("afsHashFind: %d FOUND\n", key);
2418 #endif
2419             return &(ptr->element);
2420         } else {
2421             ptr = ptr->next;
2422         }
2423     }
2424
2425     hashUnlock(hashTable[index].lock);
2426     /* it better be in the hash table */
2427     osi_Panic("afs: SEMA HashTable wants non-existent entry \n");
2428     return 0;
2429 }
2430
2431 void
2432 afsHashRelease(KEY key)
2433 {
2434     int index;
2435     Element *ptr;
2436
2437 #if AFS_SV_SEMA_HASH_DEBUG
2438     printf("afsHashRelease: %d\n", key);
2439 #endif
2440     if (!hashTable)
2441         osi_Panic("afs: afsHashRelease: no hashTable\n");
2442
2443     index = Hash(key);          /* get bucket number */
2444     hashLock(hashTable[index].lock);    /* lock this bucket */
2445     ptr = hashTable[index].element;
2446
2447     /* it should be in the hash table */
2448     while (ptr) {
2449         if (ptr->key == key) {
2450             if (ptr->refCnt <= 0)
2451                 osi_Panic("afs: SEMA HashTable entry already released\n");
2452             ptr->refCnt--;      /* release this guy */
2453             hashUnlock(hashTable[index].lock);
2454 #if AFS_SV_SEMA_HASH_DEBUG
2455             printf("afsHashRelease: %d FOUND\n", key);
2456 #endif
2457             return;
2458         } else {
2459             ptr = ptr->next;
2460         }
2461     }
2462
2463     hashUnlock(hashTable[index].lock);
2464     /* it better be in the hash table */
2465     osi_Panic("afs: SEMA HashTable deleting non-existent entry \n");
2466 }
2467
2468 /* this should be called with afsHashLock WRITE locked */
2469 static void
2470 afsHashGarbageCollect()
2471 {
2472     int index;
2473     Element *ptr;
2474     int foundFlag = 0;
2475
2476     if (!hashTable)
2477         osi_Panic("afs: afsHashGarbageCollect: no hashTable\n");
2478
2479     for (index = 0; index < sizeOfHashTable; index++) {
2480         hashLock(hashTable[index].lock);
2481         ptr = hashTable[index].element; /* pick up bucket */
2482
2483         while (ptr && !ptr->refCnt) {
2484             /* insert this element into free list */
2485             Element *temp;
2486             temp = ptr->next;
2487             ptr->next = freeList;
2488             freeList = ptr;
2489
2490             foundFlag = 1;      /* found at least one */
2491             currentSize -= sizeof(Element);
2492             ptr = temp;
2493         }
2494         hashTable[index].element = ptr;
2495
2496         /* scan thru the remaining list */
2497         if (ptr) {
2498             while (ptr->next) {
2499                 if (ptr->next->refCnt == 0) {
2500                     /* collect this element */
2501                     Element *temp;
2502                     temp = ptr->next;
2503                     ptr->next = ptr->next->next;
2504                     temp->next = freeList;
2505                     freeList = temp;
2506                     foundFlag = 1;
2507                     currentSize -= sizeof(Element);
2508                 } else {
2509                     ptr = ptr->next;
2510                 }
2511             }
2512         }
2513         hashUnlock(hashTable[index].lock);
2514     }
2515 #if 0
2516     if (!foundFlag)
2517         osi_Panic("afs: SEMA HashTable full\n");
2518 #endif
2519 }
2520
2521 #endif /* AFS_SV_SEMA_HASH */
2522
2523
2524 afs_hp_strategy(bp)
2525      struct buf *bp;
2526 {
2527     afs_int32 code;
2528     struct uio tuio;
2529     struct iovec tiovec[1];
2530     extern caddr_t hdl_kmap_bp();
2531     struct kthread *t = u.u_kthreadp;
2532
2533     memset(&tuio, 0, sizeof(tuio));
2534     memset(&tiovec, 0, sizeof(tiovec));
2535
2536     AFS_STATCNT(afs_hp_strategy);
2537     /*
2538      * hdl_kmap_bp() saves "b_bcount" and restores it in hdl_remap_bp() after
2539      * the I/O.  We must save and restore the count because pageiodone()
2540      * uses b_bcount to determine how many pages to unlock.
2541      *
2542      * Remap the entire range.
2543      */
2544     hdl_kmap_bp(bp);
2545
2546     AFS_GLOCK();
2547     afs_Trace4(afs_iclSetp, CM_TRACE_HPSTRAT, ICL_TYPE_POINTER, bp->b_vp,
2548                ICL_TYPE_LONG, (int)bp->b_blkno * DEV_BSIZE, ICL_TYPE_LONG,
2549                bp->b_bcount, ICL_TYPE_LONG, 0);
2550
2551     /* Set up the uio structure */
2552     tuio.afsio_iov = tiovec;
2553     tuio.afsio_iovcnt = 1;
2554     tuio.afsio_offset = DEV_BSIZE * bp->b_blkno;
2555     tuio.afsio_seg = AFS_UIOSYS;
2556     tuio.afsio_resid = bp->b_bcount;
2557     tuio.uio_fpflags = 0;
2558     tiovec[0].iov_base = bp->b_un.b_addr;
2559     tiovec[0].iov_len = bp->b_bcount;
2560
2561     /* Do the I/O */
2562     if ((bp->b_flags & B_READ) == B_READ) {
2563         /* read b_bcount bytes into kernel address b_un.b_addr
2564          * starting at byte DEV_BSIZE * b_blkno. Bzero anything
2565          * we can't read, and finally call iodone(bp).  File is
2566          * in bp->b_vp. Credentials are from u area??
2567          */
2568         code = afs_rdwr(VTOAFS(bp->b_vp), &tuio, UIO_READ, 0, kt_cred(t));
2569         if (code == 0)
2570             if (tuio.afsio_resid > 0) {
2571                 privlbzero(bvtospace(bp, bp->b_un.b_addr),
2572                            bp->b_un.b_addr + bp->b_bcount - tuio.afsio_resid,
2573                            (size_t) tuio.afsio_resid);
2574
2575             }
2576     } else
2577         code = afs_rdwr(VTOAFS(bp->b_vp), &tuio, UIO_WRITE, 0, kt_cred(t));
2578
2579     /* Remap back to the user's space */
2580     hdl_remap_bp(bp);
2581
2582     AFS_GUNLOCK();
2583
2584     iodone(bp);
2585     return code;
2586 }
2587
2588 afs_pathconf(vp, name, resultp, cred)
2589      struct vnode *vp;
2590      int name;
2591      int *resultp;
2592      struct ucred *cred;        /* unused */
2593 {
2594     switch (name) {
2595     case _PC_LINK_MAX:          /* Maximum number of links to a file */
2596         *resultp = 255;         /* an unsigned short on the fileserver */
2597         break;                  /* a unsigned char in the client.... */
2598
2599     case _PC_NAME_MAX:          /* Max length of file name */
2600         *resultp = 255;
2601         break;
2602
2603     case _PC_PATH_MAX:          /* Maximum length of Path Name */
2604         *resultp = 1024;
2605         break;
2606
2607     case _PC_PIPE_BUF:          /* Max atomic write to pipe.  See fifo_vnops */
2608     case _PC_CHOWN_RESTRICTED:  /* Anybody can chown? */
2609     case _PC_NO_TRUNC:          /* No file name truncation on overflow? */
2610         u.u_error = EOPNOTSUPP;
2611         return (EOPNOTSUPP);
2612         break;
2613
2614     case _PC_MAX_CANON: /* TTY buffer size for canonical input */
2615         /* need more work here for pty, ite buffer size, if differ */
2616         if (vp->v_type != VCHR) {
2617             u.u_error = EINVAL;
2618             return (EINVAL);
2619         }
2620         *resultp = CANBSIZ;     /*for tty */
2621         break;
2622
2623     case _PC_MAX_INPUT:
2624         /* need more work here for pty, ite buffer size, if differ */
2625         if (vp->v_type != VCHR) {       /* TTY buffer size */
2626             u.u_error = EINVAL;
2627             return (EINVAL);
2628         }
2629         *resultp = TTYHOG;      /*for tty */
2630         break;
2631
2632     case _PC_VDISABLE:
2633         /* Terminal special characters can be disabled? */
2634         if (vp->v_type != VCHR) {
2635             u.u_error = EINVAL;
2636             return (EINVAL);
2637         }
2638         *resultp = 1;
2639         break;
2640
2641     case _PC_SYNC_IO:
2642         if ((vp->v_type != VREG) && (vp->v_type != VBLK)) {
2643             *resultp = -1;
2644             return EINVAL;
2645         }
2646         *resultp = 1;           /* Synchronized IO supported for this file */
2647         break;
2648
2649     case _PC_FILESIZEBITS:
2650         if (vp->v_type != VDIR)
2651             return (EINVAL);
2652         *resultp = MAX_SMALL_FILE_BITS;
2653         break;
2654
2655     default:
2656         return (EINVAL);
2657     }
2658
2659     return (0);
2660 }