sysvbfs_vnops.c revision 1.38.4.1
1 /* $NetBSD: sysvbfs_vnops.c,v 1.38.4.1 2012/04/17 00:08:20 yamt Exp $ */ 2 3 /*- 4 * Copyright (c) 2004 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by UCHIYAMA Yasushi. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: sysvbfs_vnops.c,v 1.38.4.1 2012/04/17 00:08:20 yamt Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/kernel.h> 37 #include <sys/resource.h> 38 #include <sys/vnode.h> 39 #include <sys/namei.h> 40 #include <sys/dirent.h> 41 #include <sys/malloc.h> 42 #include <sys/lockf.h> 43 #include <sys/unistd.h> 44 #include <sys/fcntl.h> 45 #include <sys/kauth.h> 46 #include <sys/buf.h> 47 48 #include <miscfs/genfs/genfs.h> 49 50 #include <fs/sysvbfs/sysvbfs.h> 51 #include <fs/sysvbfs/bfs.h> 52 53 #ifdef SYSVBFS_VNOPS_DEBUG 54 #define DPRINTF(fmt, args...) printf(fmt, ##args) 55 #else 56 #define DPRINTF(arg...) ((void)0) 57 #endif 58 #define ROUND_SECTOR(x) (((x) + 511) & ~511) 59 60 MALLOC_JUSTDEFINE(M_SYSVBFS_VNODE, "sysvbfs vnode", "sysvbfs vnode structures"); 61 MALLOC_DECLARE(M_BFS); 62 63 int 64 sysvbfs_lookup(void *arg) 65 { 66 struct vop_lookup_args /* { 67 struct vnode *a_dvp; 68 struct vnode **a_vpp; 69 struct componentname *a_cnp; 70 } */ *a = arg; 71 struct vnode *v = a->a_dvp; 72 struct sysvbfs_node *bnode = v->v_data; 73 struct bfs *bfs = bnode->bmp->bfs; /* my filesystem */ 74 struct vnode *vpp = NULL; 75 struct bfs_dirent *dirent = NULL; 76 struct componentname *cnp = a->a_cnp; 77 int nameiop = cnp->cn_nameiop; 78 const char *name = cnp->cn_nameptr; 79 int namelen = cnp->cn_namelen; 80 int error; 81 82 DPRINTF("%s: %s op=%d %d\n", __func__, name, nameiop, 83 cnp->cn_flags); 84 85 *a->a_vpp = NULL; 86 87 KASSERT((cnp->cn_flags & ISDOTDOT) == 0); 88 89 if ((error = VOP_ACCESS(a->a_dvp, VEXEC, cnp->cn_cred)) != 0) { 90 return error; /* directory permission. */ 91 } 92 93 /* Deny last component write operation on a read-only mount */ 94 if ((cnp->cn_flags & ISLASTCN) && (v->v_mount->mnt_flag & MNT_RDONLY) && 95 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) 96 return EROFS; 97 98 if (namelen == 1 && name[0] == '.') { /* "." */ 99 vref(v); 100 *a->a_vpp = v; 101 } else { /* Regular file */ 102 if (!bfs_dirent_lookup_by_name(bfs, cnp->cn_nameptr, 103 &dirent)) { 104 if (nameiop != CREATE && nameiop != RENAME) { 105 DPRINTF("%s: no such a file. (1)\n", 106 __func__); 107 return ENOENT; 108 } 109 if ((error = VOP_ACCESS(v, VWRITE, cnp->cn_cred)) != 0) 110 return error; 111 return EJUSTRETURN; 112 } 113 114 /* Allocate v-node */ 115 if ((error = sysvbfs_vget(v->v_mount, dirent->inode, &vpp)) != 0) { 116 DPRINTF("%s: can't get vnode.\n", __func__); 117 return error; 118 } 119 *a->a_vpp = vpp; 120 } 121 122 return 0; 123 } 124 125 int 126 sysvbfs_create(void *arg) 127 { 128 struct vop_create_args /* { 129 struct vnode *a_dvp; 130 struct vnode **a_vpp; 131 struct componentname *a_cnp; 132 struct vattr *a_vap; 133 } */ *a = arg; 134 struct sysvbfs_node *bnode = a->a_dvp->v_data; 135 struct sysvbfs_mount *bmp = bnode->bmp; 136 struct bfs *bfs = bmp->bfs; 137 struct mount *mp = bmp->mountp; 138 struct bfs_dirent *dirent; 139 struct bfs_fileattr attr; 140 struct vattr *va = a->a_vap; 141 kauth_cred_t cr = a->a_cnp->cn_cred; 142 int err = 0; 143 144 DPRINTF("%s: %s\n", __func__, a->a_cnp->cn_nameptr); 145 KDASSERT(a->a_vap->va_type == VREG); 146 attr.uid = kauth_cred_geteuid(cr); 147 attr.gid = kauth_cred_getegid(cr); 148 attr.mode = va->va_mode; 149 150 if ((err = bfs_file_create(bfs, a->a_cnp->cn_nameptr, 0, 0, &attr)) 151 != 0) { 152 DPRINTF("%s: bfs_file_create failed.\n", __func__); 153 goto unlock_exit; 154 } 155 156 if (!bfs_dirent_lookup_by_name(bfs, a->a_cnp->cn_nameptr, &dirent)) 157 panic("no dirent for created file."); 158 159 if ((err = sysvbfs_vget(mp, dirent->inode, a->a_vpp)) != 0) { 160 DPRINTF("%s: sysvbfs_vget failed.\n", __func__); 161 goto unlock_exit; 162 } 163 bnode = (*a->a_vpp)->v_data; 164 bnode->update_ctime = true; 165 bnode->update_mtime = true; 166 bnode->update_atime = true; 167 168 unlock_exit: 169 /* unlock parent directory */ 170 vput(a->a_dvp); /* locked at sysvbfs_lookup(); */ 171 172 return err; 173 } 174 175 int 176 sysvbfs_open(void *arg) 177 { 178 struct vop_open_args /* { 179 struct vnode *a_vp; 180 int a_mode; 181 kauth_cred_t a_cred; 182 } */ *a = arg; 183 struct vnode *v = a->a_vp; 184 struct sysvbfs_node *bnode = v->v_data; 185 struct bfs_inode *inode = bnode->inode; 186 struct bfs *bfs = bnode->bmp->bfs; 187 struct bfs_dirent *dirent; 188 189 DPRINTF("%s:\n", __func__); 190 KDASSERT(v->v_type == VREG || v->v_type == VDIR); 191 192 if (!bfs_dirent_lookup_by_inode(bfs, inode->number, &dirent)) 193 return ENOENT; 194 bnode->update_atime = true; 195 if ((a->a_mode & FWRITE) && !(a->a_mode & O_APPEND)) { 196 bnode->size = 0; 197 } else { 198 bnode->size = bfs_file_size(inode); 199 } 200 bnode->data_block = inode->start_sector; 201 202 return 0; 203 } 204 205 int 206 sysvbfs_close(void *arg) 207 { 208 struct vop_close_args /* { 209 struct vnodeop_desc *a_desc; 210 struct vnode *a_vp; 211 int a_fflag; 212 kauth_cred_t a_cred; 213 } */ *a = arg; 214 struct vnode *v = a->a_vp; 215 struct sysvbfs_node *bnode = v->v_data; 216 struct bfs_fileattr attr; 217 218 DPRINTF("%s:\n", __func__); 219 uvm_vnp_setsize(v, bnode->size); 220 221 memset(&attr, 0xff, sizeof attr); /* Set VNOVAL all */ 222 if (bnode->update_atime) 223 attr.atime = time_second; 224 if (bnode->update_ctime) 225 attr.ctime = time_second; 226 if (bnode->update_mtime) 227 attr.mtime = time_second; 228 bfs_inode_set_attr(bnode->bmp->bfs, bnode->inode, &attr); 229 230 VOP_FSYNC(a->a_vp, a->a_cred, FSYNC_WAIT, 0, 0); 231 232 return 0; 233 } 234 235 static int 236 sysvbfs_check_possible(struct vnode *vp, struct sysvbfs_node *bnode, 237 mode_t mode) 238 { 239 240 if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) 241 return EROFS; 242 243 return 0; 244 } 245 246 static int 247 sysvbfs_check_permitted(struct vnode *vp, struct sysvbfs_node *bnode, 248 mode_t mode, kauth_cred_t cred) 249 { 250 struct bfs_fileattr *attr = &bnode->inode->attr; 251 252 return kauth_authorize_vnode(cred, kauth_access_action(mode, 253 vp->v_type, attr->mode), vp, NULL, genfs_can_access(vp->v_type, 254 attr->mode, attr->uid, attr->gid, mode, cred)); 255 } 256 257 int 258 sysvbfs_access(void *arg) 259 { 260 struct vop_access_args /* { 261 struct vnode *a_vp; 262 int a_mode; 263 kauth_cred_t a_cred; 264 } */ *ap = arg; 265 struct vnode *vp = ap->a_vp; 266 struct sysvbfs_node *bnode = vp->v_data; 267 int error; 268 269 DPRINTF("%s:\n", __func__); 270 271 error = sysvbfs_check_possible(vp, bnode, ap->a_mode); 272 if (error) 273 return error; 274 275 error = sysvbfs_check_permitted(vp, bnode, ap->a_mode, ap->a_cred); 276 277 return error; 278 } 279 280 int 281 sysvbfs_getattr(void *v) 282 { 283 struct vop_getattr_args /* { 284 struct vnode *a_vp; 285 struct vattr *a_vap; 286 kauth_cred_t a_cred; 287 } */ *ap = v; 288 struct vnode *vp = ap->a_vp; 289 struct sysvbfs_node *bnode = vp->v_data; 290 struct bfs_inode *inode = bnode->inode; 291 struct bfs_fileattr *attr = &inode->attr; 292 struct sysvbfs_mount *bmp = bnode->bmp; 293 struct vattr *vap = ap->a_vap; 294 295 DPRINTF("%s:\n", __func__); 296 297 vap->va_type = vp->v_type; 298 vap->va_mode = attr->mode; 299 vap->va_nlink = attr->nlink; 300 vap->va_uid = attr->uid; 301 vap->va_gid = attr->gid; 302 vap->va_fsid = bmp->devvp->v_rdev; 303 vap->va_fileid = inode->number; 304 vap->va_size = bfs_file_size(inode); 305 vap->va_blocksize = BFS_BSIZE; 306 vap->va_atime.tv_sec = attr->atime; 307 vap->va_mtime.tv_sec = attr->mtime; 308 vap->va_ctime.tv_sec = attr->ctime; 309 vap->va_birthtime.tv_sec = 0; 310 vap->va_gen = 1; 311 vap->va_flags = 0; 312 vap->va_rdev = 0; /* No device file */ 313 vap->va_bytes = vap->va_size; 314 vap->va_filerev = 0; 315 vap->va_vaflags = 0; 316 317 return 0; 318 } 319 320 int 321 sysvbfs_setattr(void *arg) 322 { 323 struct vop_setattr_args /* { 324 struct vnode *a_vp; 325 struct vattr *a_vap; 326 kauth_cred_t a_cred; 327 struct proc *p; 328 } */ *ap = arg; 329 struct vnode *vp = ap->a_vp; 330 struct vattr *vap = ap->a_vap; 331 struct sysvbfs_node *bnode = vp->v_data; 332 struct bfs_inode *inode = bnode->inode; 333 struct bfs_fileattr *attr = &inode->attr; 334 struct bfs *bfs = bnode->bmp->bfs; 335 kauth_cred_t cred = ap->a_cred; 336 int error; 337 338 DPRINTF("%s:\n", __func__); 339 if (vp->v_mount->mnt_flag & MNT_RDONLY) 340 return EROFS; 341 342 if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || 343 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || 344 (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || 345 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) 346 return EINVAL; 347 348 if (vap->va_flags != VNOVAL) 349 return EOPNOTSUPP; 350 351 if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (uid_t)VNOVAL) { 352 uid_t uid = 353 (vap->va_uid != (uid_t)VNOVAL) ? vap->va_uid : attr->uid; 354 gid_t gid = 355 (vap->va_gid != (gid_t)VNOVAL) ? vap->va_gid : attr->gid; 356 error = kauth_authorize_vnode(cred, 357 KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL, 358 genfs_can_chown(cred, attr->uid, attr->gid, uid, gid)); 359 if (error) 360 return error; 361 attr->uid = uid; 362 attr->gid = gid; 363 } 364 365 if (vap->va_size != VNOVAL) 366 switch (vp->v_type) { 367 case VDIR: 368 return EISDIR; 369 case VCHR: 370 case VBLK: 371 case VFIFO: 372 break; 373 case VREG: 374 if (vp->v_mount->mnt_flag & MNT_RDONLY) 375 return EROFS; 376 bfs_file_setsize(vp, vap->va_size); 377 break; 378 default: 379 return EOPNOTSUPP; 380 } 381 382 if (vap->va_mode != (mode_t)VNOVAL) { 383 mode_t mode = vap->va_mode; 384 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY, 385 vp, NULL, genfs_can_chmod(vp->v_type, cred, attr->uid, 386 attr->gid, mode)); 387 if (error) 388 return error; 389 attr->mode = mode; 390 } 391 392 if ((vap->va_atime.tv_sec != VNOVAL) || 393 (vap->va_mtime.tv_sec != VNOVAL) || 394 (vap->va_ctime.tv_sec != VNOVAL)) { 395 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp, 396 NULL, genfs_can_chtimes(vp, vap->va_vaflags, attr->uid, 397 cred)); 398 if (error) 399 return error; 400 401 if (vap->va_atime.tv_sec != VNOVAL) 402 attr->atime = vap->va_atime.tv_sec; 403 if (vap->va_mtime.tv_sec != VNOVAL) 404 attr->mtime = vap->va_mtime.tv_sec; 405 if (vap->va_ctime.tv_sec != VNOVAL) 406 attr->ctime = vap->va_ctime.tv_sec; 407 } 408 409 bfs_inode_set_attr(bfs, inode, attr); 410 411 return 0; 412 } 413 414 int 415 sysvbfs_read(void *arg) 416 { 417 struct vop_read_args /* { 418 struct vnode *a_vp; 419 struct uio *a_uio; 420 int a_ioflag; 421 kauth_cred_t a_cred; 422 } */ *a = arg; 423 struct vnode *v = a->a_vp; 424 struct uio *uio = a->a_uio; 425 struct sysvbfs_node *bnode = v->v_data; 426 struct bfs_inode *inode = bnode->inode; 427 vsize_t sz, filesz = bfs_file_size(inode); 428 int err; 429 const int advice = IO_ADV_DECODE(a->a_ioflag); 430 431 DPRINTF("%s: type=%d\n", __func__, v->v_type); 432 switch (v->v_type) { 433 case VREG: 434 break; 435 case VDIR: 436 return EISDIR; 437 default: 438 return EINVAL; 439 } 440 441 while (uio->uio_resid > 0) { 442 if ((sz = MIN(filesz - uio->uio_offset, uio->uio_resid)) == 0) 443 break; 444 445 err = ubc_uiomove(&v->v_uobj, uio, sz, advice, 446 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(v)); 447 if (err) 448 break; 449 DPRINTF("%s: read %ldbyte\n", __func__, sz); 450 } 451 452 return sysvbfs_update(v, NULL, NULL, UPDATE_WAIT); 453 } 454 455 int 456 sysvbfs_write(void *arg) 457 { 458 struct vop_write_args /* { 459 struct vnode *a_vp; 460 struct uio *a_uio; 461 int a_ioflag; 462 kauth_cred_t a_cred; 463 } */ *a = arg; 464 struct vnode *v = a->a_vp; 465 struct uio *uio = a->a_uio; 466 int advice = IO_ADV_DECODE(a->a_ioflag); 467 struct sysvbfs_node *bnode = v->v_data; 468 bool extended = false; 469 vsize_t sz; 470 int err = 0; 471 472 if (a->a_vp->v_type != VREG) 473 return EISDIR; 474 475 if (a->a_ioflag & IO_APPEND) 476 uio->uio_offset = bnode->size; 477 478 if (uio->uio_resid == 0) 479 return 0; 480 481 if (bnode->size < uio->uio_offset + uio->uio_resid) { 482 bfs_file_setsize(v, uio->uio_offset + uio->uio_resid); 483 extended = true; 484 } 485 486 while (uio->uio_resid > 0) { 487 sz = uio->uio_resid; 488 err = ubc_uiomove(&v->v_uobj, uio, sz, advice, 489 UBC_WRITE | UBC_UNMAP_FLAG(v)); 490 if (err) 491 break; 492 DPRINTF("%s: write %ldbyte\n", __func__, sz); 493 } 494 if (err) 495 bfs_file_setsize(v, bnode->size - uio->uio_resid); 496 497 VN_KNOTE(v, NOTE_WRITE | (extended ? NOTE_EXTEND : 0)); 498 499 return err; 500 } 501 502 int 503 sysvbfs_remove(void *arg) 504 { 505 struct vop_remove_args /* { 506 struct vnodeop_desc *a_desc; 507 struct vnode * a_dvp; 508 struct vnode * a_vp; 509 struct componentname * a_cnp; 510 } */ *ap = arg; 511 struct vnode *vp = ap->a_vp; 512 struct vnode *dvp = ap->a_dvp; 513 struct sysvbfs_node *bnode = vp->v_data; 514 struct sysvbfs_mount *bmp = bnode->bmp; 515 struct bfs *bfs = bmp->bfs; 516 int err; 517 518 DPRINTF("%s: delete %s\n", __func__, ap->a_cnp->cn_nameptr); 519 520 if (vp->v_type == VDIR) 521 return EPERM; 522 523 if ((err = bfs_file_delete(bfs, ap->a_cnp->cn_nameptr)) != 0) 524 DPRINTF("%s: bfs_file_delete failed.\n", __func__); 525 526 VN_KNOTE(ap->a_vp, NOTE_DELETE); 527 VN_KNOTE(ap->a_dvp, NOTE_WRITE); 528 if (dvp == vp) 529 vrele(vp); 530 else 531 vput(vp); 532 vput(dvp); 533 534 if (err == 0) { 535 bnode->removed = 1; 536 } 537 538 return err; 539 } 540 541 int 542 sysvbfs_rename(void *arg) 543 { 544 struct vop_rename_args /* { 545 struct vnode *a_fdvp; from parent-directory v-node 546 struct vnode *a_fvp; from file v-node 547 struct componentname *a_fcnp; 548 struct vnode *a_tdvp; to parent-directory 549 struct vnode *a_tvp; to file v-node 550 struct componentname *a_tcnp; 551 } */ *ap = arg; 552 struct vnode *fvp = ap->a_fvp; 553 struct vnode *fdvp = ap->a_fdvp; 554 struct vnode *tvp = ap->a_tvp; 555 struct vnode *tdvp = ap->a_tdvp; 556 struct sysvbfs_node *bnode = fvp->v_data; 557 struct bfs *bfs = bnode->bmp->bfs; 558 const char *from_name = ap->a_fcnp->cn_nameptr; 559 const char *to_name = ap->a_tcnp->cn_nameptr; 560 int error; 561 562 DPRINTF("%s: %s->%s\n", __func__, from_name, to_name); 563 if ((fvp->v_mount != tdvp->v_mount) || 564 (tvp && (fvp->v_mount != tvp->v_mount))) { 565 error = EXDEV; 566 printf("cross-device link\n"); 567 goto out; 568 } 569 570 KDASSERT(fvp->v_type == VREG); 571 KDASSERT(tvp == NULL ? true : tvp->v_type == VREG); 572 KASSERT(tdvp == fdvp); 573 574 /* 575 * Make sure the source hasn't been removed between lookup 576 * and target directory lock. 577 */ 578 if (bnode->removed) { 579 error = ENOENT; 580 goto out; 581 } 582 583 error = bfs_file_rename(bfs, from_name, to_name); 584 out: 585 if (tvp) { 586 if (error == 0) { 587 struct sysvbfs_node *tbnode = tvp->v_data; 588 tbnode->removed = 1; 589 } 590 vput(tvp); 591 } 592 593 /* tdvp == tvp probably can't happen with this fs, but safety first */ 594 if (tdvp == tvp) 595 vrele(tdvp); 596 else 597 vput(tdvp); 598 599 vrele(fdvp); 600 vrele(fvp); 601 602 return 0; 603 } 604 605 int 606 sysvbfs_readdir(void *v) 607 { 608 struct vop_readdir_args /* { 609 struct vnode *a_vp; 610 struct uio *a_uio; 611 kauth_cred_t a_cred; 612 int *a_eofflag; 613 off_t **a_cookies; 614 int *a_ncookies; 615 } */ *ap = v; 616 struct uio *uio = ap->a_uio; 617 struct vnode *vp = ap->a_vp; 618 struct sysvbfs_node *bnode = vp->v_data; 619 struct bfs *bfs = bnode->bmp->bfs; 620 struct dirent *dp; 621 struct bfs_dirent *file; 622 int i, n, error; 623 624 DPRINTF("%s: offset=%" PRId64 " residue=%zu\n", __func__, 625 uio->uio_offset, uio->uio_resid); 626 627 KDASSERT(vp->v_type == VDIR); 628 KDASSERT(uio->uio_offset >= 0); 629 630 dp = malloc(sizeof(struct dirent), M_BFS, M_WAITOK | M_ZERO); 631 632 i = uio->uio_offset / sizeof(struct dirent); 633 n = uio->uio_resid / sizeof(struct dirent); 634 if ((i + n) > bfs->n_dirent) 635 n = bfs->n_dirent - i; 636 637 for (file = &bfs->dirent[i]; i < n; file++) { 638 if (file->inode == 0) 639 continue; 640 if (i == bfs->max_dirent) { 641 DPRINTF("%s: file system inconsistent.\n", 642 __func__); 643 break; 644 } 645 i++; 646 memset(dp, 0, sizeof(struct dirent)); 647 dp->d_fileno = file->inode; 648 dp->d_type = file->inode == BFS_ROOT_INODE ? DT_DIR : DT_REG; 649 dp->d_namlen = strlen(file->name); 650 strncpy(dp->d_name, file->name, BFS_FILENAME_MAXLEN); 651 dp->d_reclen = sizeof(struct dirent); 652 if ((error = uiomove(dp, dp->d_reclen, uio)) != 0) { 653 DPRINTF("%s: uiomove failed.\n", __func__); 654 free(dp, M_BFS); 655 return error; 656 } 657 } 658 DPRINTF("%s: %d %d %d\n", __func__, i, n, bfs->n_dirent); 659 *ap->a_eofflag = (i == bfs->n_dirent); 660 661 free(dp, M_BFS); 662 return 0; 663 } 664 665 int 666 sysvbfs_inactive(void *arg) 667 { 668 struct vop_inactive_args /* { 669 struct vnode *a_vp; 670 bool *a_recycle; 671 } */ *a = arg; 672 struct vnode *v = a->a_vp; 673 struct sysvbfs_node *bnode = v->v_data; 674 675 DPRINTF("%s:\n", __func__); 676 if (bnode->removed) 677 *a->a_recycle = true; 678 else 679 *a->a_recycle = false; 680 VOP_UNLOCK(v); 681 682 return 0; 683 } 684 685 int 686 sysvbfs_reclaim(void *v) 687 { 688 extern struct pool sysvbfs_node_pool; 689 struct vop_reclaim_args /* { 690 struct vnode *a_vp; 691 } */ *ap = v; 692 struct vnode *vp = ap->a_vp; 693 struct sysvbfs_node *bnode = vp->v_data; 694 695 DPRINTF("%s:\n", __func__); 696 mutex_enter(&mntvnode_lock); 697 LIST_REMOVE(bnode, link); 698 mutex_exit(&mntvnode_lock); 699 genfs_node_destroy(vp); 700 pool_put(&sysvbfs_node_pool, bnode); 701 vp->v_data = NULL; 702 703 return 0; 704 } 705 706 int 707 sysvbfs_bmap(void *arg) 708 { 709 struct vop_bmap_args /* { 710 struct vnode *a_vp; 711 daddr_t a_bn; 712 struct vnode **a_vpp; 713 daddr_t *a_bnp; 714 int *a_runp; 715 } */ *a = arg; 716 struct vnode *v = a->a_vp; 717 struct sysvbfs_node *bnode = v->v_data; 718 struct sysvbfs_mount *bmp = bnode->bmp; 719 struct bfs_inode *inode = bnode->inode; 720 daddr_t blk; 721 722 DPRINTF("%s:\n", __func__); 723 /* BFS algorithm is contiguous allocation */ 724 blk = inode->start_sector + a->a_bn; 725 726 if (blk * BFS_BSIZE > bmp->bfs->data_end) 727 return ENOSPC; 728 729 *a->a_vpp = bmp->devvp; 730 *a->a_runp = 0; 731 DPRINTF("%s: %d + %" PRId64 "\n", __func__, inode->start_sector, 732 a->a_bn); 733 734 *a->a_bnp = blk; 735 736 737 return 0; 738 } 739 740 int 741 sysvbfs_strategy(void *arg) 742 { 743 struct vop_strategy_args /* { 744 struct vnode *a_vp; 745 struct buf *a_bp; 746 } */ *a = arg; 747 struct buf *b = a->a_bp; 748 struct vnode *v = a->a_vp; 749 struct sysvbfs_node *bnode = v->v_data; 750 struct sysvbfs_mount *bmp = bnode->bmp; 751 int error; 752 753 DPRINTF("%s:\n", __func__); 754 KDASSERT(v->v_type == VREG); 755 if (b->b_blkno == b->b_lblkno) { 756 error = VOP_BMAP(v, b->b_lblkno, NULL, &b->b_blkno, NULL); 757 if (error) { 758 b->b_error = error; 759 biodone(b); 760 return error; 761 } 762 if ((long)b->b_blkno == -1) 763 clrbuf(b); 764 } 765 if ((long)b->b_blkno == -1) { 766 biodone(b); 767 return 0; 768 } 769 770 return VOP_STRATEGY(bmp->devvp, b); 771 } 772 773 int 774 sysvbfs_print(void *v) 775 { 776 struct vop_print_args /* { 777 struct vnode *a_vp; 778 } */ *ap = v; 779 struct sysvbfs_node *bnode = ap->a_vp->v_data; 780 781 DPRINTF("%s:\n", __func__); 782 bfs_dump(bnode->bmp->bfs); 783 784 return 0; 785 } 786 787 int 788 sysvbfs_advlock(void *v) 789 { 790 struct vop_advlock_args /* { 791 struct vnode *a_vp; 792 void *a_id; 793 int a_op; 794 struct flock *a_fl; 795 int a_flags; 796 } */ *ap = v; 797 struct sysvbfs_node *bnode = ap->a_vp->v_data; 798 799 DPRINTF("%s: op=%d\n", __func__, ap->a_op); 800 801 return lf_advlock(ap, &bnode->lockf, bfs_file_size(bnode->inode)); 802 } 803 804 int 805 sysvbfs_pathconf(void *v) 806 { 807 struct vop_pathconf_args /* { 808 struct vnode *a_vp; 809 int a_name; 810 register_t *a_retval; 811 } */ *ap = v; 812 int err = 0; 813 814 DPRINTF("%s:\n", __func__); 815 816 switch (ap->a_name) { 817 case _PC_LINK_MAX: 818 *ap->a_retval = 1; 819 break; 820 case _PC_NAME_MAX: 821 *ap->a_retval = BFS_FILENAME_MAXLEN; 822 break; 823 case _PC_PATH_MAX: 824 *ap->a_retval = BFS_FILENAME_MAXLEN; 825 break; 826 case _PC_CHOWN_RESTRICTED: 827 *ap->a_retval = 1; 828 break; 829 case _PC_NO_TRUNC: 830 *ap->a_retval = 0; 831 break; 832 case _PC_SYNC_IO: 833 *ap->a_retval = 1; 834 break; 835 case _PC_FILESIZEBITS: 836 *ap->a_retval = 32; 837 break; 838 default: 839 err = EINVAL; 840 break; 841 } 842 843 return err; 844 } 845 846 int 847 sysvbfs_fsync(void *v) 848 { 849 struct vop_fsync_args /* { 850 struct vnode *a_vp; 851 kauth_cred_t a_cred; 852 int a_flags; 853 off_t offlo; 854 off_t offhi; 855 } */ *ap = v; 856 struct vnode *vp = ap->a_vp; 857 int error, wait; 858 859 if (ap->a_flags & FSYNC_CACHE) { 860 return EOPNOTSUPP; 861 } 862 863 wait = (ap->a_flags & FSYNC_WAIT) != 0; 864 error = vflushbuf(vp, wait); 865 if (error == 0 && (ap->a_flags & FSYNC_DATAONLY) == 0) 866 error = sysvbfs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0); 867 868 return error; 869 } 870 871 int 872 sysvbfs_update(struct vnode *vp, const struct timespec *acc, 873 const struct timespec *mod, int flags) 874 { 875 struct sysvbfs_node *bnode = vp->v_data; 876 struct bfs_fileattr attr; 877 878 DPRINTF("%s:\n", __func__); 879 memset(&attr, 0xff, sizeof attr); /* Set VNOVAL all */ 880 if (bnode->update_atime) { 881 attr.atime = acc ? acc->tv_sec : time_second; 882 bnode->update_atime = false; 883 } 884 if (bnode->update_ctime) { 885 attr.ctime = time_second; 886 bnode->update_ctime = false; 887 } 888 if (bnode->update_mtime) { 889 attr.mtime = mod ? mod->tv_sec : time_second; 890 bnode->update_mtime = false; 891 } 892 bfs_inode_set_attr(bnode->bmp->bfs, bnode->inode, &attr); 893 894 return 0; 895 } 896
Indexes created Mon Sep 29 21:09:56 GMT 2025