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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/types.h> 30 #include <sys/cmn_err.h> 31 #include <sys/debug.h> 32 #include <sys/dirent.h> 33 #include <sys/kmem.h> 34 #include <sys/mman.h> 35 #include <sys/mutex.h> 36 #include <sys/sysmacros.h> 37 #include <sys/systm.h> 38 #include <sys/uio.h> 39 #include <sys/vmsystm.h> 40 #include <sys/vfs.h> 41 #include <sys/vnode.h> 42 43 #include <vm/as.h> 44 #include <vm/seg_vn.h> 45 46 #include <sys/gfs.h> 47 48 /* 49 * Generic pseudo-filesystem routines. 50 * 51 * There are significant similarities between the implementation of certain file 52 * system entry points across different filesystems. While one could attempt to 53 * "choke up on the bat" and incorporate common functionality into a VOP 54 * preamable or postamble, such an approach is limited in the benefit it can 55 * provide. In this file we instead define a toolkit of routines which can be 56 * called from a filesystem (with in-kernel pseudo-filesystems being the focus 57 * of the exercise) in a more component-like fashion. 58 * 59 * There are three basic classes of routines: 60 * 61 * 1) Lowlevel support routines 62 * 63 * These routines are designed to play a support role for existing 64 * pseudo-filesystems (such as procfs). They simplif ycommon tasks, 65 * without enforcing the filesystem to hand over management to GFS. The 66 * routines covered are: 67 * 68 * gfs_readdir_init() 69 * gfs_readdir_emit() 70 * gfs_readdir_emitn() 71 * gfs_readdir_pred() 72 * gfs_readdir_fini() 73 * gfs_lookup_dot() 74 * 75 * 2) Complete GFS management 76 * 77 * These routines take a more active role in management of the 78 * pseudo-filesystem. They handle the relationship between vnode private 79 * data and VFS data, as well as the relationship between vnodes in the 80 * directory heirarchy. 81 * 82 * In order to use these interfaces, the first member of every private 83 * v_data must be a gfs_file_t or a gfs_dir_t. This hands over all control 84 * to GFS. 85 * 86 * gfs_file_create() 87 * gfs_dir_create() 88 * gfs_root_create() 89 * 90 * gfs_file_inactive() 91 * gfs_dir_inactive() 92 * gfs_dir_lookup() 93 * gfs_dir_readdir() 94 * 95 * gfs_vop_inactive() 96 * gfs_vop_lookup() 97 * gfs_vop_readdir() 98 * gfs_vop_map() 99 */ 100 101 /* 102 * gfs_make_opsvec: take an array of vnode type definitions and create 103 * their vnodeops_t structures 104 * 105 * This routine takes an array of gfs_opsvec_t's. It could 106 * alternatively take an array of gfs_opsvec_t*'s, which would allow 107 * vnode types to be completely defined in files external to the caller 108 * of gfs_make_opsvec(). As it stands, much more sharing takes place -- 109 * both the caller and the vnode type provider need to access gfsv_ops 110 * and gfsv_template, and the caller also needs to know gfsv_name. 111 */ 112 int 113 gfs_make_opsvec(gfs_opsvec_t *vec) 114 { 115 int error, i; 116 117 for (i = 0; ; i++) { 118 if (vec[i].gfsv_name == NULL) 119 return (0); 120 error = vn_make_ops(vec[i].gfsv_name, vec[i].gfsv_template, 121 vec[i].gfsv_ops); 122 if (error) 123 break; 124 } 125 126 cmn_err(CE_WARN, "gfs_make_opsvec: bad vnode ops template for '%s'", 127 vec[i].gfsv_name); 128 for (i--; i >= 0; i--) { 129 vn_freevnodeops(*vec[i].gfsv_ops); 130 *vec[i].gfsv_ops = NULL; 131 } 132 return (error); 133 } 134 135 /* 136 * Low level directory routines 137 * 138 * These routines provide some simple abstractions for reading directories. 139 * They are designed to be used by existing pseudo filesystems (namely procfs) 140 * that already have a complicated management infrastructure. 141 */ 142 143 /* 144 * gfs_readdir_init: initiate a generic readdir 145 * st - a pointer to an uninitialized gfs_readdir_state_t structure 146 * name_max - the directory's maximum file name length 147 * ureclen - the exported file-space record length (1 for non-legacy FSs) 148 * uiop - the uiop passed to readdir 149 * parent - the parent directory's inode 150 * self - this directory's inode 151 * 152 * Returns 0 or a non-zero errno. 153 * 154 * Typical VOP_READDIR usage of gfs_readdir_*: 155 * 156 * if ((error = gfs_readdir_init(...)) != 0) 157 * return (error); 158 * eof = 0; 159 * while ((error = gfs_readdir_pred(..., &voffset)) != 0) { 160 * if (!consumer_entry_at(voffset)) 161 * voffset = consumer_next_entry(voffset); 162 * if (consumer_eof(voffset)) { 163 * eof = 1 164 * break; 165 * } 166 * if ((error = gfs_readdir_emit(..., voffset, 167 * consumer_ino(voffset), consumer_name(voffset))) != 0) 168 * break; 169 * } 170 * return (gfs_readdir_fini(..., error, eofp, eof)); 171 * 172 * As you can see, a zero result from gfs_readdir_pred() or 173 * gfs_readdir_emit() indicates that processing should continue, 174 * whereas a non-zero result indicates that the loop should terminate. 175 * Most consumers need do nothing more than let gfs_readdir_fini() 176 * determine what the cause of failure was and return the appropriate 177 * value. 178 */ 179 int 180 gfs_readdir_init(gfs_readdir_state_t *st, int name_max, int ureclen, 181 uio_t *uiop, ino64_t parent, ino64_t self) 182 { 183 if (uiop->uio_loffset < 0 || uiop->uio_resid <= 0 || 184 (uiop->uio_loffset % ureclen) != 0) 185 return (EINVAL); 186 187 st->grd_ureclen = ureclen; 188 st->grd_oresid = uiop->uio_resid; 189 st->grd_namlen = name_max; 190 st->grd_dirent = kmem_zalloc(DIRENT64_RECLEN(st->grd_namlen), KM_SLEEP); 191 st->grd_parent = parent; 192 st->grd_self = self; 193 194 return (0); 195 } 196 197 /* 198 * gfs_readdir_emit_int: internal routine to emit directory entry 199 * 200 * st - the current readdir state, which must have d_ino and d_name 201 * set 202 * uiop - caller-supplied uio pointer 203 * off - the offset of the current entry 204 * next - the offset of the next entry 205 */ 206 static int 207 gfs_readdir_emit_int(gfs_readdir_state_t *st, uio_t *uiop, offset_t off, 208 offset_t next) 209 { 210 int reclen; 211 212 reclen = DIRENT64_RECLEN(strlen(st->grd_dirent->d_name)); 213 214 if (reclen > uiop->uio_resid) { 215 /* 216 * Error if no entries were returned yet 217 */ 218 if (uiop->uio_resid == st->grd_oresid) 219 return (EINVAL); 220 return (-1); 221 } 222 223 st->grd_dirent->d_off = off; 224 st->grd_dirent->d_reclen = (ushort_t)reclen; 225 226 if (uiomove((caddr_t)st->grd_dirent, reclen, UIO_READ, uiop)) 227 return (EFAULT); 228 229 uiop->uio_loffset = next; 230 231 return (0); 232 } 233 234 /* 235 * gfs_readdir_emit: emit a directory entry 236 * voff - the virtual offset (obtained from gfs_readdir_pred) 237 * ino - the entry's inode 238 * name - the entry's name 239 * 240 * Returns a 0 on success, a non-zero errno on failure, or -1 if the 241 * readdir loop should terminate. A non-zero result (either errno or 242 * -1) from this function is typically passed directly to 243 * gfs_readdir_fini(). 244 */ 245 int 246 gfs_readdir_emit(gfs_readdir_state_t *st, uio_t *uiop, offset_t voff, 247 ino64_t ino, const char *name) 248 { 249 offset_t off = (voff + 2) * st->grd_ureclen; 250 251 st->grd_dirent->d_ino = ino; 252 (void) strncpy(st->grd_dirent->d_name, name, st->grd_namlen); 253 254 /* 255 * Inter-entry offsets are invalid, so we assume a record size of 256 * grd_ureclen and explicitly set the offset appropriately. 257 */ 258 return (gfs_readdir_emit_int(st, uiop, off, off + st->grd_ureclen)); 259 } 260 261 /* 262 * gfs_readdir_emitn: like gfs_readdir_emit(), but takes an integer 263 * instead of a string for the entry's name. 264 */ 265 int 266 gfs_readdir_emitn(gfs_readdir_state_t *st, uio_t *uiop, offset_t voff, 267 ino64_t ino, unsigned long num) 268 { 269 char buf[40]; 270 271 numtos(num, buf); 272 return (gfs_readdir_emit(st, uiop, voff, ino, buf)); 273 } 274 275 /* 276 * gfs_readdir_pred: readdir loop predicate 277 * voffp - a pointer in which the next virtual offset should be stored 278 * 279 * Returns a 0 on success, a non-zero errno on failure, or -1 if the 280 * readdir loop should terminate. A non-zero result (either errno or 281 * -1) from this function is typically passed directly to 282 * gfs_readdir_fini(). 283 */ 284 int 285 gfs_readdir_pred(gfs_readdir_state_t *st, uio_t *uiop, offset_t *voffp) 286 { 287 offset_t off, voff; 288 int error; 289 290 top: 291 if (uiop->uio_resid <= 0) 292 return (-1); 293 294 off = uiop->uio_loffset / st->grd_ureclen; 295 voff = off - 2; 296 if (off == 0) { 297 if ((error = gfs_readdir_emit(st, uiop, voff, st->grd_self, 298 ".")) == 0) 299 goto top; 300 } else if (off == 1) { 301 if ((error = gfs_readdir_emit(st, uiop, voff, st->grd_parent, 302 "..")) == 0) 303 goto top; 304 } else { 305 *voffp = voff; 306 return (0); 307 } 308 309 return (error); 310 } 311 312 /* 313 * gfs_readdir_fini: generic readdir cleanup 314 * error - if positive, an error to return 315 * eofp - the eofp passed to readdir 316 * eof - the eof value 317 * 318 * Returns a 0 on success, a non-zero errno on failure. This result 319 * should be returned from readdir. 320 */ 321 int 322 gfs_readdir_fini(gfs_readdir_state_t *st, int error, int *eofp, int eof) 323 { 324 kmem_free(st->grd_dirent, DIRENT64_RECLEN(st->grd_namlen)); 325 if (error > 0) 326 return (error); 327 if (eofp) 328 *eofp = eof; 329 return (0); 330 } 331 332 /* 333 * gfs_lookup_dot 334 * 335 * Performs a basic check for "." and ".." directory entries. 336 */ 337 int 338 gfs_lookup_dot(vnode_t **vpp, vnode_t *dvp, vnode_t *pvp, const char *nm) 339 { 340 if (*nm == '\0' || strcmp(nm, ".") == 0) { 341 VN_HOLD(dvp); 342 *vpp = dvp; 343 return (0); 344 } else if (strcmp(nm, "..") == 0) { 345 if (pvp == NULL) { 346 ASSERT(dvp->v_flag & VROOT); 347 VN_HOLD(dvp); 348 *vpp = dvp; 349 } else { 350 VN_HOLD(pvp); 351 *vpp = pvp; 352 } 353 return (0); 354 } 355 356 return (-1); 357 } 358 359 /* 360 * gfs_file_create(): create a new GFS file 361 * 362 * size - size of private data structure (v_data) 363 * pvp - parent vnode (GFS directory) 364 * ops - vnode operations vector 365 * 366 * In order to use this interface, the parent vnode must have been created by 367 * gfs_dir_create(), and the private data stored in v_data must have a 368 * 'gfs_file_t' as its first field. 369 * 370 * Given these constraints, this routine will automatically: 371 * 372 * - Allocate v_data for the vnode 373 * - Initialize necessary fields in the vnode 374 * - Hold the parent 375 */ 376 vnode_t * 377 gfs_file_create(size_t size, vnode_t *pvp, vnodeops_t *ops) 378 { 379 gfs_file_t *fp; 380 vnode_t *vp; 381 382 /* 383 * Allocate vnode and internal data structure 384 */ 385 fp = kmem_zalloc(size, KM_SLEEP); 386 vp = vn_alloc(KM_SLEEP); 387 388 /* 389 * Set up various pointers 390 */ 391 fp->gfs_vnode = vp; 392 fp->gfs_parent = pvp; 393 vp->v_data = fp; 394 fp->gfs_size = size; 395 fp->gfs_type = GFS_FILE; 396 397 /* 398 * Initialize vnode and hold parent. 399 */ 400 vn_setops(vp, ops); 401 if (pvp) { 402 VN_SET_VFS_TYPE_DEV(vp, pvp->v_vfsp, VREG, 0); 403 VN_HOLD(pvp); 404 } 405 406 return (vp); 407 } 408 409 /* 410 * gfs_dir_create: creates a new directory in the parent 411 * 412 * size - size of private data structure (v_data) 413 * pvp - parent vnode (GFS directory) 414 * ops - vnode operations vector 415 * entries - NULL-terminated list of static entries (if any) 416 * maxlen - maximum length of a directory entry 417 * readdir_cb - readdir callback (see gfs_dir_readdir) 418 * inode_cb - inode callback (see gfs_dir_readdir) 419 * lookup_cb - lookup callback (see gfs_dir_lookup) 420 * 421 * In order to use this function, the first member of the private vnode 422 * structure (v_data) must be a gfs_dir_t. For each directory, there are 423 * static entries, defined when the structure is initialized, and dynamic 424 * entries, retrieved through callbacks. 425 * 426 * If a directory has static entries, then it must supply a inode callback, 427 * which will compute the inode number based on the parent and the index. 428 * For a directory with dynamic entries, the caller must supply a readdir 429 * callback and a lookup callback. If a static lookup fails, we fall back to 430 * the supplied lookup callback, if any. 431 * 432 * This function also performs the same initialization as gfs_file_create(). 433 */ 434 vnode_t * 435 gfs_dir_create(size_t struct_size, vnode_t *pvp, vnodeops_t *ops, 436 gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen, 437 gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb) 438 { 439 vnode_t *vp; 440 gfs_dir_t *dp; 441 gfs_dirent_t *de; 442 443 vp = gfs_file_create(struct_size, pvp, ops); 444 vp->v_type = VDIR; 445 446 dp = vp->v_data; 447 dp->gfsd_file.gfs_type = GFS_DIR; 448 dp->gfsd_maxlen = maxlen; 449 450 if (entries != NULL) { 451 for (de = entries; de->gfse_name != NULL; de++) 452 dp->gfsd_nstatic++; 453 454 dp->gfsd_static = kmem_alloc( 455 dp->gfsd_nstatic * sizeof (gfs_dirent_t), KM_SLEEP); 456 bcopy(entries, dp->gfsd_static, 457 dp->gfsd_nstatic * sizeof (gfs_dirent_t)); 458 } 459 460 dp->gfsd_readdir = readdir_cb; 461 dp->gfsd_lookup = lookup_cb; 462 dp->gfsd_inode = inode_cb; 463 464 mutex_init(&dp->gfsd_lock, NULL, MUTEX_DEFAULT, NULL); 465 466 return (vp); 467 } 468 469 /* 470 * gfs_root_create(): create a root vnode for a GFS filesystem 471 * 472 * Similar to gfs_dir_create(), this creates a root vnode for a filesystem. The 473 * only difference is that it takes a vfs_t instead of a vnode_t as its parent. 474 */ 475 vnode_t * 476 gfs_root_create(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino, 477 gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen, 478 gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb) 479 { 480 vnode_t *vp = gfs_dir_create(size, NULL, ops, entries, inode_cb, 481 maxlen, readdir_cb, lookup_cb); 482 483 /* Manually set the inode */ 484 ((gfs_file_t *)vp->v_data)->gfs_ino = ino; 485 486 VFS_HOLD(vfsp); 487 VN_SET_VFS_TYPE_DEV(vp, vfsp, VDIR, 0); 488 vp->v_flag |= VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT; 489 490 return (vp); 491 } 492 493 /* 494 * gfs_file_inactive() 495 * 496 * Called from the VOP_INACTIVE() routine. If necessary, this routine will 497 * remove the given vnode from the parent directory and clean up any references 498 * in the VFS layer. 499 * 500 * If the vnode was not removed (due to a race with vget), then NULL is 501 * returned. Otherwise, a pointer to the private data is returned. 502 */ 503 void * 504 gfs_file_inactive(vnode_t *vp) 505 { 506 int i; 507 gfs_dirent_t *ge = NULL; 508 gfs_file_t *fp = vp->v_data; 509 gfs_dir_t *dp = NULL; 510 void *data; 511 512 if (fp->gfs_parent == NULL) 513 goto found; 514 515 dp = fp->gfs_parent->v_data; 516 517 /* 518 * First, see if this vnode is cached in the parent. 519 */ 520 gfs_dir_lock(dp); 521 522 /* 523 * Find it in the set of static entries. 524 */ 525 for (i = 0; i < dp->gfsd_nstatic; i++) { 526 ge = &dp->gfsd_static[i]; 527 528 if (ge->gfse_vnode == vp) 529 goto found; 530 } 531 532 /* 533 * If 'ge' is NULL, then it is a dynamic entry. 534 */ 535 ge = NULL; 536 537 found: 538 mutex_enter(&vp->v_lock); 539 if (vp->v_count == 1) { 540 /* 541 * Really remove this vnode 542 */ 543 data = vp->v_data; 544 if (ge != NULL) { 545 /* 546 * If this was a statically cached entry, simply set the 547 * cached vnode to NULL. 548 */ 549 ge->gfse_vnode = NULL; 550 } 551 mutex_exit(&vp->v_lock); 552 553 /* 554 * Free vnode and release parent 555 */ 556 if (fp->gfs_parent) { 557 gfs_dir_unlock(dp); 558 VN_RELE(fp->gfs_parent); 559 } else { 560 ASSERT(vp->v_vfsp != NULL); 561 VFS_RELE(vp->v_vfsp); 562 } 563 vn_free(vp); 564 } else { 565 vp->v_count--; 566 data = NULL; 567 mutex_exit(&vp->v_lock); 568 if (dp) 569 gfs_dir_unlock(dp); 570 } 571 572 return (data); 573 } 574 575 /* 576 * gfs_dir_inactive() 577 * 578 * Same as above, but for directories. 579 */ 580 void * 581 gfs_dir_inactive(vnode_t *vp) 582 { 583 gfs_dir_t *dp; 584 585 ASSERT(vp->v_type == VDIR); 586 587 if ((dp = gfs_file_inactive(vp)) != NULL) { 588 mutex_destroy(&dp->gfsd_lock); 589 if (dp->gfsd_nstatic) 590 kmem_free(dp->gfsd_static, 591 dp->gfsd_nstatic * sizeof (gfs_dirent_t)); 592 } 593 594 return (dp); 595 } 596 597 /* 598 * gfs_dir_lookup() 599 * 600 * Looks up the given name in the directory and returns the corresponding vnode, 601 * if found. 602 * 603 * First, we search statically defined entries, if any. If a match is found, 604 * and GFS_CACHE_VNODE is set and the vnode exists, we simply return the 605 * existing vnode. Otherwise, we call the static entry's callback routine, 606 * caching the result if necessary. 607 * 608 * If no static entry is found, we invoke the lookup callback, if any. The 609 * arguments to this callback are: 610 * 611 * int gfs_lookup_cb(vnode_t *pvp, const char *nm, vnode_t **vpp); 612 * 613 * pvp - parent vnode 614 * nm - name of entry 615 * vpp - pointer to resulting vnode 616 * 617 * Returns 0 on success, non-zero on error. 618 */ 619 int 620 gfs_dir_lookup(vnode_t *dvp, const char *nm, vnode_t **vpp) 621 { 622 int i; 623 gfs_dirent_t *ge; 624 vnode_t *vp; 625 gfs_dir_t *dp = dvp->v_data; 626 int ret = 0; 627 628 ASSERT(dvp->v_type == VDIR); 629 630 if (gfs_lookup_dot(vpp, dvp, dp->gfsd_file.gfs_parent, nm) == 0) 631 return (0); 632 633 gfs_dir_lock(dp); 634 635 /* 636 * Search static entries. 637 */ 638 for (i = 0; i < dp->gfsd_nstatic; i++) { 639 ge = &dp->gfsd_static[i]; 640 641 if (strcmp(ge->gfse_name, nm) == 0) { 642 if (ge->gfse_vnode) { 643 ASSERT(ge->gfse_flags & GFS_CACHE_VNODE); 644 vp = ge->gfse_vnode; 645 VN_HOLD(vp); 646 goto out; 647 } 648 649 /* 650 * We drop the directory lock, as the constuctor will 651 * need to do KM_SLEEP allocations. If we return from 652 * the constructor only to find that a parallel 653 * operation has completed, and GFS_CACHE_VNODE is set 654 * for this entry, we discard the result in favor of the 655 * cached vnode. 656 */ 657 gfs_dir_unlock(dp); 658 vp = ge->gfse_ctor(dvp); 659 gfs_dir_lock(dp); 660 661 ((gfs_file_t *)vp->v_data)->gfs_index = i; 662 663 /* Set the inode according to the callback. */ 664 ((gfs_file_t *)vp->v_data)->gfs_ino = 665 dp->gfsd_inode(dvp, i); 666 667 if (ge->gfse_flags & GFS_CACHE_VNODE) { 668 if (ge->gfse_vnode == NULL) { 669 ge->gfse_vnode = vp; 670 } else { 671 /* 672 * A parallel constructor beat us to it; 673 * return existing vnode. We have to be 674 * careful because we can't release the 675 * current vnode while holding the 676 * directory lock; its inactive routine 677 * will try to lock this directory. 678 */ 679 vnode_t *oldvp = vp; 680 vp = ge->gfse_vnode; 681 VN_HOLD(vp); 682 683 gfs_dir_unlock(dp); 684 VN_RELE(oldvp); 685 gfs_dir_lock(dp); 686 } 687 } 688 689 goto out; 690 } 691 } 692 693 /* 694 * See if there is a dynamic constructor. 695 */ 696 if (dp->gfsd_lookup) { 697 ino64_t ino; 698 gfs_file_t *fp; 699 700 /* 701 * Once again, drop the directory lock, as the lookup routine 702 * will need to allocate memory, or otherwise deadlock on this 703 * directory. 704 */ 705 gfs_dir_unlock(dp); 706 ret = dp->gfsd_lookup(dvp, nm, &vp, &ino); 707 gfs_dir_lock(dp); 708 if (ret != 0) 709 goto out; 710 711 fp = (gfs_file_t *)vp->v_data; 712 fp->gfs_index = -1; 713 fp->gfs_ino = ino; 714 } else { 715 /* 716 * No static entry found, and there is no lookup callback, so 717 * return ENOENT. 718 */ 719 ret = ENOENT; 720 } 721 722 out: 723 gfs_dir_unlock(dp); 724 725 *vpp = vp; 726 727 return (ret); 728 } 729 730 /* 731 * gfs_dir_readdir: does a readdir() on the given directory 732 * 733 * dvp - directory vnode 734 * uiop - uio structure 735 * eofp - eof pointer 736 * data - arbitrary data passed to readdir callback 737 * 738 * This routine does all the readdir() dirty work. Even so, the caller must 739 * supply two callbacks in order to get full compatibility. 740 * 741 * If the directory contains static entries, an inode callback must be 742 * specified. This avoids having to create every vnode and call VOP_GETATTR() 743 * when reading the directory. This function has the following arguments: 744 * 745 * ino_t gfs_inode_cb(vnode_t *vp, int index); 746 * 747 * vp - vnode for the directory 748 * index - index in original gfs_dirent_t array 749 * 750 * Returns the inode number for the given entry. 751 * 752 * For directories with dynamic entries, a readdir callback must be provided. 753 * This is significantly more complex, thanks to the particulars of 754 * VOP_READDIR(). 755 * 756 * int gfs_readdir_cb(vnode_t *vp, struct dirent64 *dp, int *eofp, 757 * offset_t *off, offset_t *nextoff, void *data) 758 * 759 * vp - directory vnode 760 * dp - directory entry, sized according to maxlen given to 761 * gfs_dir_create(). callback must fill in d_name and 762 * d_ino. 763 * eofp - callback must set to 1 when EOF has been reached 764 * off - on entry, the last offset read from the directory. Callback 765 * must set to the offset of the current entry, typically left 766 * untouched. 767 * nextoff - callback must set to offset of next entry. Typically 768 * (off + 1) 769 * data - caller-supplied data 770 * 771 * Return 0 on success, or error on failure. 772 */ 773 int 774 gfs_dir_readdir(vnode_t *dvp, uio_t *uiop, int *eofp, void *data) 775 { 776 gfs_readdir_state_t gstate; 777 int error, eof = 0; 778 ino64_t ino, pino; 779 offset_t off, next; 780 gfs_dir_t *dp = dvp->v_data; 781 782 ino = dp->gfsd_file.gfs_ino; 783 784 if (dp->gfsd_file.gfs_parent == NULL) 785 pino = ino; /* root of filesystem */ 786 else 787 pino = ((gfs_file_t *) 788 (dp->gfsd_file.gfs_parent->v_data))->gfs_ino; 789 790 if ((error = gfs_readdir_init(&gstate, dp->gfsd_maxlen, 1, uiop, 791 pino, ino)) != 0) 792 return (error); 793 794 while ((error = gfs_readdir_pred(&gstate, uiop, &off)) == 0 && 795 !eof) { 796 797 if (off >= 0 && off < dp->gfsd_nstatic) { 798 ino = dp->gfsd_inode(dvp, off); 799 800 if ((error = gfs_readdir_emit(&gstate, uiop, 801 off, ino, dp->gfsd_static[off].gfse_name)) 802 != 0) 803 break; 804 805 } else if (dp->gfsd_readdir) { 806 off -= dp->gfsd_nstatic; 807 808 if ((error = dp->gfsd_readdir(dvp, 809 gstate.grd_dirent, &eof, &off, &next, 810 data)) != 0 || eof) 811 break; 812 813 off += dp->gfsd_nstatic + 2; 814 next += dp->gfsd_nstatic + 2; 815 816 if ((error = gfs_readdir_emit_int(&gstate, uiop, 817 off, next)) != 0) 818 break; 819 } else { 820 /* 821 * Offset is beyond the end of the static entries, and 822 * we have no dynamic entries. Set EOF. 823 */ 824 eof = 1; 825 } 826 } 827 828 return (gfs_readdir_fini(&gstate, error, eofp, eof)); 829 } 830 831 832 /* 833 * gfs_vop_lookup: VOP_LOOKUP() entry point 834 * 835 * For use directly in vnode ops table. Given a GFS directory, calls 836 * gfs_dir_lookup() as necessary. 837 */ 838 /* ARGSUSED */ 839 int 840 gfs_vop_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, 841 int flags, vnode_t *rdir, cred_t *cr) 842 { 843 return (gfs_dir_lookup(dvp, nm, vpp)); 844 } 845 846 /* 847 * gfs_vop_readdir: VOP_READDIR() entry point 848 * 849 * For use directly in vnode ops table. Given a GFS directory, calls 850 * gfs_dir_readdir() as necessary. 851 */ 852 /* ARGSUSED */ 853 int 854 gfs_vop_readdir(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp) 855 { 856 return (gfs_dir_readdir(vp, uiop, eofp, NULL)); 857 } 858 859 860 /* 861 * gfs_vop_map: VOP_MAP() entry point 862 * 863 * Convenient routine for handling pseudo-files that wish to allow mmap() calls. 864 * This function only works for readonly files, and uses the read function for 865 * the vnode to fill in the data. The mapped data is immediately faulted in and 866 * filled with the necessary data during this call; there are no getpage() or 867 * putpage() routines. 868 */ 869 /* ARGSUSED */ 870 int 871 gfs_vop_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp, 872 size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cred) 873 { 874 int rv; 875 ssize_t resid = len; 876 877 /* 878 * Check for bad parameters 879 */ 880 #ifdef _ILP32 881 if (len > MAXOFF_T) 882 return (ENOMEM); 883 #endif 884 if (vp->v_flag & VNOMAP) 885 return (ENOTSUP); 886 if (off > MAXOFF_T) 887 return (EFBIG); 888 if ((long)off < 0 || (long)(off + len) < 0) 889 return (EINVAL); 890 if (vp->v_type != VREG) 891 return (ENODEV); 892 if ((prot & (PROT_EXEC | PROT_WRITE)) != 0) 893 return (EACCES); 894 895 /* 896 * Find appropriate address if needed, otherwise clear address range. 897 */ 898 as_rangelock(as); 899 if ((flags & MAP_FIXED) == 0) { 900 map_addr(addrp, len, (offset_t)off, 1, flags); 901 if (*addrp == NULL) { 902 as_rangeunlock(as); 903 return (ENOMEM); 904 } 905 } else { 906 (void) as_unmap(as, *addrp, len); 907 } 908 909 /* 910 * Create mapping 911 */ 912 rv = as_map(as, *addrp, len, segvn_create, zfod_argsp); 913 as_rangeunlock(as); 914 if (rv != 0) 915 return (rv); 916 917 /* 918 * Fill with data from read() 919 */ 920 rv = vn_rdwr(UIO_READ, vp, *addrp, len, off, UIO_USERSPACE, 921 0, (rlim64_t)0, cred, &resid); 922 923 if (rv == 0 && resid != 0) 924 rv = ENXIO; 925 926 if (rv != 0) { 927 as_rangelock(as); 928 (void) as_unmap(as, *addrp, len); 929 as_rangeunlock(as); 930 } 931 932 return (rv); 933 } 934 935 /* 936 * gfs_vop_inactive: VOP_INACTIVE() entry point 937 * 938 * Given a vnode that is a GFS file or directory, call gfs_file_inactive() or 939 * gfs_dir_inactive() as necessary, and kmem_free()s associated private data. 940 */ 941 /* ARGSUSED */ 942 void 943 gfs_vop_inactive(vnode_t *vp, cred_t *cr) 944 { 945 gfs_file_t *fp = vp->v_data; 946 void *data; 947 948 if (fp->gfs_type == GFS_DIR) 949 data = gfs_dir_inactive(vp); 950 else 951 data = gfs_file_inactive(vp); 952 953 if (data != NULL) 954 kmem_free(data, fp->gfs_size); 955 } 956