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