kernel/fs/pcfs/pc_vnops.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
  29  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  30  * Copyright (c) 2017 by Delphix. All rights reserved.
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/t_lock.h>
  35 #include <sys/systm.h>
  36 #include <sys/sysmacros.h>
  37 #include <sys/user.h>
  38 #include <sys/buf.h>
  39 #include <sys/stat.h>
  40 #include <sys/vfs.h>
  41 #include <sys/dirent.h>
  42 #include <sys/vnode.h>
  43 #include <sys/proc.h>
  44 #include <sys/file.h>
  45 #include <sys/fcntl.h>
  46 #include <sys/uio.h>
  47 #include <sys/fs/pc_label.h>
  48 #include <sys/fs/pc_fs.h>
  49 #include <sys/fs/pc_dir.h>
  50 #include <sys/fs/pc_node.h>
  51 #include <sys/mman.h>
  52 #include <sys/pathname.h>
  53 #include <sys/vmsystm.h>
  54 #include <sys/cmn_err.h>
  55 #include <sys/debug.h>
  56 #include <sys/statvfs.h>
  57 #include <sys/unistd.h>
  58 #include <sys/kmem.h>
  59 #include <sys/conf.h>
  60 #include <sys/flock.h>
  61 #include <sys/policy.h>
  62 #include <sys/sdt.h>
  63 #include <sys/sunddi.h>
  64 #include <sys/types.h>
  65 #include <sys/errno.h>
  66
  67 #include <vm/seg.h>
  68 #include <vm/page.h>
  69 #include <vm/pvn.h>
  70 #include <vm/seg_map.h>
  71 #include <vm/seg_vn.h>
  72 #include <vm/hat.h>
  73 #include <vm/as.h>
  74 #include <vm/seg_kmem.h>
  75
  76 #include <sys/fs_subr.h>
  77
  78 static int pcfs_open(struct vnode **, int, struct cred *, caller_context_t *ct);
  79 static int pcfs_close(struct vnode *, int, int, offset_t, struct cred *,
  80         caller_context_t *ct);
  81 static int pcfs_read(struct vnode *, struct uio *, int, struct cred *,
  82         caller_context_t *);
  83 static int pcfs_write(struct vnode *, struct uio *, int, struct cred *,
  84         caller_context_t *);
  85 static int pcfs_getattr(struct vnode *, struct vattr *, int, struct cred *,
  86         caller_context_t *ct);
  87 static int pcfs_setattr(struct vnode *, struct vattr *, int, struct cred *,
  88         caller_context_t *);
  89 static int pcfs_access(struct vnode *, int, int, struct cred *,
  90         caller_context_t *ct);
  91 static int pcfs_lookup(struct vnode *, char *, struct vnode **,
  92         struct pathname *, int, struct vnode *, struct cred *,
  93         caller_context_t *, int *, pathname_t *);
  94 static int pcfs_create(struct vnode *, char *, struct vattr *,
  95         enum vcexcl, int mode, struct vnode **, struct cred *, int,
  96         caller_context_t *, vsecattr_t *);
  97 static int pcfs_remove(struct vnode *, char *, struct cred *,
  98         caller_context_t *, int);
  99 static int pcfs_rename(struct vnode *, char *, struct vnode *, char *,
 100         struct cred *, caller_context_t *, int);
 101 static int pcfs_mkdir(struct vnode *, char *, struct vattr *, struct vnode **,
 102         struct cred *, caller_context_t *, int, vsecattr_t *);
 103 static int pcfs_rmdir(struct vnode *, char *, struct vnode *, struct cred *,
 104         caller_context_t *, int);
 105 static int pcfs_readdir(struct vnode *, struct uio *, struct cred *, int *,
 106         caller_context_t *, int);
 107 static int pcfs_fsync(struct vnode *, int, struct cred *, caller_context_t *);
 108 static void pcfs_inactive(struct vnode *, struct cred *, caller_context_t *);
 109 static int pcfs_fid(struct vnode *vp, struct fid *fidp, caller_context_t *);
 110 static int pcfs_space(struct vnode *, int, struct flock64 *, int,
 111         offset_t, cred_t *, caller_context_t *);
 112 static int pcfs_getpage(struct vnode *, offset_t, size_t, uint_t *, page_t *[],
 113         size_t, struct seg *, caddr_t, enum seg_rw, struct cred *,
 114         caller_context_t *);
 115 static int pcfs_getapage(struct vnode *, uoff_t, size_t, uint_t *,
 116         page_t *[], size_t, struct seg *, caddr_t, enum seg_rw, struct cred *);
 117 static int pcfs_putpage(struct vnode *, offset_t, size_t, int, struct cred *,
 118         caller_context_t *);
 119 static int pcfs_map(struct vnode *, offset_t, struct as *, caddr_t *, size_t,
 120         uchar_t, uchar_t, uint_t, struct cred *, caller_context_t *);
 121 static int pcfs_addmap(struct vnode *, offset_t, struct as *, caddr_t,
 122         size_t, uchar_t, uchar_t, uint_t, struct cred *, caller_context_t *);
 123 static int pcfs_delmap(struct vnode *, offset_t, struct as *, caddr_t,
 124         size_t, uint_t, uint_t, uint_t, struct cred *, caller_context_t *);
 125 static int pcfs_seek(struct vnode *, offset_t, offset_t *,
 126         caller_context_t *);
 127 static int pcfs_pathconf(struct vnode *, int, ulong_t *, struct cred *,
 128         caller_context_t *);
 129
 130 int pcfs_putapage(struct vnode *, page_t *, uoff_t *, size_t *, int,
 131         struct cred *);
 132 static int rwpcp(struct pcnode *, struct uio *, enum uio_rw, int);
 133 static int get_long_fn_chunk(struct pcdir_lfn *ep, char *buf);
 134
 135 extern krwlock_t pcnodes_lock;
 136
 137 #define lround(r)       (((r)+sizeof (long long)-1)&(~(sizeof (long long)-1)))
 138
 139 /*
 140  * vnode op vectors for files and directories.
 141  */
 142 const struct vnodeops pcfs_fvnodeops = {
 143         .vnop_name = "pcfs",
 144         .vop_open = pcfs_open,
 145         .vop_close = pcfs_close,
 146         .vop_read = pcfs_read,
 147         .vop_write = pcfs_write,
 148         .vop_getattr = pcfs_getattr,
 149         .vop_setattr = pcfs_setattr,
 150         .vop_access = pcfs_access,
 151         .vop_fsync = pcfs_fsync,
 152         .vop_inactive = pcfs_inactive,
 153         .vop_fid = pcfs_fid,
 154         .vop_seek = pcfs_seek,
 155         .vop_space = pcfs_space,
 156         .vop_getpage = pcfs_getpage,
 157         .vop_putpage = pcfs_putpage,
 158         .vop_map = pcfs_map,
 159         .vop_addmap = pcfs_addmap,
 160         .vop_delmap = pcfs_delmap,
 161         .vop_pathconf = pcfs_pathconf,
 162         .vop_vnevent = fs_vnevent_support,
 163 };
 164
 165 const struct vnodeops pcfs_dvnodeops = {
 166         .vnop_name = "pcfs",
 167         .vop_open = pcfs_open,
 168         .vop_close = pcfs_close,
 169         .vop_getattr = pcfs_getattr,
 170         .vop_setattr = pcfs_setattr,
 171         .vop_access = pcfs_access,
 172         .vop_lookup = pcfs_lookup,
 173         .vop_create = pcfs_create,
 174         .vop_remove = pcfs_remove,
 175         .vop_rename = pcfs_rename,
 176         .vop_mkdir = pcfs_mkdir,
 177         .vop_rmdir = pcfs_rmdir,
 178         .vop_readdir = pcfs_readdir,
 179         .vop_fsync = pcfs_fsync,
 180         .vop_inactive = pcfs_inactive,
 181         .vop_fid = pcfs_fid,
 182         .vop_seek = pcfs_seek,
 183         .vop_pathconf = pcfs_pathconf,
 184         .vop_vnevent = fs_vnevent_support,
 185 };
 186
 187
 188 /*ARGSUSED*/
 189 static int
 190 pcfs_open(
 191         struct vnode **vpp,
 192         int flag,
 193         struct cred *cr,
 194         caller_context_t *ct)
 195 {
 196         return (0);
 197 }
 198
 199 /*
 200  * files are sync'ed on close to keep floppy up to date
 201  */
 202
 203 /*ARGSUSED*/
 204 static int
 205 pcfs_close(
 206         struct vnode *vp,
 207         int flag,
 208         int count,
 209         offset_t offset,
 210         struct cred *cr,
 211         caller_context_t *ct)
 212 {
 213         return (0);
 214 }
 215
 216 /*ARGSUSED*/
 217 static int
 218 pcfs_read(
 219         struct vnode *vp,
 220         struct uio *uiop,
 221         int ioflag,
 222         struct cred *cr,
 223         struct caller_context *ct)
 224 {
 225         struct pcfs *fsp;
 226         struct pcnode *pcp;
 227         int error;
 228
 229         fsp = VFSTOPCFS(vp->v_vfsp);
 230         if (error = pc_verify(fsp))
 231                 return (error);
 232         error = pc_lockfs(fsp, 0, 0);
 233         if (error)
 234                 return (error);
 235         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL) {
 236                 pc_unlockfs(fsp);
 237                 return (EIO);
 238         }
 239         error = rwpcp(pcp, uiop, UIO_READ, ioflag);
 240         if ((fsp->pcfs_vfs->vfs_flag & VFS_RDONLY) == 0) {
 241                 pc_mark_acc(fsp, pcp);
 242         }
 243         pc_unlockfs(fsp);
 244         if (error) {
 245                 PC_DPRINTF1(1, "pcfs_read: io error = %d\n", error);
 246         }
 247         return (error);
 248 }
 249
 250 /*ARGSUSED*/
 251 static int
 252 pcfs_write(
 253         struct vnode *vp,
 254         struct uio *uiop,
 255         int ioflag,
 256         struct cred *cr,
 257         struct caller_context *ct)
 258 {
 259         struct pcfs *fsp;
 260         struct pcnode *pcp;
 261         int error;
 262
 263         fsp = VFSTOPCFS(vp->v_vfsp);
 264         if (error = pc_verify(fsp))
 265                 return (error);
 266         error = pc_lockfs(fsp, 0, 0);
 267         if (error)
 268                 return (error);
 269         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL) {
 270                 pc_unlockfs(fsp);
 271                 return (EIO);
 272         }
 273         if (ioflag & FAPPEND) {
 274                 /*
 275                  * in append mode start at end of file.
 276                  */
 277                 uiop->uio_loffset = pcp->pc_size;
 278         }
 279         error = rwpcp(pcp, uiop, UIO_WRITE, ioflag);
 280         pcp->pc_flags |= PC_MOD;
 281         pc_mark_mod(fsp, pcp);
 282         if (ioflag & (FSYNC|FDSYNC))
 283                 (void) pc_nodeupdate(pcp);
 284
 285         pc_unlockfs(fsp);
 286         if (error) {
 287                 PC_DPRINTF1(1, "pcfs_write: io error = %d\n", error);
 288         }
 289         return (error);
 290 }
 291
 292 /*
 293  * read or write a vnode
 294  */
 295 static int
 296 rwpcp(
 297         struct pcnode *pcp,
 298         struct uio *uio,
 299         enum uio_rw rw,
 300         int ioflag)
 301 {
 302         struct vnode *vp = PCTOV(pcp);
 303         struct pcfs *fsp;
 304         daddr_t bn;                     /* phys block number */
 305         int n;
 306         offset_t off;
 307         caddr_t base;
 308         int mapon, pagecreate;
 309         int newpage;
 310         int error = 0;
 311         rlim64_t limit = uio->uio_llimit;
 312         int oresid = uio->uio_resid;
 313
 314         /*
 315          * If the filesystem was umounted by force, return immediately.
 316          */
 317         if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
 318                 return (EIO);
 319
 320         PC_DPRINTF4(5, "rwpcp pcp=%p off=%lld resid=%ld size=%u\n", (void *)pcp,
 321             uio->uio_loffset, uio->uio_resid, pcp->pc_size);
 322
 323         ASSERT(rw == UIO_READ || rw == UIO_WRITE);
 324         ASSERT(vp->v_type == VREG);
 325
 326         if (uio->uio_loffset >= UINT32_MAX && rw == UIO_READ) {
 327                 return (0);
 328         }
 329
 330         if (uio->uio_loffset < 0)
 331                 return (EINVAL);
 332
 333         if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T)
 334                 limit = MAXOFFSET_T;
 335
 336         if (uio->uio_loffset >= limit && rw == UIO_WRITE) {
 337                 proc_t *p = ttoproc(curthread);
 338
 339                 mutex_enter(&p->p_lock);
 340                 (void) rctl_action(rctlproc_legacy[RLIMIT_FSIZE], p->p_rctls,
 341                     p, RCA_UNSAFE_SIGINFO);
 342                 mutex_exit(&p->p_lock);
 343                 return (EFBIG);
 344         }
 345
 346         /* the following condition will occur only for write */
 347
 348         if (uio->uio_loffset >= UINT32_MAX)
 349                 return (EFBIG);
 350
 351         if (uio->uio_resid == 0)
 352                 return (0);
 353
 354         if (limit > UINT32_MAX)
 355                 limit = UINT32_MAX;
 356
 357         fsp = VFSTOPCFS(vp->v_vfsp);
 358         if (fsp->pcfs_flags & PCFS_IRRECOV)
 359                 return (EIO);
 360
 361         do {
 362                 /*
 363                  * Assignments to "n" in this block may appear
 364                  * to overflow in some cases.  However, after careful
 365                  * analysis it was determined that all assignments to
 366                  * "n" serve only to make "n" smaller.  Since "n"
 367                  * starts out as no larger than MAXBSIZE, "int" is
 368                  * safe.
 369                  */
 370                 off = uio->uio_loffset & MAXBMASK;
 371                 mapon = (int)(uio->uio_loffset & MAXBOFFSET);
 372                 n = MIN(MAXBSIZE - mapon, uio->uio_resid);
 373                 if (rw == UIO_READ) {
 374                         offset_t diff;
 375
 376                         diff = pcp->pc_size - uio->uio_loffset;
 377                         if (diff <= 0)
 378                                 return (0);
 379                         if (diff < n)
 380                                 n = (int)diff;
 381                 }
 382                 /*
 383                  * Compare limit with the actual offset + n, not the
 384                  * rounded down offset "off" or we will overflow
 385                  * the maximum file size after all.
 386                  */
 387                 if (rw == UIO_WRITE && uio->uio_loffset + n >= limit) {
 388                         if (uio->uio_loffset >= limit) {
 389                                 error = EFBIG;
 390                                 break;
 391                         }
 392                         n = (int)(limit - uio->uio_loffset);
 393                 }
 394
 395                 /*
 396                  * Touch the page and fault it in if it is not in
 397                  * core before segmap_getmapflt can lock it. This
 398                  * is to avoid the deadlock if the buffer is mapped
 399                  * to the same file through mmap which we want to
 400                  * write to.
 401                  */
 402                 uio_prefaultpages((long)n, uio);
 403
 404                 base = segmap_getmap(segkmap, vp, (uoff_t)off);
 405                 pagecreate = 0;
 406                 newpage = 0;
 407                 if (rw == UIO_WRITE) {
 408                         /*
 409                          * If PAGESIZE < MAXBSIZE, perhaps we ought to deal
 410                          * with one page at a time, instead of one MAXBSIZE
 411                          * at a time, so we can fully explore pagecreate
 412                          * optimization??
 413                          */
 414                         if (uio->uio_loffset + n > pcp->pc_size) {
 415                                 uint_t ncl, lcn;
 416
 417                                 ncl = (uint_t)howmany((offset_t)pcp->pc_size,
 418                                     fsp->pcfs_clsize);
 419                                 if (uio->uio_loffset > pcp->pc_size &&
 420                                     ncl < (uint_t)howmany(uio->uio_loffset,
 421                                     fsp->pcfs_clsize)) {
 422                                         /*
 423                                          * Allocate and zerofill skipped
 424                                          * clusters. This may not be worth the
 425                                          * effort since a small lseek beyond
 426                                          * eof but still within the cluster
 427                                          * will not be zeroed out.
 428                                          */
 429                                         lcn = pc_lblkno(fsp, uio->uio_loffset);
 430                                         error = pc_balloc(pcp, (daddr_t)lcn,
 431                                             1, &bn);
 432                                         ncl = lcn + 1;
 433                                 }
 434                                 if (!error &&
 435                                     ncl < (uint_t)howmany(uio->uio_loffset + n,
 436                                     fsp->pcfs_clsize))
 437                                         /*
 438                                          * allocate clusters w/o zerofill
 439                                          */
 440                                         error = pc_balloc(pcp,
 441                                             (daddr_t)pc_lblkno(fsp,
 442                                             uio->uio_loffset + n - 1),
 443                                             0, &bn);
 444
 445                                 pcp->pc_flags |= PC_CHG;
 446
 447                                 if (error) {
 448                                         pc_cluster32_t ncl;
 449                                         int nerror;
 450
 451                                         /*
 452                                          * figure out new file size from
 453                                          * cluster chain length. If this
 454                                          * is detected to loop, the chain
 455                                          * is corrupted and we'd better
 456                                          * keep our fingers off that file.
 457                                          */
 458                                         nerror = pc_fileclsize(fsp,
 459                                             pcp->pc_scluster, &ncl);
 460                                         if (nerror) {
 461                                                 PC_DPRINTF1(2,
 462                                                     "cluster chain "
 463                                                     "corruption, "
 464                                                     "scluster=%d\n",
 465                                                     pcp->pc_scluster);
 466                                                 pcp->pc_size = 0;
 467                                                 pcp->pc_flags |= PC_INVAL;
 468                                                 error = nerror;
 469                                                 (void) segmap_release(segkmap,
 470                                                     base, 0);
 471                                                 break;
 472                                         }
 473                                         pcp->pc_size = fsp->pcfs_clsize * ncl;
 474
 475                                         if (error == ENOSPC &&
 476                                             (pcp->pc_size - uio->uio_loffset)
 477                                             > 0) {
 478                                                 PC_DPRINTF3(2, "rwpcp ENOSPC "
 479                                                     "off=%lld n=%d size=%d\n",
 480                                                     uio->uio_loffset,
 481                                                     n, pcp->pc_size);
 482                                                 n = (int)(pcp->pc_size -
 483                                                     uio->uio_loffset);
 484                                         } else {
 485                                                 PC_DPRINTF1(1,
 486                                                     "rwpcp error1=%d\n", error);
 487                                                 (void) segmap_release(segkmap,
 488                                                     base, 0);
 489                                                 break;
 490                                         }
 491                                 } else {
 492                                         pcp->pc_size =
 493                                             (uint_t)(uio->uio_loffset + n);
 494                                 }
 495                                 if (mapon == 0) {
 496                                         newpage = segmap_pagecreate(segkmap,
 497                                             base, (size_t)n, 0);
 498                                         pagecreate = 1;
 499                                 }
 500                         } else if (n == MAXBSIZE) {
 501                                 newpage = segmap_pagecreate(segkmap, base,
 502                                     (size_t)n, 0);
 503                                 pagecreate = 1;
 504                         }
 505                 }
 506                 error = uiomove(base + mapon, (size_t)n, rw, uio);
 507
 508                 if (pagecreate && uio->uio_loffset <
 509                     roundup(off + mapon + n, PAGESIZE)) {
 510                         offset_t nzero, nmoved;
 511
 512                         nmoved = uio->uio_loffset - (off + mapon);
 513                         nzero = roundup(mapon + n, PAGESIZE) - nmoved;
 514                         (void) kzero(base + mapon + nmoved, (size_t)nzero);
 515                 }
 516
 517                 /*
 518                  * Unlock the pages which have been allocated by
 519                  * page_create_va() in segmap_pagecreate().
 520                  */
 521                 if (newpage) {
 522                         segmap_pageunlock(segkmap, base, (size_t)n,
 523                             rw == UIO_WRITE ? S_WRITE : S_READ);
 524                 }
 525
 526                 if (error) {
 527                         PC_DPRINTF1(1, "rwpcp error2=%d\n", error);
 528                         /*
 529                          * If we failed on a write, we may have already
 530                          * allocated file blocks as well as pages.  It's hard
 531                          * to undo the block allocation, but we must be sure
 532                          * to invalidate any pages that may have been
 533                          * allocated.
 534                          */
 535                         if (rw == UIO_WRITE)
 536                                 (void) segmap_release(segkmap, base, SM_INVAL);
 537                         else
 538                                 (void) segmap_release(segkmap, base, 0);
 539                 } else {
 540                         uint_t flags = 0;
 541
 542                         if (rw == UIO_READ) {
 543                                 if (n + mapon == MAXBSIZE ||
 544                                     uio->uio_loffset == pcp->pc_size)
 545                                         flags = SM_DONTNEED;
 546                         } else if (ioflag & (FSYNC|FDSYNC)) {
 547                                 flags = SM_WRITE;
 548                         } else if (n + mapon == MAXBSIZE) {
 549                                 flags = SM_WRITE|SM_ASYNC|SM_DONTNEED;
 550                         }
 551                         error = segmap_release(segkmap, base, flags);
 552                 }
 553
 554         } while (error == 0 && uio->uio_resid > 0 && n != 0);
 555
 556         if (oresid != uio->uio_resid)
 557                 error = 0;
 558         return (error);
 559 }
 560
 561 /*ARGSUSED*/
 562 static int
 563 pcfs_getattr(
 564         struct vnode *vp,
 565         struct vattr *vap,
 566         int flags,
 567         struct cred *cr,
 568         caller_context_t *ct)
 569 {
 570         struct pcnode *pcp;
 571         struct pcfs *fsp;
 572         int error;
 573         char attr;
 574         struct pctime atime;
 575         int64_t unixtime;
 576
 577         PC_DPRINTF1(8, "pcfs_getattr: vp=%p\n", (void *)vp);
 578
 579         fsp = VFSTOPCFS(vp->v_vfsp);
 580         error = pc_lockfs(fsp, 0, 0);
 581         if (error)
 582                 return (error);
 583
 584         /*
 585          * Note that we don't check for "invalid node" (PC_INVAL) here
 586          * only in order to make stat() succeed. We allow no I/O on such
 587          * a node, but do allow to check for its existence.
 588          */
 589         if ((pcp = VTOPC(vp)) == NULL) {
 590                 pc_unlockfs(fsp);
 591                 return (EIO);
 592         }
 593         /*
 594          * Copy from pcnode.
 595          */
 596         vap->va_type = vp->v_type;
 597         attr = pcp->pc_entry.pcd_attr;
 598         if (PCA_IS_HIDDEN(fsp, attr))
 599                 vap->va_mode = 0;
 600         else if (attr & PCA_LABEL)
 601                 vap->va_mode = 0444;
 602         else if (attr & PCA_RDONLY)
 603                 vap->va_mode = 0555;
 604         else if (fsp->pcfs_flags & PCFS_BOOTPART) {
 605                 vap->va_mode = 0755;
 606         } else {
 607                 vap->va_mode = 0777;
 608         }
 609
 610         if (attr & PCA_DIR)
 611                 vap->va_mode |= S_IFDIR;
 612         else
 613                 vap->va_mode |= S_IFREG;
 614         if (fsp->pcfs_flags & PCFS_BOOTPART) {
 615                 vap->va_uid = 0;
 616                 vap->va_gid = 0;
 617         } else {
 618                 vap->va_uid = crgetuid(cr);
 619                 vap->va_gid = crgetgid(cr);
 620         }
 621         vap->va_fsid = vp->v_vfsp->vfs_dev;
 622         vap->va_nodeid = (ino64_t)pc_makenodeid(pcp->pc_eblkno,
 623             pcp->pc_eoffset, pcp->pc_entry.pcd_attr,
 624             pc_getstartcluster(fsp, &pcp->pc_entry), pc_direntpersec(fsp));
 625         vap->va_nlink = 1;
 626         vap->va_size = (uoff_t)pcp->pc_size;
 627         vap->va_rdev = 0;
 628         vap->va_nblocks =
 629             (fsblkcnt64_t)howmany((offset_t)pcp->pc_size, DEV_BSIZE);
 630         vap->va_blksize = fsp->pcfs_clsize;
 631
 632         /*
 633          * FAT root directories have no timestamps. In order not to return
 634          * "time zero" (1/1/1970), we record the time of the mount and give
 635          * that. This breaks less expectations.
 636          */
 637         if (vp->v_flag & VROOT) {
 638                 vap->va_mtime = fsp->pcfs_mounttime;
 639                 vap->va_atime = fsp->pcfs_mounttime;
 640                 vap->va_ctime = fsp->pcfs_mounttime;
 641                 pc_unlockfs(fsp);
 642                 return (0);
 643         }
 644
 645         pc_pcttotv(&pcp->pc_entry.pcd_mtime, &unixtime);
 646         if ((fsp->pcfs_flags & PCFS_NOCLAMPTIME) == 0) {
 647                 if (unixtime > INT32_MAX)
 648                         DTRACE_PROBE1(pcfs__mtimeclamped, int64_t, unixtime);
 649                 unixtime = MIN(unixtime, INT32_MAX);
 650         } else if (unixtime > INT32_MAX &&
 651             get_udatamodel() == DATAMODEL_ILP32) {
 652                 pc_unlockfs(fsp);
 653                 DTRACE_PROBE1(pcfs__mtimeoverflowed, int64_t, unixtime);
 654                 return (EOVERFLOW);
 655         }
 656
 657         vap->va_mtime.tv_sec = (time_t)unixtime;
 658         vap->va_mtime.tv_nsec = 0;
 659
 660         /*
 661          * FAT doesn't know about POSIX ctime.
 662          * Best approximation is to always set it to mtime.
 663          */
 664         vap->va_ctime = vap->va_mtime;
 665
 666         /*
 667          * FAT only stores "last access date". If that's the
 668          * same as the date of last modification then the time
 669          * of last access is known. Otherwise, use midnight.
 670          */
 671         atime.pct_date = pcp->pc_entry.pcd_ladate;
 672         if (atime.pct_date == pcp->pc_entry.pcd_mtime.pct_date)
 673                 atime.pct_time = pcp->pc_entry.pcd_mtime.pct_time;
 674         else
 675                 atime.pct_time = 0;
 676         pc_pcttotv(&atime, &unixtime);
 677         if ((fsp->pcfs_flags & PCFS_NOCLAMPTIME) == 0) {
 678                 if (unixtime > INT32_MAX)
 679                         DTRACE_PROBE1(pcfs__atimeclamped, int64_t, unixtime);
 680                 unixtime = MIN(unixtime, INT32_MAX);
 681         } else if (unixtime > INT32_MAX &&
 682             get_udatamodel() == DATAMODEL_ILP32) {
 683                 pc_unlockfs(fsp);
 684                 DTRACE_PROBE1(pcfs__atimeoverflowed, int64_t, unixtime);
 685                 return (EOVERFLOW);
 686         }
 687
 688         vap->va_atime.tv_sec = (time_t)unixtime;
 689         vap->va_atime.tv_nsec = 0;
 690
 691         pc_unlockfs(fsp);
 692         return (0);
 693 }
 694
 695
 696 /*ARGSUSED*/
 697 static int
 698 pcfs_setattr(
 699         struct vnode *vp,
 700         struct vattr *vap,
 701         int flags,
 702         struct cred *cr,
 703         caller_context_t *ct)
 704 {
 705         struct pcnode *pcp;
 706         mode_t mask = vap->va_mask;
 707         int error;
 708         struct pcfs *fsp;
 709         timestruc_t now, *timep;
 710
 711         PC_DPRINTF2(6, "pcfs_setattr: vp=%p mask=%x\n", (void *)vp, (int)mask);
 712         /*
 713          * cannot set these attributes
 714          */
 715         if (mask & (VATTR_NOSET | VATTR_UID | VATTR_GID)) {
 716                 return (EINVAL);
 717         }
 718         /*
 719          * pcfs_setattr is now allowed on directories to avoid silly warnings
 720          * from 'tar' when it tries to set times on a directory, and console
 721          * printf's on the NFS server when it gets EINVAL back on such a
 722          * request. One possible problem with that since a directory entry
 723          * identifies a file, '.' and all the '..' entries in subdirectories
 724          * may get out of sync when the directory is updated since they're
 725          * treated like separate files. We could fix that by looking for
 726          * '.' and giving it the same attributes, and then looking for
 727          * all the subdirectories and updating '..', but that's pretty
 728          * expensive for something that doesn't seem likely to matter.
 729          */
 730         /* can't do some ops on directories anyway */
 731         if ((vp->v_type == VDIR) &&
 732             (mask & VATTR_SIZE)) {
 733                 return (EINVAL);
 734         }
 735
 736         fsp = VFSTOPCFS(vp->v_vfsp);
 737         error = pc_lockfs(fsp, 0, 0);
 738         if (error)
 739                 return (error);
 740         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL) {
 741                 pc_unlockfs(fsp);
 742                 return (EIO);
 743         }
 744
 745         if (fsp->pcfs_flags & PCFS_BOOTPART) {
 746                 if (secpolicy_pcfs_modify_bootpartition(cr) != 0) {
 747                         pc_unlockfs(fsp);
 748                         return (EACCES);
 749                 }
 750         }
 751
 752         /*
 753          * Change file access modes.
 754          * If nobody has write permission, file is marked readonly.
 755          * Otherwise file is writable by anyone.
 756          */
 757         if ((mask & VATTR_MODE) && (vap->va_mode != (mode_t)-1)) {
 758                 if ((vap->va_mode & 0222) == 0)
 759                         pcp->pc_entry.pcd_attr |= PCA_RDONLY;
 760                 else
 761                         pcp->pc_entry.pcd_attr &= ~PCA_RDONLY;
 762                 pcp->pc_flags |= PC_CHG;
 763         }
 764         /*
 765          * Truncate file. Must have write permission.
 766          */
 767         if ((mask & VATTR_SIZE) && (vap->va_size != (uoff_t)-1)) {
 768                 if (pcp->pc_entry.pcd_attr & PCA_RDONLY) {
 769                         error = EACCES;
 770                         goto out;
 771                 }
 772                 if (vap->va_size > UINT32_MAX) {
 773                         error = EFBIG;
 774                         goto out;
 775                 }
 776                 error = pc_truncate(pcp, (uint_t)vap->va_size);
 777
 778                 if (error)
 779                         goto out;
 780
 781                 if (vap->va_size == 0)
 782                         vnevent_truncate(vp, ct);
 783         }
 784         /*
 785          * Change file modified times.
 786          */
 787         if (mask & (VATTR_MTIME | VATTR_CTIME)) {
 788                 /*
 789                  * If SysV-compatible option to set access and
 790                  * modified times if privileged, owner, or write access,
 791                  * use current time rather than va_mtime.
 792                  *
 793                  * XXX - va_mtime.tv_sec == -1 flags this.
 794                  */
 795                 timep = &vap->va_mtime;
 796                 if (vap->va_mtime.tv_sec == -1) {
 797                         gethrestime(&now);
 798                         timep = &now;
 799                 }
 800                 if ((fsp->pcfs_flags & PCFS_NOCLAMPTIME) == 0 &&
 801                     timep->tv_sec > INT32_MAX) {
 802                         error = EOVERFLOW;
 803                         goto out;
 804                 }
 805                 error = pc_tvtopct(timep, &pcp->pc_entry.pcd_mtime);
 806                 if (error)
 807                         goto out;
 808                 pcp->pc_flags |= PC_CHG;
 809         }
 810         /*
 811          * Change file access times.
 812          */
 813         if (mask & VATTR_ATIME) {
 814                 /*
 815                  * If SysV-compatible option to set access and
 816                  * modified times if privileged, owner, or write access,
 817                  * use current time rather than va_mtime.
 818                  *
 819                  * XXX - va_atime.tv_sec == -1 flags this.
 820                  */
 821                 struct pctime   atime;
 822
 823                 timep = &vap->va_atime;
 824                 if (vap->va_atime.tv_sec == -1) {
 825                         gethrestime(&now);
 826                         timep = &now;
 827                 }
 828                 if ((fsp->pcfs_flags & PCFS_NOCLAMPTIME) == 0 &&
 829                     timep->tv_sec > INT32_MAX) {
 830                         error = EOVERFLOW;
 831                         goto out;
 832                 }
 833                 error = pc_tvtopct(timep, &atime);
 834                 if (error)
 835                         goto out;
 836                 pcp->pc_entry.pcd_ladate = atime.pct_date;
 837                 pcp->pc_flags |= PC_CHG;
 838         }
 839 out:
 840         pc_unlockfs(fsp);
 841         return (error);
 842 }
 843
 844
 845 /*ARGSUSED*/
 846 static int
 847 pcfs_access(
 848         struct vnode *vp,
 849         int mode,
 850         int flags,
 851         struct cred *cr,
 852         caller_context_t *ct)
 853 {
 854         struct pcnode *pcp;
 855         struct pcfs *fsp;
 856
 857
 858         fsp = VFSTOPCFS(vp->v_vfsp);
 859
 860         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL)
 861                 return (EIO);
 862         if ((mode & VWRITE) && (pcp->pc_entry.pcd_attr & PCA_RDONLY))
 863                 return (EACCES);
 864
 865         /*
 866          * If this is a boot partition, privileged users have full access while
 867          * others have read-only access.
 868          */
 869         if (fsp->pcfs_flags & PCFS_BOOTPART) {
 870                 if ((mode & VWRITE) &&
 871                     secpolicy_pcfs_modify_bootpartition(cr) != 0)
 872                         return (EACCES);
 873         }
 874         return (0);
 875 }
 876
 877
 878 /*ARGSUSED*/
 879 static int
 880 pcfs_fsync(
 881         struct vnode *vp,
 882         int syncflag,
 883         struct cred *cr,
 884         caller_context_t *ct)
 885 {
 886         struct pcfs *fsp;
 887         struct pcnode *pcp;
 888         int error;
 889
 890         fsp = VFSTOPCFS(vp->v_vfsp);
 891         if (error = pc_verify(fsp))
 892                 return (error);
 893         error = pc_lockfs(fsp, 0, 0);
 894         if (error)
 895                 return (error);
 896         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL) {
 897                 pc_unlockfs(fsp);
 898                 return (EIO);
 899         }
 900         rw_enter(&pcnodes_lock, RW_WRITER);
 901         error = pc_nodesync(pcp);
 902         rw_exit(&pcnodes_lock);
 903         pc_unlockfs(fsp);
 904         return (error);
 905 }
 906
 907
 908 /*ARGSUSED*/
 909 static void
 910 pcfs_inactive(
 911         struct vnode *vp,
 912         struct cred *cr,
 913         caller_context_t *ct)
 914 {
 915         struct pcnode *pcp;
 916         struct pcfs *fsp;
 917         int error;
 918
 919         fsp = VFSTOPCFS(vp->v_vfsp);
 920         error = pc_lockfs(fsp, 0, 1);
 921
 922         /*
 923          * If the filesystem was umounted by force, all dirty
 924          * pages associated with this vnode are invalidated
 925          * and then the vnode will be freed.
 926          */
 927         if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED) {
 928                 pcp = VTOPC(vp);
 929                 if (vn_has_cached_data(vp)) {
 930                         (void) pvn_vplist_dirty(vp, 0,
 931                             pcfs_putapage, B_INVAL, NULL);
 932                 }
 933                 remque(pcp);
 934                 if (error == 0)
 935                         pc_unlockfs(fsp);
 936                 vn_free(vp);
 937                 kmem_free(pcp, sizeof (struct pcnode));
 938                 VFS_RELE(PCFSTOVFS(fsp));
 939                 return;
 940         }
 941
 942         mutex_enter(&vp->v_lock);
 943         ASSERT(vp->v_count >= 1);
 944         if (vp->v_count > 1) {
 945                 VN_RELE_LOCKED(vp);
 946                 mutex_exit(&vp->v_lock);
 947                 pc_unlockfs(fsp);
 948                 return;
 949         }
 950         mutex_exit(&vp->v_lock);
 951
 952         /*
 953          * Check again to confirm that no intervening I/O error
 954          * with a subsequent pc_diskchanged() call has released
 955          * the pcnode. If it has then release the vnode as above.
 956          */
 957         pcp = VTOPC(vp);
 958         if (pcp == NULL || pcp->pc_flags & PC_INVAL) {
 959                 if (vn_has_cached_data(vp))
 960                         (void) pvn_vplist_dirty(vp, 0,
 961                             pcfs_putapage, B_INVAL | B_TRUNC, NULL);
 962         }
 963
 964         if (pcp == NULL) {
 965                 vn_free(vp);
 966         } else {
 967                 pc_rele(pcp);
 968         }
 969
 970         if (!error)
 971                 pc_unlockfs(fsp);
 972 }
 973
 974 /*ARGSUSED*/
 975 static int
 976 pcfs_lookup(
 977         struct vnode *dvp,
 978         char *nm,
 979         struct vnode **vpp,
 980         struct pathname *pnp,
 981         int flags,
 982         struct vnode *rdir,
 983         struct cred *cr,
 984         caller_context_t *ct,
 985         int *direntflags,
 986         pathname_t *realpnp)
 987 {
 988         struct pcfs *fsp;
 989         struct pcnode *pcp;
 990         int error;
 991
 992         /*
 993          * If the filesystem was umounted by force, return immediately.
 994          */
 995         if (dvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
 996                 return (EIO);
 997
 998         /*
 999          * verify that the dvp is still valid on the disk
1000          */
1001         fsp = VFSTOPCFS(dvp->v_vfsp);
1002         if (error = pc_verify(fsp))
1003                 return (error);
1004         error = pc_lockfs(fsp, 0, 0);
1005         if (error)
1006                 return (error);
1007         if (VTOPC(dvp) == NULL || VTOPC(dvp)->pc_flags & PC_INVAL) {
1008                 pc_unlockfs(fsp);
1009                 return (EIO);
1010         }
1011         /*
1012          * Null component name is a synonym for directory being searched.
1013          */
1014         if (*nm == '\0') {
1015                 VN_HOLD(dvp);
1016                 *vpp = dvp;
1017                 pc_unlockfs(fsp);
1018                 return (0);
1019         }
1020
1021         error = pc_dirlook(VTOPC(dvp), nm, &pcp);
1022         if (!error) {
1023                 *vpp = PCTOV(pcp);
1024                 pcp->pc_flags |= PC_EXTERNAL;
1025         }
1026         pc_unlockfs(fsp);
1027         return (error);
1028 }
1029
1030
1031 /*ARGSUSED*/
1032 static int
1033 pcfs_create(
1034         struct vnode *dvp,
1035         char *nm,
1036         struct vattr *vap,
1037         enum vcexcl exclusive,
1038         int mode,
1039         struct vnode **vpp,
1040         struct cred *cr,
1041         int flag,
1042         caller_context_t *ct,
1043         vsecattr_t *vsecp)
1044 {
1045         int error;
1046         struct pcnode *pcp;
1047         struct vnode *vp;
1048         struct pcfs *fsp;
1049
1050         /*
1051          * can't create directories. use pcfs_mkdir.
1052          * can't create anything other than files.
1053          */
1054         if (vap->va_type == VDIR)
1055                 return (EISDIR);
1056         else if (vap->va_type != VREG)
1057                 return (EINVAL);
1058
1059         pcp = NULL;
1060         fsp = VFSTOPCFS(dvp->v_vfsp);
1061         error = pc_lockfs(fsp, 0, 0);
1062         if (error)
1063                 return (error);
1064         if (VTOPC(dvp) == NULL || VTOPC(dvp)->pc_flags & PC_INVAL) {
1065                 pc_unlockfs(fsp);
1066                 return (EIO);
1067         }
1068
1069         if (fsp->pcfs_flags & PCFS_BOOTPART) {
1070                 if (secpolicy_pcfs_modify_bootpartition(cr) != 0) {
1071                         pc_unlockfs(fsp);
1072                         return (EACCES);
1073                 }
1074         }
1075
1076         if (*nm == '\0') {
1077                 /*
1078                  * Null component name refers to the directory itself.
1079                  */
1080                 VN_HOLD(dvp);
1081                 pcp = VTOPC(dvp);
1082                 error = EEXIST;
1083         } else {
1084                 error = pc_direnter(VTOPC(dvp), nm, vap, &pcp);
1085         }
1086         /*
1087          * if file exists and this is a nonexclusive create,
1088          * check for access permissions
1089          */
1090         if (error == EEXIST) {
1091                 vp = PCTOV(pcp);
1092                 if (exclusive == NONEXCL) {
1093                         if (vp->v_type == VDIR) {
1094                                 error = EISDIR;
1095                         } else if (mode) {
1096                                 error = pcfs_access(PCTOV(pcp), mode, 0,
1097                                     cr, ct);
1098                         } else {
1099                                 error = 0;
1100                         }
1101                 }
1102                 if (error) {
1103                         VN_RELE(PCTOV(pcp));
1104                 } else if ((vp->v_type == VREG) && (vap->va_mask & VATTR_SIZE) &&
1105                     (vap->va_size == 0)) {
1106                         error = pc_truncate(pcp, 0L);
1107                         if (error) {
1108                                 VN_RELE(PCTOV(pcp));
1109                         } else {
1110                                 vnevent_create(PCTOV(pcp), ct);
1111                         }
1112                 }
1113         }
1114         if (error) {
1115                 pc_unlockfs(fsp);
1116                 return (error);
1117         }
1118         *vpp = PCTOV(pcp);
1119         pcp->pc_flags |= PC_EXTERNAL;
1120         pc_unlockfs(fsp);
1121         return (error);
1122 }
1123
1124 /*ARGSUSED*/
1125 static int
1126 pcfs_remove(
1127         struct vnode *vp,
1128         char *nm,
1129         struct cred *cr,
1130         caller_context_t *ct,
1131         int flags)
1132 {
1133         struct pcfs *fsp;
1134         struct pcnode *pcp;
1135         int error;
1136
1137         fsp = VFSTOPCFS(vp->v_vfsp);
1138         if (error = pc_verify(fsp))
1139                 return (error);
1140         error = pc_lockfs(fsp, 0, 0);
1141         if (error)
1142                 return (error);
1143         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL) {
1144                 pc_unlockfs(fsp);
1145                 return (EIO);
1146         }
1147         if (fsp->pcfs_flags & PCFS_BOOTPART) {
1148                 if (secpolicy_pcfs_modify_bootpartition(cr) != 0) {
1149                         pc_unlockfs(fsp);
1150                         return (EACCES);
1151                 }
1152         }
1153         error = pc_dirremove(pcp, nm, NULL, VREG, ct);
1154         pc_unlockfs(fsp);
1155         return (error);
1156 }
1157
1158 /*
1159  * Rename a file or directory
1160  * This rename is restricted to only rename files within a directory.
1161  * XX should make rename more general
1162  */
1163 /*ARGSUSED*/
1164 static int
1165 pcfs_rename(
1166         struct vnode *sdvp,             /* old (source) parent vnode */
1167         char *snm,                      /* old (source) entry name */
1168         struct vnode *tdvp,             /* new (target) parent vnode */
1169         char *tnm,                      /* new (target) entry name */
1170         struct cred *cr,
1171         caller_context_t *ct,
1172         int flags)
1173 {
1174         struct pcfs *fsp;
1175         struct pcnode *dp;      /* parent pcnode */
1176         struct pcnode *tdp;
1177         int error;
1178
1179         fsp = VFSTOPCFS(sdvp->v_vfsp);
1180         if (error = pc_verify(fsp))
1181                 return (error);
1182
1183         /*
1184          * make sure we can muck with this directory.
1185          */
1186         error = pcfs_access(sdvp, VWRITE, 0, cr, ct);
1187         if (error) {
1188                 return (error);
1189         }
1190         error = pc_lockfs(fsp, 0, 0);
1191         if (error)
1192                 return (error);
1193         if (((dp = VTOPC(sdvp)) == NULL) || ((tdp = VTOPC(tdvp)) == NULL) ||
1194             (dp->pc_flags & PC_INVAL) || (tdp->pc_flags & PC_INVAL)) {
1195                 pc_unlockfs(fsp);
1196                 return (EIO);
1197         }
1198         error = pc_rename(dp, tdp, snm, tnm, ct);
1199         pc_unlockfs(fsp);
1200         return (error);
1201 }
1202
1203 /*ARGSUSED*/
1204 static int
1205 pcfs_mkdir(
1206         struct vnode *dvp,
1207         char *nm,
1208         struct vattr *vap,
1209         struct vnode **vpp,
1210         struct cred *cr,
1211         caller_context_t *ct,
1212         int flags,
1213         vsecattr_t *vsecp)
1214 {
1215         struct pcfs *fsp;
1216         struct pcnode *pcp;
1217         int error;
1218
1219         fsp = VFSTOPCFS(dvp->v_vfsp);
1220         if (error = pc_verify(fsp))
1221                 return (error);
1222         error = pc_lockfs(fsp, 0, 0);
1223         if (error)
1224                 return (error);
1225         if (VTOPC(dvp) == NULL || VTOPC(dvp)->pc_flags & PC_INVAL) {
1226                 pc_unlockfs(fsp);
1227                 return (EIO);
1228         }
1229
1230         if (fsp->pcfs_flags & PCFS_BOOTPART) {
1231                 if (secpolicy_pcfs_modify_bootpartition(cr) != 0) {
1232                         pc_unlockfs(fsp);
1233                         return (EACCES);
1234                 }
1235         }
1236
1237         error = pc_direnter(VTOPC(dvp), nm, vap, &pcp);
1238
1239         if (!error) {
1240                 pcp -> pc_flags |= PC_EXTERNAL;
1241                 *vpp = PCTOV(pcp);
1242         } else if (error == EEXIST) {
1243                 VN_RELE(PCTOV(pcp));
1244         }
1245         pc_unlockfs(fsp);
1246         return (error);
1247 }
1248
1249 /*ARGSUSED*/
1250 static int
1251 pcfs_rmdir(
1252         struct vnode *dvp,
1253         char *nm,
1254         struct vnode *cdir,
1255         struct cred *cr,
1256         caller_context_t *ct,
1257         int flags)
1258 {
1259         struct pcfs *fsp;
1260         struct pcnode *pcp;
1261         int error;
1262
1263         fsp = VFSTOPCFS(dvp -> v_vfsp);
1264         if (error = pc_verify(fsp))
1265                 return (error);
1266         if (error = pc_lockfs(fsp, 0, 0))
1267                 return (error);
1268
1269         if ((pcp = VTOPC(dvp)) == NULL || pcp->pc_flags & PC_INVAL) {
1270                 pc_unlockfs(fsp);
1271                 return (EIO);
1272         }
1273
1274         if (fsp->pcfs_flags & PCFS_BOOTPART) {
1275                 if (secpolicy_pcfs_modify_bootpartition(cr) != 0) {
1276                         pc_unlockfs(fsp);
1277                         return (EACCES);
1278                 }
1279         }
1280
1281         error = pc_dirremove(pcp, nm, cdir, VDIR, ct);
1282         pc_unlockfs(fsp);
1283         return (error);
1284 }
1285
1286 /*
1287  * read entries in a directory.
1288  * we must convert pc format to unix format
1289  */
1290
1291 /*ARGSUSED*/
1292 static int
1293 pcfs_readdir(
1294         struct vnode *dvp,
1295         struct uio *uiop,
1296         struct cred *cr,
1297         int *eofp,
1298         caller_context_t *ct,
1299         int flags)
1300 {
1301         struct pcnode *pcp;
1302         struct pcfs *fsp;
1303         struct pcdir *ep;
1304         struct buf *bp = NULL;
1305         offset_t offset;
1306         int boff;
1307         struct pc_dirent lbp;
1308         struct pc_dirent *ld = &lbp;
1309         int error;
1310
1311         /*
1312          * If the filesystem was umounted by force, return immediately.
1313          */
1314         if (dvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
1315                 return (EIO);
1316
1317         if ((uiop->uio_iovcnt != 1) ||
1318             (uiop->uio_loffset % sizeof (struct pcdir)) != 0) {
1319                 return (EINVAL);
1320         }
1321         fsp = VFSTOPCFS(dvp->v_vfsp);
1322         /*
1323          * verify that the dp is still valid on the disk
1324          */
1325         if (error = pc_verify(fsp)) {
1326                 return (error);
1327         }
1328         error = pc_lockfs(fsp, 0, 0);
1329         if (error)
1330                 return (error);
1331         if ((pcp = VTOPC(dvp)) == NULL || pcp->pc_flags & PC_INVAL) {
1332                 pc_unlockfs(fsp);
1333                 return (EIO);
1334         }
1335
1336         bzero(ld, sizeof (*ld));
1337
1338         if (eofp != NULL)
1339                 *eofp = 0;
1340         offset = uiop->uio_loffset;
1341
1342         if (dvp->v_flag & VROOT) {
1343                 /*
1344                  * kludge up entries for "." and ".." in the root.
1345                  */
1346                 if (offset == 0) {
1347                         (void) strcpy(ld->d_name, ".");
1348                         ld->d_reclen = DIRENT64_RECLEN(1);
1349                         ld->d_off = (off64_t)sizeof (struct pcdir);
1350                         ld->d_ino = (ino64_t)UINT_MAX;
1351                         if (ld->d_reclen > uiop->uio_resid) {
1352                                 pc_unlockfs(fsp);
1353                                 return (ENOSPC);
1354                         }
1355                         (void) uiomove(ld, ld->d_reclen, UIO_READ, uiop);
1356                         uiop->uio_loffset = ld->d_off;
1357                         offset = uiop->uio_loffset;
1358                 }
1359                 if (offset == sizeof (struct pcdir)) {
1360                         (void) strcpy(ld->d_name, "..");
1361                         ld->d_reclen = DIRENT64_RECLEN(2);
1362                         if (ld->d_reclen > uiop->uio_resid) {
1363                                 pc_unlockfs(fsp);
1364                                 return (ENOSPC);
1365                         }
1366                         ld->d_off = (off64_t)(uiop->uio_loffset +
1367                             sizeof (struct pcdir));
1368                         ld->d_ino = (ino64_t)UINT_MAX;
1369                         (void) uiomove(ld, ld->d_reclen, UIO_READ, uiop);
1370                         uiop->uio_loffset = ld->d_off;
1371                         offset = uiop->uio_loffset;
1372                 }
1373                 offset -= 2 * sizeof (struct pcdir);
1374                 /* offset now has the real offset value into directory file */
1375         }
1376
1377         for (;;) {
1378                 boff = pc_blkoff(fsp, offset);
1379                 if (boff == 0 || bp == NULL || boff >= bp->b_bcount) {
1380                         if (bp != NULL) {
1381                                 brelse(bp);
1382                                 bp = NULL;
1383                         }
1384                         error = pc_blkatoff(pcp, offset, &bp, &ep);
1385                         if (error) {
1386                                 if (error == ENOENT) {
1387                                         error = 0;
1388                                         if (eofp)
1389                                                 *eofp = 1;
1390                                 }
1391                                 break;
1392                         }
1393                 }
1394                 if (ep->pcd_filename[0] == PCD_UNUSED) {
1395                         if (eofp)
1396                                 *eofp = 1;
1397                         break;
1398                 }
1399                 /*
1400                  * Don't display label because it may contain funny characters.
1401                  */
1402                 if (ep->pcd_filename[0] == PCD_ERASED) {
1403                         uiop->uio_loffset += sizeof (struct pcdir);
1404                         offset += sizeof (struct pcdir);
1405                         ep++;
1406                         continue;
1407                 }
1408                 if (PCDL_IS_LFN(ep)) {
1409                         if (pc_read_long_fn(dvp, uiop, ld, &ep, &offset, &bp) !=
1410                             0)
1411                                 break;
1412                         continue;
1413                 }
1414
1415                 if (pc_read_short_fn(dvp, uiop, ld, &ep, &offset, &bp) != 0)
1416                         break;
1417         }
1418         if (bp)
1419                 brelse(bp);
1420         pc_unlockfs(fsp);
1421         return (error);
1422 }
1423
1424
1425 /*
1426  * Called from pvn_getpages to get a particular page.  When we are called
1427  * the pcfs is already locked.
1428  */
1429 /*ARGSUSED*/
1430 static int
1431 pcfs_getapage(
1432         struct vnode *vp,
1433         uoff_t off,
1434         size_t len,
1435         uint_t *protp,
1436         page_t *pl[],           /* NULL if async IO is requested */
1437         size_t plsz,
1438         struct seg *seg,
1439         caddr_t addr,
1440         enum seg_rw rw,
1441         struct cred *cr)
1442 {
1443         struct pcnode *pcp;
1444         struct pcfs *fsp = VFSTOPCFS(vp->v_vfsp);
1445         struct vnode *devvp;
1446         page_t *pp;
1447         page_t *pagefound;
1448         int err;
1449
1450         /*
1451          * If the filesystem was umounted by force, return immediately.
1452          */
1453         if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
1454                 return (EIO);
1455
1456         PC_DPRINTF3(5, "pcfs_getapage: vp=%p off=%lld len=%lu\n",
1457             (void *)vp, off, len);
1458
1459         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL)
1460                 return (EIO);
1461         devvp = fsp->pcfs_devvp;
1462
1463         /* pcfs doesn't do readaheads */
1464         if (pl == NULL)
1465                 return (0);
1466
1467         pl[0] = NULL;
1468         err = 0;
1469         /*
1470          * If the accessed time on the pcnode has not already been
1471          * set elsewhere (e.g. for read/setattr) we set the time now.
1472          * This gives us approximate modified times for mmap'ed files
1473          * which are accessed via loads in the user address space.
1474          */
1475         if ((pcp->pc_flags & PC_ACC) == 0 &&
1476             ((fsp->pcfs_vfs->vfs_flag & VFS_RDONLY) == 0)) {
1477                 pc_mark_acc(fsp, pcp);
1478         }
1479 reread:
1480         if ((pagefound = page_exists(&vp->v_object, off)) == NULL) {
1481                 /*
1482                  * Need to really do disk IO to get the page(s).
1483                  */
1484                 struct buf *bp;
1485                 daddr_t lbn, bn;
1486                 uoff_t io_off;
1487                 size_t io_len;
1488                 uoff_t lbnoff, xferoffset;
1489                 uoff_t pgoff;
1490                 uint_t  xfersize;
1491                 int err1;
1492
1493                 lbn = pc_lblkno(fsp, off);
1494                 lbnoff = off & ~(fsp->pcfs_clsize - 1);
1495                 xferoffset = off & ~(fsp->pcfs_secsize - 1);
1496
1497                 pp = pvn_read_kluster(vp, off, seg, addr, &io_off, &io_len,
1498                     off, (size_t)MIN(pc_blksize(fsp, pcp, off), PAGESIZE), 0);
1499                 if (pp == NULL)
1500                         /*
1501                          * XXX - If pcfs is made MT-hot, this should go
1502                          * back to reread.
1503                          */
1504                         panic("pcfs_getapage pvn_read_kluster");
1505
1506                 for (pgoff = 0; pgoff < PAGESIZE && xferoffset < pcp->pc_size;
1507                     pgoff += xfersize,
1508                     lbn +=  howmany(xfersize, fsp->pcfs_clsize),
1509                     lbnoff += xfersize, xferoffset += xfersize) {
1510                         /*
1511                          * read as many contiguous blocks as possible to
1512                          * fill this page
1513                          */
1514                         xfersize = PAGESIZE - pgoff;
1515                         err1 = pc_bmap(pcp, lbn, &bn, &xfersize);
1516                         if (err1) {
1517                                 PC_DPRINTF1(1, "pc_getapage err=%d", err1);
1518                                 err = err1;
1519                                 goto out;
1520                         }
1521                         bp = pageio_setup(pp, xfersize, devvp, B_READ);
1522                         bp->b_edev = devvp->v_rdev;
1523                         bp->b_dev = cmpdev(devvp->v_rdev);
1524                         bp->b_blkno = bn + btodt(xferoffset - lbnoff);
1525                         bp->b_un.b_addr = (caddr_t)(uintptr_t)pgoff;
1526                         bp->b_file = vp;
1527                         bp->b_offset = (offset_t)(off + pgoff);
1528
1529                         (void) bdev_strategy(bp);
1530
1531                         lwp_stat_update(LWP_STAT_INBLK, 1);
1532
1533                         if (err == 0)
1534                                 err = biowait(bp);
1535                         else
1536                                 (void) biowait(bp);
1537                         pageio_done(bp);
1538                         if (err)
1539                                 goto out;
1540                 }
1541                 if (pgoff < PAGESIZE) {
1542                         pagezero(pp->p_prev, pgoff, PAGESIZE - pgoff);
1543                 }
1544                 pvn_plist_init(pp, pl, plsz, off, io_len, rw);
1545         }
1546 out:
1547         if (err) {
1548                 if (pp != NULL)
1549                         pvn_read_done(pp, B_ERROR);
1550                 return (err);
1551         }
1552
1553         if (pagefound) {
1554                 /*
1555                  * Page exists in the cache, acquire the "shared"
1556                  * lock.  If this fails, go back to reread.
1557                  */
1558                 if ((pp = page_lookup(&vp->v_object, off, SE_SHARED)) == NULL) {
1559                         goto reread;
1560                 }
1561                 pl[0] = pp;
1562                 pl[1] = NULL;
1563         }
1564         return (err);
1565 }
1566
1567 /*
1568  * Return all the pages from [off..off+len] in given file
1569  */
1570 /* ARGSUSED */
1571 static int
1572 pcfs_getpage(
1573         struct vnode *vp,
1574         offset_t off,
1575         size_t len,
1576         uint_t *protp,
1577         page_t *pl[],
1578         size_t plsz,
1579         struct seg *seg,
1580         caddr_t addr,
1581         enum seg_rw rw,
1582         struct cred *cr,
1583         caller_context_t *ct)
1584 {
1585         struct pcfs *fsp = VFSTOPCFS(vp->v_vfsp);
1586         int err;
1587
1588         PC_DPRINTF0(6, "pcfs_getpage\n");
1589         if (err = pc_verify(fsp))
1590                 return (err);
1591         if (vp->v_flag & VNOMAP)
1592                 return (ENOSYS);
1593         ASSERT(off <= UINT32_MAX);
1594         err = pc_lockfs(fsp, 0, 0);
1595         if (err)
1596                 return (err);
1597         if (protp != NULL)
1598                 *protp = PROT_ALL;
1599
1600         ASSERT((off & PAGEOFFSET) == 0);
1601         err = pvn_getpages(pcfs_getapage, vp, off, len, protp, pl, plsz,
1602             seg, addr, rw, cr);
1603
1604         pc_unlockfs(fsp);
1605         return (err);
1606 }
1607
1608
1609 /*
1610  * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE}
1611  * If len == 0, do from off to EOF.
1612  *
1613  * The normal cases should be len == 0 & off == 0 (entire vp list),
1614  * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
1615  * (from pageout).
1616  *
1617  */
1618 /*ARGSUSED*/
1619 static int
1620 pcfs_putpage(
1621         struct vnode *vp,
1622         offset_t off,
1623         size_t len,
1624         int flags,
1625         struct cred *cr,
1626         caller_context_t *ct)
1627 {
1628         struct pcnode *pcp;
1629         page_t *pp;
1630         struct pcfs *fsp;
1631         uoff_t io_off;
1632         size_t io_len;
1633         offset_t eoff;
1634         int err;
1635
1636         /*
1637          * If the filesystem was umounted by force, return immediately.
1638          */
1639         if (vp->v_vfsp->vfs_flag & VFS_UNMOUNTED)
1640                 return (EIO);
1641
1642         PC_DPRINTF1(6, "pcfs_putpage vp=0x%p\n", (void *)vp);
1643         if (vp->v_flag & VNOMAP)
1644                 return (ENOSYS);
1645
1646         fsp = VFSTOPCFS(vp->v_vfsp);
1647
1648         if (err = pc_verify(fsp))
1649                 return (err);
1650         if ((pcp = VTOPC(vp)) == NULL) {
1651                 PC_DPRINTF1(3, "pcfs_putpage NULL vp=0x%p\n", (void *)vp);
1652                 return (EIO);
1653         }
1654         if (pcp->pc_flags & PC_INVAL)
1655                 return (EIO);
1656
1657         if (curproc == proc_pageout) {
1658                 /*
1659                  * XXX - This is a quick hack to avoid blocking
1660                  * pageout. Also to avoid pcfs_getapage deadlocking
1661                  * with putpage when memory is running out,
1662                  * since we only have one global lock and we don't
1663                  * support async putpage.
1664                  * It should be fixed someday.
1665                  *
1666                  * Interestingly, this used to be a test of NOMEMWAIT().
1667                  * We only ever got here once pcfs started supporting
1668                  * NFS sharing, and then only because the NFS server
1669                  * threads seem to do writes in sched's process context.
1670                  * Since everyone else seems to just care about pageout,
1671                  * the test was changed to look for pageout directly.
1672                  */
1673                 return (ENOMEM);
1674         }
1675
1676         ASSERT(off <= UINT32_MAX);
1677
1678         flags &= ~B_ASYNC;      /* XXX should fix this later */
1679
1680         err = pc_lockfs(fsp, 0, 0);
1681         if (err)
1682                 return (err);
1683         if (!vn_has_cached_data(vp) || off >= pcp->pc_size) {
1684                 pc_unlockfs(fsp);
1685                 return (0);
1686         }
1687
1688         if (len == 0) {
1689                 /*
1690                  * Search the entire vp list for pages >= off
1691                  */
1692                 err = pvn_vplist_dirty(vp, off,
1693                     pcfs_putapage, flags, cr);
1694         } else {
1695                 eoff = off + len;
1696
1697                 for (io_off = off; io_off < eoff &&
1698                     io_off < pcp->pc_size; io_off += io_len) {
1699                         /*
1700                          * If we are not invalidating, synchronously
1701                          * freeing or writing pages use the routine
1702                          * page_lookup_nowait() to prevent reclaiming
1703                          * them from the free list.
1704                          */
1705                         if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) {
1706                                 pp = page_lookup(&vp->v_object, io_off,
1707                                                  (flags & (B_INVAL | B_FREE)) ? SE_EXCL : SE_SHARED);
1708                         } else {
1709                                 pp = page_lookup_nowait(&vp->v_object,
1710                                                         io_off,
1711                                                         (flags & B_FREE) ? SE_EXCL : SE_SHARED);
1712                         }
1713
1714                         if (pp == NULL || pvn_getdirty(pp, flags) == 0)
1715                                 io_len = PAGESIZE;
1716                         else {
1717                                 err = pcfs_putapage(vp, pp, &io_off, &io_len,
1718                                     flags, cr);
1719                                 if (err != 0)
1720                                         break;
1721                                 /*
1722                                  * "io_off" and "io_len" are returned as
1723                                  * the range of pages we actually wrote.
1724                                  * This allows us to skip ahead more quickly
1725                                  * since several pages may've been dealt
1726                                  * with by this iteration of the loop.
1727                                  */
1728                         }
1729                 }
1730         }
1731         if (err == 0 && (flags & B_INVAL) &&
1732             off == 0 && len == 0 && vn_has_cached_data(vp)) {
1733                 /*
1734                  * If doing "invalidation", make sure that
1735                  * all pages on the vnode list are actually
1736                  * gone.
1737                  */
1738                 cmn_err(CE_PANIC,
1739                     "pcfs_putpage: B_INVAL, pages not gone");
1740         } else if (err) {
1741                 PC_DPRINTF1(1, "pcfs_putpage err=%d\n", err);
1742         }
1743         pc_unlockfs(fsp);
1744         return (err);
1745 }
1746
1747 /*
1748  * Write out a single page, possibly klustering adjacent dirty pages.
1749  */
1750 /*ARGSUSED*/
1751 int
1752 pcfs_putapage(
1753         struct vnode *vp,
1754         page_t *pp,
1755         uoff_t *offp,
1756         size_t *lenp,
1757         int flags,
1758         struct cred *cr)
1759 {
1760         struct pcnode *pcp;
1761         struct pcfs *fsp;
1762         struct vnode *devvp;
1763         size_t io_len;
1764         daddr_t bn;
1765         uoff_t lbn, lbnoff, xferoffset;
1766         uint_t pgoff, xfersize;
1767         int err = 0;
1768         uoff_t io_off;
1769
1770         pcp = VTOPC(vp);
1771         fsp = VFSTOPCFS(vp->v_vfsp);
1772         devvp = fsp->pcfs_devvp;
1773
1774         /*
1775          * If the modified time on the inode has not already been
1776          * set elsewhere (e.g. for write/setattr) and this is not
1777          * a call from msync (B_FORCE) we set the time now.
1778          * This gives us approximate modified times for mmap'ed files
1779          * which are modified via stores in the user address space.
1780          */
1781         if ((pcp->pc_flags & PC_MOD) == 0 || (flags & B_FORCE)) {
1782                 pcp->pc_flags |= PC_MOD;
1783                 pc_mark_mod(fsp, pcp);
1784         }
1785         pp = pvn_write_kluster(vp, pp, &io_off, &io_len, pp->p_offset,
1786             PAGESIZE, flags);
1787
1788         if (fsp->pcfs_flags & PCFS_IRRECOV) {
1789                 goto out;
1790         }
1791
1792         PC_DPRINTF1(7, "pc_putpage writing dirty page off=%llu\n", io_off);
1793
1794         lbn = pc_lblkno(fsp, io_off);
1795         lbnoff = io_off & ~(fsp->pcfs_clsize - 1);
1796         xferoffset = io_off & ~(fsp->pcfs_secsize - 1);
1797
1798         for (pgoff = 0; pgoff < io_len && xferoffset < pcp->pc_size;
1799             pgoff += xfersize,
1800             lbn += howmany(xfersize, fsp->pcfs_clsize),
1801             lbnoff += xfersize, xferoffset += xfersize) {
1802
1803                 struct buf *bp;
1804                 int err1;
1805
1806                 /*
1807                  * write as many contiguous blocks as possible from this page
1808                  */
1809                 xfersize = io_len - pgoff;
1810                 err1 = pc_bmap(pcp, (daddr_t)lbn, &bn, &xfersize);
1811                 if (err1) {
1812                         err = err1;
1813                         goto out;
1814                 }
1815                 bp = pageio_setup(pp, xfersize, devvp, B_WRITE | flags);
1816                 bp->b_edev = devvp->v_rdev;
1817                 bp->b_dev = cmpdev(devvp->v_rdev);
1818                 bp->b_blkno = bn + btodt(xferoffset - lbnoff);
1819                 bp->b_un.b_addr = (caddr_t)(uintptr_t)pgoff;
1820                 bp->b_file = vp;
1821                 bp->b_offset = (offset_t)(io_off + pgoff);
1822
1823                 (void) bdev_strategy(bp);
1824
1825                 lwp_stat_update(LWP_STAT_OUBLK, 1);
1826
1827                 if (err == 0)
1828                         err = biowait(bp);
1829                 else
1830                         (void) biowait(bp);
1831                 pageio_done(bp);
1832         }
1833         pvn_write_done(pp, ((err) ? B_ERROR : 0) | B_WRITE | flags);
1834         pp = NULL;
1835
1836 out:
1837         if ((fsp->pcfs_flags & PCFS_IRRECOV) && pp != NULL) {
1838                 pvn_write_done(pp, B_WRITE | flags);
1839         } else if (err != 0 && pp != NULL) {
1840                 pvn_write_done(pp, B_ERROR | B_WRITE | flags);
1841         }
1842
1843         if (offp)
1844                 *offp = io_off;
1845         if (lenp)
1846                 *lenp = io_len;
1847                 PC_DPRINTF4(4, "pcfs_putapage: vp=%p pp=%p off=%lld len=%lu\n",
1848                     (void *)vp, (void *)pp, io_off, io_len);
1849         if (err) {
1850                 PC_DPRINTF1(1, "pcfs_putapage err=%d", err);
1851         }
1852         return (err);
1853 }
1854
1855 /*ARGSUSED*/
1856 static int
1857 pcfs_map(
1858         struct vnode *vp,
1859         offset_t off,
1860         struct as *as,
1861         caddr_t *addrp,
1862         size_t len,
1863         uchar_t prot,
1864         uchar_t maxprot,
1865         uint_t flags,
1866         struct cred *cr,
1867         caller_context_t *ct)
1868 {
1869         struct segvn_crargs vn_a;
1870         int error;
1871
1872         PC_DPRINTF0(6, "pcfs_map\n");
1873         if (vp->v_flag & VNOMAP)
1874                 return (ENOSYS);
1875
1876         if (off > UINT32_MAX || off + len > UINT32_MAX)
1877                 return (ENXIO);
1878
1879         as_rangelock(as);
1880         error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
1881         if (error != 0) {
1882                 as_rangeunlock(as);
1883                 return (error);
1884         }
1885
1886         vn_a.vp = vp;
1887         vn_a.offset = off;
1888         vn_a.type = flags & MAP_TYPE;
1889         vn_a.prot = prot;
1890         vn_a.maxprot = maxprot;
1891         vn_a.flags = flags & ~MAP_TYPE;
1892         vn_a.cred = cr;
1893         vn_a.amp = NULL;
1894         vn_a.szc = 0;
1895         vn_a.lgrp_mem_policy_flags = 0;
1896
1897         error = as_map(as, *addrp, len, segvn_create, &vn_a);
1898         as_rangeunlock(as);
1899         return (error);
1900 }
1901
1902 /* ARGSUSED */
1903 static int
1904 pcfs_seek(
1905         struct vnode *vp,
1906         offset_t ooff,
1907         offset_t *noffp,
1908         caller_context_t *ct)
1909 {
1910         if (*noffp < 0)
1911                 return (EINVAL);
1912         else if (*noffp > MAXOFFSET_T)
1913                 return (EINVAL);
1914         else
1915                 return (0);
1916 }
1917
1918 /* ARGSUSED */
1919 static int
1920 pcfs_addmap(
1921         struct vnode *vp,
1922         offset_t off,
1923         struct as *as,
1924         caddr_t addr,
1925         size_t len,
1926         uchar_t prot,
1927         uchar_t maxprot,
1928         uint_t flags,
1929         struct cred *cr,
1930         caller_context_t *ct)
1931 {
1932         if (vp->v_flag & VNOMAP)
1933                 return (ENOSYS);
1934         return (0);
1935 }
1936
1937 /*ARGSUSED*/
1938 static int
1939 pcfs_delmap(
1940         struct vnode *vp,
1941         offset_t off,
1942         struct as *as,
1943         caddr_t addr,
1944         size_t len,
1945         uint_t prot,
1946         uint_t maxprot,
1947         uint_t flags,
1948         struct cred *cr,
1949         caller_context_t *ct)
1950 {
1951         if (vp->v_flag & VNOMAP)
1952                 return (ENOSYS);
1953         return (0);
1954 }
1955
1956 /*
1957  * POSIX pathconf() support.
1958  */
1959 /* ARGSUSED */
1960 static int
1961 pcfs_pathconf(
1962         struct vnode *vp,
1963         int cmd,
1964         ulong_t *valp,
1965         struct cred *cr,
1966         caller_context_t *ct)
1967 {
1968         struct pcfs *fsp = VFSTOPCFS(vp->v_vfsp);
1969
1970         switch (cmd) {
1971         case _PC_LINK_MAX:
1972                 *valp = 1;
1973                 return (0);
1974
1975         case _PC_CASE_BEHAVIOR:
1976                 return (EINVAL);
1977
1978         case _PC_FILESIZEBITS:
1979                 /*
1980                  * Both FAT16 and FAT32 support 4GB - 1 byte for file size.
1981                  * FAT12 can only go up to the maximum filesystem capacity
1982                  * which is ~509MB.
1983                  */
1984                 *valp = IS_FAT12(fsp) ? 30 : 33;
1985                 return (0);
1986
1987         case _PC_TIMESTAMP_RESOLUTION:
1988                 /*
1989                  * PCFS keeps track of modification times, it its own
1990                  * internal format, to a resolution of 2 seconds.
1991                  * Since 2000 million is representable in an int32_t
1992                  * without overflow (or becoming negative), we allow
1993                  * this value to be returned.
1994                  */
1995                 *valp = 2000000000L;
1996                 return (0);
1997
1998         default:
1999                 return (fs_pathconf(vp, cmd, valp, cr, ct));
2000         }
2001
2002 }
2003
2004 /* ARGSUSED */
2005 static int
2006 pcfs_space(
2007         struct vnode *vp,
2008         int cmd,
2009         struct flock64 *bfp,
2010         int flag,
2011         offset_t offset,
2012         cred_t *cr,
2013         caller_context_t *ct)
2014 {
2015         struct vattr vattr;
2016         int error;
2017
2018         if (cmd != F_FREESP)
2019                 return (EINVAL);
2020
2021         if ((error = convoff(vp, bfp, 0, offset)) == 0) {
2022                 if ((bfp->l_start > UINT32_MAX) || (bfp->l_len > UINT32_MAX))
2023                         return (EFBIG);
2024                 /*
2025                  * we only support the special case of l_len == 0,
2026                  * meaning free to end of file at this moment.
2027                  */
2028                 if (bfp->l_len != 0)
2029                         return (EINVAL);
2030                 vattr.va_mask = VATTR_SIZE;
2031                 vattr.va_size = bfp->l_start;
2032                 error = fop_setattr(vp, (vattr_t *)&vattr, 0, cr, ct);
2033         }
2034         return (error);
2035 }
2036
2037 /*
2038  * Break up 'len' chars from 'buf' into a long file name chunk.
2039  * Pad with '0xff' to make Norton Disk Doctor and Microsoft ScanDisk happy.
2040  */
2041 void
2042 set_long_fn_chunk(struct pcdir_lfn *ep, char *buf, int len)
2043 {
2044         int     i;
2045
2046         ASSERT(buf != NULL);
2047
2048         for (i = 0; i < PCLF_FIRSTNAMESIZE; i += 2) {
2049                 if (len > 0) {
2050                         ep->pcdl_firstfilename[i] = *buf++;
2051                         ep->pcdl_firstfilename[i + 1] = *buf++;
2052                         len -= 2;
2053                 } else {
2054                         ep->pcdl_firstfilename[i] = (uchar_t)0xff;
2055                         ep->pcdl_firstfilename[i + 1] = (uchar_t)0xff;
2056                 }
2057         }
2058
2059         for (i = 0; i < PCLF_SECONDNAMESIZE; i += 2) {
2060                 if (len > 0) {
2061                         ep->pcdl_secondfilename[i] = *buf++;
2062                         ep->pcdl_secondfilename[i + 1] = *buf++;
2063                         len -= 2;
2064                 } else {
2065                         ep->pcdl_secondfilename[i] = (uchar_t)0xff;
2066                         ep->pcdl_secondfilename[i + 1] = (uchar_t)0xff;
2067                 }
2068         }
2069         for (i = 0; i < PCLF_THIRDNAMESIZE; i += 2) {
2070                 if (len > 0) {
2071                         ep->pcdl_thirdfilename[i] = *buf++;
2072                         ep->pcdl_thirdfilename[i + 1] = *buf++;
2073                         len -= 2;
2074                 } else {
2075                         ep->pcdl_thirdfilename[i] = (uchar_t)0xff;
2076                         ep->pcdl_thirdfilename[i + 1] = (uchar_t)0xff;
2077                 }
2078         }
2079 }
2080
2081 /*
2082  * Extract the characters from the long filename chunk into 'buf'.
2083  * Return the number of characters extracted.
2084  */
2085 static int
2086 get_long_fn_chunk(struct pcdir_lfn *ep, char *buf)
2087 {
2088         char    *tmp = buf;
2089         int     i;
2090
2091         /* Copy all the names, no filtering now */
2092
2093         for (i = 0; i < PCLF_FIRSTNAMESIZE; i += 2, tmp += 2) {
2094                 *tmp = ep->pcdl_firstfilename[i];
2095                 *(tmp + 1) = ep->pcdl_firstfilename[i + 1];
2096
2097                 if ((*tmp == '\0') && (*(tmp+1) == '\0'))
2098                         return (tmp - buf);
2099         }
2100         for (i = 0; i < PCLF_SECONDNAMESIZE; i += 2, tmp += 2) {
2101                 *tmp = ep->pcdl_secondfilename[i];
2102                 *(tmp + 1) = ep->pcdl_secondfilename[i + 1];
2103
2104                 if ((*tmp == '\0') && (*(tmp+1) == '\0'))
2105                         return (tmp - buf);
2106         }
2107         for (i = 0; i < PCLF_THIRDNAMESIZE; i += 2, tmp += 2) {
2108                 *tmp = ep->pcdl_thirdfilename[i];
2109                 *(tmp + 1) = ep->pcdl_thirdfilename[i + 1];
2110
2111                 if ((*tmp == '\0') && (*(tmp+1) == '\0'))
2112                         return (tmp - buf);
2113         }
2114         return (tmp - buf);
2115 }
2116
2117
2118 /*
2119  * Checksum the passed in short filename.
2120  * This is used to validate each component of the long name to make
2121  * sure the long name is valid (it hasn't been "detached" from the
2122  * short filename). This algorithm was found in FreeBSD.
2123  * (sys/fs/msdosfs/msdosfs_conv.c:winChksum(), Wolfgang Solfrank)
2124  */
2125
2126 uchar_t
2127 pc_checksum_long_fn(char *name, char *ext)
2128 {
2129         uchar_t c;
2130         char    b[11];
2131
2132         bcopy(name, b, 8);
2133         bcopy(ext, b+8, 3);
2134
2135         c = b[0];
2136         c = ((c << 7) | (c >> 1)) + b[1];
2137         c = ((c << 7) | (c >> 1)) + b[2];
2138         c = ((c << 7) | (c >> 1)) + b[3];
2139         c = ((c << 7) | (c >> 1)) + b[4];
2140         c = ((c << 7) | (c >> 1)) + b[5];
2141         c = ((c << 7) | (c >> 1)) + b[6];
2142         c = ((c << 7) | (c >> 1)) + b[7];
2143         c = ((c << 7) | (c >> 1)) + b[8];
2144         c = ((c << 7) | (c >> 1)) + b[9];
2145         c = ((c << 7) | (c >> 1)) + b[10];
2146
2147         return (c);
2148 }
2149
2150 /*
2151  * Read a chunk of long filename entries into 'namep'.
2152  * Return with offset pointing to short entry (on success), or next
2153  * entry to read (if this wasn't a valid lfn really).
2154  * Uses the passed-in buffer if it can, otherwise kmem_allocs() room for
2155  * a long filename.
2156  *
2157  * Can also be called with a NULL namep, in which case it just returns
2158  * whether this was really a valid long filename and consumes it
2159  * (used by pc_dirempty()).
2160  */
2161 int
2162 pc_extract_long_fn(struct pcnode *pcp, char *namep,
2163     struct pcdir **epp, offset_t *offset, struct buf **bp)
2164 {
2165         struct pcdir *ep = *epp;
2166         struct pcdir_lfn *lep = (struct pcdir_lfn *)ep;
2167         struct vnode *dvp = PCTOV(pcp);
2168         struct pcfs *fsp = VFSTOPCFS(dvp->v_vfsp);
2169         char    *lfn;
2170         char    *lfn_base;
2171         int     boff;
2172         int     i, cs;
2173         char    *buf;
2174         uchar_t cksum;
2175         int     detached = 0;
2176         int     error = 0;
2177         int     foldcase;
2178         int     count = 0;
2179         size_t  u16l = 0, u8l = 0;
2180         char    *outbuf;
2181         size_t  ret, inlen, outlen;
2182
2183         foldcase = (fsp->pcfs_flags & PCFS_FOLDCASE);
2184         lfn_base = kmem_alloc(PCMAXNAM_UTF16, KM_SLEEP);
2185         lfn = lfn_base + PCMAXNAM_UTF16 - sizeof (uint16_t);
2186         *lfn = '\0';
2187         *(lfn + 1) = '\0';
2188         cksum = lep->pcdl_checksum;
2189
2190         buf = kmem_alloc(PCMAXNAM_UTF16, KM_SLEEP);
2191         for (i = (lep->pcdl_ordinal & ~0xc0); i > 0; i--) {
2192                 /* read next block if necessary */
2193                 boff = pc_blkoff(fsp, *offset);
2194                 if (boff == 0 || *bp == NULL || boff >= (*bp)->b_bcount) {
2195                         if (*bp != NULL) {
2196                                 brelse(*bp);
2197                                 *bp = NULL;
2198                         }
2199                         error = pc_blkatoff(pcp, *offset, bp, &ep);
2200                         if (error) {
2201                                 kmem_free(lfn_base, PCMAXNAM_UTF16);
2202                                 kmem_free(buf, PCMAXNAM_UTF16);
2203                                 return (error);
2204                         }
2205                         lep = (struct pcdir_lfn *)ep;
2206                 }
2207                 /* can this happen? Bad fs? */
2208                 if (!PCDL_IS_LFN((struct pcdir *)lep)) {
2209                         detached = 1;
2210                         break;
2211                 }
2212                 if (cksum != lep->pcdl_checksum)
2213                         detached = 1;
2214                 /* process current entry */
2215                 cs = get_long_fn_chunk(lep, buf);
2216                 count += cs;
2217                 for (; cs > 0; cs--) {
2218                         /* see if we underflow */
2219                         if (lfn >= lfn_base)
2220                                 *--lfn = buf[cs - 1];
2221                         else
2222                                 detached = 1;
2223                 }
2224                 lep++;
2225                 *offset += sizeof (struct pcdir);
2226         }
2227         kmem_free(buf, PCMAXNAM_UTF16);
2228         /* read next block if necessary */
2229         boff = pc_blkoff(fsp, *offset);
2230         ep = (struct pcdir *)lep;
2231         if (boff == 0 || *bp == NULL || boff >= (*bp)->b_bcount) {
2232                 if (*bp != NULL) {
2233                         brelse(*bp);
2234                         *bp = NULL;
2235                 }
2236                 error = pc_blkatoff(pcp, *offset, bp, &ep);
2237                 if (error) {
2238                         kmem_free(lfn_base, PCMAXNAM_UTF16);
2239                         return (error);
2240                 }
2241         }
2242         /* should be on the short one */
2243         if (PCDL_IS_LFN(ep) || ((ep->pcd_filename[0] == PCD_UNUSED) ||
2244             (ep->pcd_filename[0] == PCD_ERASED))) {
2245                 detached = 1;
2246         }
2247         if (detached ||
2248             (cksum != pc_checksum_long_fn(ep->pcd_filename, ep->pcd_ext)) ||
2249             !pc_valid_long_fn(lfn, 0)) {
2250                 /*
2251                  * process current entry again. This may end up another lfn
2252                  * or a short name.
2253                  */
2254                 *epp = ep;
2255                 kmem_free(lfn_base, PCMAXNAM_UTF16);
2256                 return (EINVAL);
2257         }
2258         if (PCA_IS_HIDDEN(fsp, ep->pcd_attr)) {
2259                 /*
2260                  * Don't display label because it may contain
2261                  * funny characters.
2262                  */
2263                 *offset += sizeof (struct pcdir);
2264                 ep++;
2265                 *epp = ep;
2266                 kmem_free(lfn_base, PCMAXNAM_UTF16);
2267                 return (EINVAL);
2268         }
2269         if (namep) {
2270                 u16l = count / 2;
2271                 u8l = PCMAXNAMLEN;
2272                 error = uconv_u16tou8((const uint16_t *)lfn, &u16l,
2273                     (uchar_t *)namep, &u8l, UCONV_IN_LITTLE_ENDIAN);
2274                 /*
2275                  * uconv_u16tou8() will catch conversion errors including
2276                  * the case where there is not enough room to write the
2277                  * converted result and the u8l will never go over the given
2278                  * PCMAXNAMLEN.
2279                  */
2280                 if (error != 0) {
2281                         kmem_free(lfn_base, PCMAXNAM_UTF16);
2282                         return (EINVAL);
2283                 }
2284                 namep[u8l] = '\0';
2285                 if (foldcase) {
2286                         inlen = strlen(namep);
2287                         outlen = PCMAXNAMLEN;
2288                         outbuf = kmem_alloc(PCMAXNAMLEN + 1, KM_SLEEP);
2289                         ret = u8_textprep_str(namep, &inlen, outbuf,
2290                             &outlen, U8_TEXTPREP_TOLOWER, U8_UNICODE_LATEST,
2291                             &error);
2292                         if (ret == -1) {
2293                                 kmem_free(outbuf, PCMAXNAMLEN + 1);
2294                                 kmem_free(lfn_base, PCMAXNAM_UTF16);
2295                                 return (EINVAL);
2296                         }
2297                         outbuf[PCMAXNAMLEN - outlen] = '\0';
2298                         (void) strncpy(namep, outbuf, PCMAXNAMLEN + 1);
2299                         kmem_free(outbuf, PCMAXNAMLEN + 1);
2300                 }
2301         }
2302         kmem_free(lfn_base, PCMAXNAM_UTF16);
2303         *epp = ep;
2304         return (0);
2305 }
2306 /*
2307  * Read a long filename into the pc_dirent structure and copy it out.
2308  */
2309 int
2310 pc_read_long_fn(struct vnode *dvp, struct uio *uiop, struct pc_dirent *ld,
2311     struct pcdir **epp, offset_t *offset, struct buf **bp)
2312 {
2313         struct pcdir *ep;
2314         struct pcnode *pcp = VTOPC(dvp);
2315         struct pcfs *fsp = VFSTOPCFS(dvp->v_vfsp);
2316         offset_t uiooffset = uiop->uio_loffset;
2317         int     error = 0;
2318         offset_t oldoffset;
2319
2320         oldoffset = *offset;
2321         error = pc_extract_long_fn(pcp, ld->d_name, epp, offset, bp);
2322         if (error) {
2323                 if (error == EINVAL) {
2324                         uiop->uio_loffset += *offset - oldoffset;
2325                         return (0);
2326                 } else
2327                         return (error);
2328         }
2329
2330         ep = *epp;
2331         uiop->uio_loffset += *offset - oldoffset;
2332         ld->d_reclen = DIRENT64_RECLEN(strlen(ld->d_name));
2333         if (ld->d_reclen > uiop->uio_resid) {
2334                 uiop->uio_loffset = uiooffset;
2335                 return (ENOSPC);
2336         }
2337         ld->d_off = uiop->uio_loffset + sizeof (struct pcdir);
2338         ld->d_ino = pc_makenodeid(pc_daddrdb(fsp, (*bp)->b_blkno),
2339             pc_blkoff(fsp, *offset), ep->pcd_attr,
2340             pc_getstartcluster(fsp, ep), pc_direntpersec(fsp));
2341         (void) uiomove((caddr_t)ld, ld->d_reclen, UIO_READ, uiop);
2342         uiop->uio_loffset = ld->d_off;
2343         *offset += sizeof (struct pcdir);
2344         ep++;
2345         *epp = ep;
2346         return (0);
2347 }
2348
2349 /*
2350  * Read a short filename into the pc_dirent structure and copy it out.
2351  */
2352 int
2353 pc_read_short_fn(struct vnode *dvp, struct uio *uiop, struct pc_dirent *ld,
2354     struct pcdir **epp, offset_t *offset, struct buf **bp)
2355 {
2356         struct pcfs *fsp = VFSTOPCFS(dvp->v_vfsp);
2357         int     boff = pc_blkoff(fsp, *offset);
2358         struct pcdir *ep = *epp;
2359         offset_t        oldoffset = uiop->uio_loffset;
2360         int     error;
2361         int     foldcase;
2362
2363         if (PCA_IS_HIDDEN(fsp, ep->pcd_attr)) {
2364                 uiop->uio_loffset += sizeof (struct pcdir);
2365                 *offset += sizeof (struct pcdir);
2366                 ep++;
2367                 *epp = ep;
2368                 return (0);
2369         }
2370         ld->d_ino = (ino64_t)pc_makenodeid(pc_daddrdb(fsp, (*bp)->b_blkno),
2371             boff, ep->pcd_attr, pc_getstartcluster(fsp, ep),
2372             pc_direntpersec(fsp));
2373         foldcase = (fsp->pcfs_flags & PCFS_FOLDCASE);
2374         error = pc_fname_ext_to_name(&ld->d_name[0], &ep->pcd_filename[0],
2375             &ep->pcd_ext[0], foldcase);
2376         if (error == 0) {
2377                 ld->d_reclen = DIRENT64_RECLEN(strlen(ld->d_name));
2378                 if (ld->d_reclen > uiop->uio_resid) {
2379                         uiop->uio_loffset = oldoffset;
2380                         return (ENOSPC);
2381                 }
2382                 ld->d_off = (off64_t)(uiop->uio_loffset +
2383                     sizeof (struct pcdir));
2384                 (void) uiomove((caddr_t)ld,
2385                     ld->d_reclen, UIO_READ, uiop);
2386                 uiop->uio_loffset = ld->d_off;
2387         } else {
2388                 uiop->uio_loffset += sizeof (struct pcdir);
2389         }
2390         *offset += sizeof (struct pcdir);
2391         ep++;
2392         *epp = ep;
2393         return (0);
2394 }
2395
2396 /* ARGSUSED */
2397 static int
2398 pcfs_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ct)
2399 {
2400         struct pc_fid *pcfid;
2401         struct pcnode *pcp;
2402         struct pcfs     *fsp;
2403         int     error;
2404
2405         fsp = VFSTOPCFS(vp->v_vfsp);
2406         if (fsp == NULL)
2407                 return (EIO);
2408         error = pc_lockfs(fsp, 0, 0);
2409         if (error)
2410                 return (error);
2411         if ((pcp = VTOPC(vp)) == NULL || pcp->pc_flags & PC_INVAL) {
2412                 pc_unlockfs(fsp);
2413                 return (EIO);
2414         }
2415         if (fidp->fid_len < (sizeof (struct pc_fid) - sizeof (ushort_t))) {
2416                 fidp->fid_len = sizeof (struct pc_fid) - sizeof (ushort_t);
2417                 pc_unlockfs(fsp);
2418                 return (ENOSPC);
2419         }
2420
2421         pcfid = (struct pc_fid *)fidp;
2422         bzero(pcfid, sizeof (struct pc_fid));
2423         pcfid->pcfid_len = sizeof (struct pc_fid) - sizeof (ushort_t);
2424         if (vp->v_flag & VROOT) {
2425                 pcfid->pcfid_block = 0;
2426                 pcfid->pcfid_offset = 0;
2427                 pcfid->pcfid_ctime = 0;
2428         } else {
2429                 pcfid->pcfid_block = pcp->pc_eblkno;
2430                 pcfid->pcfid_offset = pcp->pc_eoffset;
2431                 pcfid->pcfid_ctime = pcp->pc_entry.pcd_crtime.pct_time;
2432         }
2433         pc_unlockfs(fsp);
2434         return (0);
2435 }