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