node.c revision 1.38
1 /* $NetBSD: node.c,v 1.38 2007/08/23 15:19:40 pooka Exp $ */ 2 3 /* 4 * Copyright (c) 2006 Antti Kantee. All Rights Reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 16 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 18 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 #ifndef lint 30 __RCSID("$NetBSD: node.c,v 1.38 2007/08/23 15:19:40 pooka Exp $"); 31 #endif /* !lint */ 32 33 #include <assert.h> 34 #include <errno.h> 35 #include <stdio.h> 36 #include <stdlib.h> 37 38 #include "psshfs.h" 39 #include "sftp_proto.h" 40 41 int 42 psshfs_node_lookup(struct puffs_cc *pcc, void *opc, struct puffs_newinfo *pni, 43 const struct puffs_cn *pcn) 44 { 45 struct puffs_usermount *pu = puffs_cc_getusermount(pcc); 46 struct psshfs_ctx *pctx = puffs_getspecific(pu); 47 struct puffs_node *pn_dir = opc; 48 struct psshfs_node *psn, *psn_dir = pn_dir->pn_data; 49 struct puffs_node *pn; 50 struct psshfs_dir *pd; 51 struct vattr va; 52 int rv; 53 54 if (PCNISDOTDOT(pcn)) { 55 psn = psn_dir->parent->pn_data; 56 psn->stat &= ~PSN_RECLAIMED; 57 58 puffs_newinfo_setcookie(pni, psn_dir->parent); 59 puffs_newinfo_setvtype(pni, VDIR); 60 return 0; 61 } 62 63 rv = sftp_readdir(pcc, pctx, pn_dir); 64 if (rv) { 65 if (rv != EPERM) 66 return rv; 67 68 /* 69 * Can't read the directory. We still might be 70 * able to find the node with getattr in -r+x dirs 71 */ 72 rv = getpathattr(pcc, PCNPATH(pcn), &va); 73 if (rv) 74 return rv; 75 76 /* guess */ 77 if (va.va_type == VDIR) 78 va.va_nlink = 2; 79 else 80 va.va_nlink = 1; 81 82 pn = allocnode(pu, pn_dir, pcn->pcn_name, &va); 83 psn = pn->pn_data; 84 psn->attrread = time(NULL); 85 } else { 86 pd = lookup(psn_dir->dir, psn_dir->dentnext, pcn->pcn_name); 87 if (!pd) { 88 return ENOENT; 89 } 90 91 if (pd->entry) 92 pn = pd->entry; 93 else 94 pn = makenode(pu, pn_dir, pd, &pd->va); 95 psn = pn->pn_data; 96 } 97 98 psn->stat &= ~PSN_RECLAIMED; 99 100 puffs_newinfo_setcookie(pni, pn); 101 puffs_newinfo_setvtype(pni, pn->pn_va.va_type); 102 puffs_newinfo_setsize(pni, pn->pn_va.va_size); 103 104 return 0; 105 } 106 107 int 108 psshfs_node_getattr(struct puffs_cc *pcc, void *opc, struct vattr *vap, 109 const struct puffs_cred *pcr, const struct puffs_cid *pcid) 110 { 111 struct puffs_node *pn = opc; 112 int rv; 113 114 rv = getnodeattr(pcc, pn); 115 if (rv) 116 return rv; 117 118 memcpy(vap, &pn->pn_va, sizeof(struct vattr)); 119 120 return 0; 121 } 122 123 int 124 psshfs_node_setattr(struct puffs_cc *pcc, void *opc, 125 const struct vattr *va, const struct puffs_cred *pcr, 126 const struct puffs_cid *pcid) 127 { 128 PSSHFSAUTOVAR(pcc); 129 struct vattr kludgeva; 130 struct puffs_node *pn = opc; 131 132 psbuf_req_str(pb, SSH_FXP_SETSTAT, reqid, PNPATH(pn)); 133 134 memcpy(&kludgeva, va, sizeof(struct vattr)); 135 136 /* XXX: kludge due to openssh server implementation */ 137 if (va->va_atime.tv_sec != PUFFS_VNOVAL 138 && va->va_mtime.tv_sec == PUFFS_VNOVAL) { 139 if (pn->pn_va.va_mtime.tv_sec != PUFFS_VNOVAL) 140 kludgeva.va_mtime.tv_sec = pn->pn_va.va_mtime.tv_sec; 141 else 142 kludgeva.va_mtime.tv_sec = va->va_atime.tv_sec; 143 } 144 if (va->va_mtime.tv_sec != PUFFS_VNOVAL 145 && va->va_atime.tv_sec == PUFFS_VNOVAL) { 146 if (pn->pn_va.va_atime.tv_sec != PUFFS_VNOVAL) 147 kludgeva.va_atime.tv_sec = pn->pn_va.va_atime.tv_sec; 148 else 149 kludgeva.va_atime.tv_sec = va->va_mtime.tv_sec; 150 } 151 152 psbuf_put_vattr(pb, &kludgeva); 153 GETRESPONSE(pb); 154 155 rv = psbuf_expect_status(pb); 156 if (rv == 0) 157 puffs_setvattr(&pn->pn_va, &kludgeva); 158 159 out: 160 PSSHFSRETURN(rv); 161 } 162 163 int 164 psshfs_node_create(struct puffs_cc *pcc, void *opc, struct puffs_newinfo *pni, 165 const struct puffs_cn *pcn, const struct vattr *va) 166 { 167 PSSHFSAUTOVAR(pcc); 168 struct puffs_usermount *pu = puffs_cc_getusermount(pcc); 169 struct puffs_node *pn = opc; 170 struct puffs_node *pn_new; 171 char *fhand = NULL; 172 uint32_t fhandlen; 173 174 pn_new = allocnode(pu, pn, pcn->pcn_name, va); 175 if (!pn_new) { 176 rv = ENOMEM; 177 goto out; 178 } 179 180 psbuf_req_str(pb, SSH_FXP_OPEN, reqid, PCNPATH(pcn)); 181 psbuf_put_4(pb, SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_TRUNC); 182 psbuf_put_vattr(pb, va); 183 GETRESPONSE(pb); 184 185 rv = psbuf_expect_handle(pb, &fhand, &fhandlen); 186 if (rv == 0) 187 puffs_newinfo_setcookie(pni, pn_new); 188 else 189 goto out; 190 191 reqid = NEXTREQ(pctx); 192 psbuf_recycleout(pb); 193 psbuf_req_data(pb, SSH_FXP_CLOSE, reqid, fhand, fhandlen); 194 JUSTSEND(pb); 195 free(fhand); 196 return 0; 197 198 out: 199 free(fhand); 200 PSSHFSRETURN(rv); 201 } 202 203 int 204 psshfs_node_mmap(struct puffs_cc* pcc, void *opc, vm_prot_t prot, 205 const struct puffs_cred *pcr, const struct puffs_cid *pcid) 206 { 207 struct puffs_node *pn = opc; 208 struct psshfs_node *psn = pn->pn_data; 209 210 if (prot & (VM_PROT_READ | VM_PROT_EXECUTE)) 211 psn->stat |= PSN_READMAP; 212 if (prot & VM_PROT_WRITE) 213 psn->stat |= PSN_WRITEMAP; 214 215 return 0; 216 } 217 218 int 219 psshfs_node_open(struct puffs_cc *pcc, void *opc, int mode, 220 const struct puffs_cred *pcr, const struct puffs_cid *pcid) 221 { 222 PSSHFSAUTOVAR(pcc); 223 struct vattr va; 224 struct puffs_node *pn = opc; 225 struct psshfs_node *psn = pn->pn_data; 226 227 if (pn->pn_va.va_type == VDIR) 228 goto out; 229 230 puffs_setback(pcc, PUFFS_SETBACK_INACT_N1); 231 puffs_vattr_null(&va); 232 if (mode & FREAD && psn->fhand_r == NULL) { 233 psbuf_req_str(pb, SSH_FXP_OPEN, reqid, PNPATH(pn)); 234 psbuf_put_4(pb, SSH_FXF_READ); 235 psbuf_put_vattr(pb, &va); 236 GETRESPONSE(pb); 237 238 rv = psbuf_expect_handle(pb, &psn->fhand_r, &psn->fhand_r_len); 239 if (rv) 240 goto out; 241 psbuf_recycleout(pb); 242 } 243 if (mode & FWRITE && psn->fhand_w == NULL) { 244 psbuf_req_str(pb, SSH_FXP_OPEN, reqid, PNPATH(pn)); 245 psbuf_put_4(pb, SSH_FXF_WRITE); 246 psbuf_put_vattr(pb, &va); 247 GETRESPONSE(pb); 248 249 rv = psbuf_expect_handle(pb, &psn->fhand_w, &psn->fhand_w_len); 250 if (rv) 251 goto out; 252 } 253 254 out: 255 if (rv == 0) 256 psn->opencount++; 257 258 PSSHFSRETURN(rv); 259 } 260 261 static void 262 closehandles(struct puffs_cc *pcc, struct psshfs_node *psn) 263 { 264 struct puffs_usermount *pu = puffs_cc_getusermount(pcc); 265 struct psshfs_ctx *pctx = puffs_cc_getspecific(pcc); 266 struct puffs_framebuf *pb1, *pb2; 267 uint32_t reqid = NEXTREQ(pctx); 268 int rv; /* macro magic */ 269 270 if ((psn->stat & PSN_READMAP) == 0 && psn->fhand_r) { 271 pb1 = psbuf_makeout(); 272 psbuf_req_data(pb1, SSH_FXP_CLOSE, reqid, 273 psn->fhand_r, psn->fhand_r_len); 274 JUSTSEND(pb1); 275 free(psn->fhand_r); 276 psn->fhand_r = NULL; 277 } 278 if ((psn->stat & PSN_WRITEMAP) == 0 && psn->fhand_w) { 279 pb2 = psbuf_makeout(); 280 psbuf_req_data(pb2, SSH_FXP_CLOSE, reqid, 281 psn->fhand_w, psn->fhand_w_len); 282 JUSTSEND(pb2); 283 free(psn->fhand_w); 284 psn->fhand_w = NULL; 285 } 286 287 out: 288 return; 289 } 290 291 int 292 psshfs_node_close(struct puffs_cc *pcc, void *opc, int flags, 293 const struct puffs_cred *pcr, const struct puffs_cid *pcid) 294 { 295 struct puffs_node *pn = opc; 296 struct psshfs_node *psn = pn->pn_data; 297 298 assert(psn->opencount != 0); 299 if (--psn->opencount == 0) 300 closehandles(pcc, psn); 301 302 return 0; 303 } 304 305 int 306 psshfs_node_inactive(struct puffs_cc *pcc, void *opc, 307 const struct puffs_cid *pcid) 308 { 309 struct puffs_node *pn = opc; 310 struct psshfs_node *psn = pn->pn_data; 311 312 assert(psn->opencount == 0); 313 psn->stat &= ~(PSN_READMAP | PSN_WRITEMAP); 314 closehandles(pcc, psn); 315 316 return 0; 317 } 318 319 /* 320 * XXXX: I'm not really sure I'll export this symbol eventually, 321 * so fix this a bit in the future. 322 */ 323 void puffs_goto(struct puffs_cc *); 324 325 int 326 psshfs_node_readdir(struct puffs_cc *pcc, void *opc, struct dirent *dent, 327 off_t *readoff, size_t *reslen, const struct puffs_cred *pcr, 328 int *eofflag, off_t *cookies, size_t *ncookies) 329 { 330 struct psshfs_ctx *pctx = puffs_cc_getspecific(pcc); 331 struct puffs_node *pn = opc; 332 struct psshfs_node *psn = pn->pn_data; 333 struct psshfs_dir *pd; 334 int i, rv, set_readdir; 335 336 if (psn->stat & PSN_READDIR) { 337 struct psshfs_dirwait dw; 338 339 set_readdir = 0; 340 dw.dw_cc = pcc; 341 LIST_INSERT_HEAD(&psn->dw, &dw, dw_entries); 342 puffs_cc_yield(pcc); 343 LIST_REMOVE(&dw, dw_entries); 344 } else { 345 psn->stat |= PSN_READDIR; 346 set_readdir = 1; 347 } 348 349 *ncookies = 0; 350 rv = sftp_readdir(pcc, pctx, pn); 351 if (rv) 352 goto out; 353 354 /* find next dirent */ 355 for (i = *readoff;;i++) { 356 if (i >= psn->dentnext) 357 goto out; 358 pd = &psn->dir[i]; 359 if (pd->valid) 360 break; 361 } 362 363 for (;;) { 364 *readoff = i; 365 if (!puffs_nextdent(&dent, pd->entryname, 366 pd->va.va_fileid, puffs_vtype2dt(pd->va.va_type), reslen)) { 367 rv = 0; 368 goto out; 369 } 370 371 /* find next entry, store possible nfs key */ 372 do { 373 if (++i >= psn->dentnext) 374 goto out; 375 pd = &psn->dir[i]; 376 } while (pd->valid == 0); 377 PUFFS_STORE_DCOOKIE(cookies, ncookies, (off_t)i); 378 } 379 380 out: 381 if (rv == 0) { 382 if (i >= psn->dentnext) 383 *eofflag = 1; 384 385 *readoff = i; 386 } 387 388 if (set_readdir) { 389 struct psshfs_dirwait *dw; 390 391 while ((dw = LIST_FIRST(&psn->dw)) != NULL) 392 puffs_goto(dw->dw_cc); 393 394 psn->stat &= ~PSN_READDIR; 395 } 396 397 return rv; 398 } 399 400 int 401 psshfs_node_read(struct puffs_cc *pcc, void *opc, uint8_t *buf, 402 off_t offset, size_t *resid, const struct puffs_cred *pcr, 403 int ioflag) 404 { 405 PSSHFSAUTOVAR(pcc); 406 struct puffs_node *pn = opc; 407 struct psshfs_node *psn = pn->pn_data; 408 uint32_t readlen; 409 410 if (pn->pn_va.va_type == VDIR) { 411 rv = EISDIR; 412 goto out; 413 } 414 415 readlen = *resid; 416 psbuf_req_data(pb, SSH_FXP_READ, reqid, psn->fhand_r, psn->fhand_r_len); 417 psbuf_put_8(pb, offset); 418 psbuf_put_4(pb, readlen); 419 GETRESPONSE(pb); 420 421 rv = psbuf_do_data(pb, buf, &readlen); 422 if (rv == 0) 423 *resid -= readlen; 424 425 out: 426 PSSHFSRETURN(rv); 427 } 428 429 /* XXX: we should getattr for size */ 430 int 431 psshfs_node_write(struct puffs_cc *pcc, void *opc, uint8_t *buf, 432 off_t offset, size_t *resid, const struct puffs_cred *cred, 433 int ioflag) 434 { 435 PSSHFSAUTOVAR(pcc); 436 struct puffs_node *pn = opc; 437 struct psshfs_node *psn = pn->pn_data; 438 uint32_t writelen; 439 440 if (pn->pn_va.va_type == VDIR) { 441 rv = EISDIR; 442 goto out; 443 } 444 445 writelen = *resid; 446 psbuf_req_data(pb, SSH_FXP_WRITE, reqid, psn->fhand_w,psn->fhand_w_len); 447 psbuf_put_8(pb, offset); 448 psbuf_put_data(pb, buf, writelen); 449 GETRESPONSE(pb); 450 451 rv = psbuf_expect_status(pb); 452 if (rv == 0) 453 *resid = 0; 454 455 if (pn->pn_va.va_size < offset + writelen) 456 pn->pn_va.va_size = offset + writelen; 457 458 out: 459 PSSHFSRETURN(rv); 460 } 461 462 int 463 psshfs_node_readlink(struct puffs_cc *pcc, void *opc, 464 const struct puffs_cred *cred, char *linkvalue, size_t *linklen) 465 { 466 PSSHFSAUTOVAR(pcc); 467 struct puffs_node *pn = opc; 468 char *linktmp = NULL; 469 uint32_t count; 470 471 if (pctx->protover < 3) { 472 rv = EOPNOTSUPP; 473 goto out; 474 } 475 476 psbuf_req_str(pb, SSH_FXP_READLINK, reqid, PNPATH(pn)); 477 GETRESPONSE(pb); 478 479 rv = psbuf_expect_name(pb, &count); 480 if (rv) 481 goto out; 482 if (count != 1) { 483 rv = EPROTO; 484 goto out; 485 } 486 487 rv = psbuf_get_str(pb, &linktmp, (uint32_t *)linklen); 488 if (rv) 489 goto out; 490 (void) memcpy(linkvalue, linktmp, *linklen); 491 492 out: 493 free(linktmp); 494 PSSHFSRETURN(rv); 495 } 496 497 static int 498 doremove(struct puffs_cc *pcc, struct puffs_node *pn_dir, 499 struct puffs_node *pn, const char *name) 500 { 501 PSSHFSAUTOVAR(pcc); 502 int op; 503 504 if (pn->pn_va.va_type == VDIR) 505 op = SSH_FXP_RMDIR; 506 else 507 op = SSH_FXP_REMOVE; 508 509 psbuf_req_str(pb, op, reqid, PNPATH(pn)); 510 GETRESPONSE(pb); 511 512 rv = psbuf_expect_status(pb); 513 if (rv == 0) 514 nukenode(pn, name, 0); 515 516 out: 517 PSSHFSRETURN(rv); 518 } 519 520 int 521 psshfs_node_remove(struct puffs_cc *pcc, void *opc, void *targ, 522 const struct puffs_cn *pcn) 523 { 524 struct puffs_node *pn_targ = targ; 525 int rv; 526 527 assert(pn_targ->pn_va.va_type != VDIR); 528 529 rv = doremove(pcc, opc, targ, pcn->pcn_name); 530 if (rv == 0) 531 puffs_setback(pcc, PUFFS_SETBACK_NOREF_N2); 532 533 return rv; 534 } 535 536 int 537 psshfs_node_rmdir(struct puffs_cc *pcc, void *opc, void *targ, 538 const struct puffs_cn *pcn) 539 { 540 struct puffs_node *pn_targ = targ; 541 int rv; 542 543 assert(pn_targ->pn_va.va_type == VDIR); 544 545 rv = doremove(pcc, opc, targ, pcn->pcn_name); 546 if (rv == 0) 547 puffs_setback(pcc, PUFFS_SETBACK_NOREF_N2); 548 549 return rv; 550 } 551 552 int 553 psshfs_node_mkdir(struct puffs_cc *pcc, void *opc, struct puffs_newinfo *pni, 554 const struct puffs_cn *pcn, const struct vattr *va) 555 { 556 PSSHFSAUTOVAR(pcc); 557 struct puffs_usermount *pu = puffs_cc_getusermount(pcc); 558 struct puffs_node *pn = opc; 559 struct puffs_node *pn_new; 560 561 pn_new = allocnode(pu, pn, pcn->pcn_name, va); 562 if (!pn_new) { 563 rv = ENOMEM; 564 goto out; 565 } 566 567 psbuf_req_str(pb, SSH_FXP_MKDIR, reqid, PCNPATH(pcn)); 568 psbuf_put_vattr(pb, va); 569 GETRESPONSE(pb); 570 571 rv = psbuf_expect_status(pb); 572 573 if (rv == 0) 574 puffs_newinfo_setcookie(pni, pn_new); 575 else 576 nukenode(pn_new, pcn->pcn_name, 1); 577 578 out: 579 PSSHFSRETURN(rv); 580 } 581 582 int 583 psshfs_node_symlink(struct puffs_cc *pcc, void *opc, struct puffs_newinfo *pni, 584 const struct puffs_cn *pcn, const struct vattr *va, 585 const char *link_target) 586 { 587 PSSHFSAUTOVAR(pcc); 588 struct puffs_usermount *pu = puffs_cc_getusermount(pcc); 589 struct puffs_node *pn = opc; 590 struct puffs_node *pn_new; 591 592 if (pctx->protover < 3) { 593 rv = EOPNOTSUPP; 594 goto out; 595 } 596 597 pn_new = allocnode(pu, pn, pcn->pcn_name, va); 598 if (!pn_new) { 599 rv = ENOMEM; 600 goto out; 601 } 602 603 /* 604 * XXX: ietf says: source, target. openssh says: ietf who? 605 * Let's go with openssh and build quirk tables later if we care 606 */ 607 psbuf_req_str(pb, SSH_FXP_SYMLINK, reqid, link_target); 608 psbuf_put_str(pb, PCNPATH(pcn)); 609 GETRESPONSE(pb); 610 611 rv = psbuf_expect_status(pb); 612 if (rv == 0) 613 puffs_newinfo_setcookie(pni, pn_new); 614 else 615 nukenode(pn_new, pcn->pcn_name, 1); 616 617 out: 618 PSSHFSRETURN(rv); 619 } 620 621 int 622 psshfs_node_rename(struct puffs_cc *pcc, void *opc, void *src, 623 const struct puffs_cn *pcn_src, void *targ_dir, void *targ, 624 const struct puffs_cn *pcn_targ) 625 { 626 PSSHFSAUTOVAR(pcc); 627 struct puffs_node *pn_sf = src; 628 struct puffs_node *pn_td = targ_dir, *pn_tf = targ; 629 struct psshfs_node *psn_targdir = pn_td->pn_data; 630 631 if (pctx->protover < 2) { 632 rv = EOPNOTSUPP; 633 goto out; 634 } 635 636 if (pn_tf) { 637 rv = doremove(pcc, targ_dir, pn_tf, pcn_targ->pcn_name); 638 if (rv) 639 goto out; 640 } 641 642 psbuf_req_str(pb, SSH_FXP_RENAME, reqid, PCNPATH(pcn_src)); 643 psbuf_put_str(pb, PCNPATH(pcn_targ)); 644 GETRESPONSE(pb); 645 646 rv = psbuf_expect_status(pb); 647 if (rv == 0) { 648 struct psshfs_dir *pd; 649 650 /* 651 * XXX: interfaces didn't quite work with rename.. 652 * the song remains the same. go figure .. ;) 653 */ 654 nukenode(pn_sf, pcn_src->pcn_name, 0); 655 pd = direnter(pn_td, pcn_targ->pcn_name); 656 pd->entry = pn_sf; 657 puffs_setvattr(&pd->va, &pn_sf->pn_va); 658 659 if (opc != targ_dir) { 660 psn_targdir->childcount++; 661 if (pn_sf->pn_va.va_type == VDIR) 662 pn_td->pn_va.va_nlink++; 663 } 664 } 665 666 out: 667 PSSHFSRETURN(rv); 668 } 669 670 /* 671 * So this file system happened to be written in such a way that 672 * lookup for ".." is hard if we lose the in-memory node. We'd 673 * need to recreate the entire directory structure from the root 674 * node up to the ".." node we're looking up. 675 * 676 * And since our entire fs structure is purely fictional (i.e. it's 677 * only in-memory, not fetchable from the server), the easiest way 678 * to deal with it is to not allow nodes with children to be 679 * reclaimed. 680 * 681 * If a node with children is being attempted to be reclaimed, we 682 * just mark it "reclaimed" but leave it as is until all its children 683 * have been reclaimed. If a lookup for that node is done meanwhile, 684 * it will be found by lookup() and we just remove the "reclaimed" 685 * bit. 686 */ 687 int 688 psshfs_node_reclaim(struct puffs_cc *pcc, void *opc, 689 const struct puffs_cid *pcid) 690 { 691 struct puffs_usermount *pu = puffs_cc_getusermount(pcc); 692 struct puffs_node *pn = opc, *pn_next, *pn_root; 693 struct psshfs_node *psn = pn->pn_data; 694 695 /* 696 * don't reclaim if we have file handle issued, otherwise 697 * we can't do fhtonode 698 */ 699 if (psn->stat & PSN_HASFH) 700 return 0; 701 702 psn->stat |= PSN_RECLAIMED; 703 pn_root = puffs_getroot(pu); 704 for (; pn != pn_root; pn = pn_next) { 705 psn = pn->pn_data; 706 if ((psn->stat & PSN_RECLAIMED) == 0 || psn->childcount != 0) 707 break; 708 709 pn_next = psn->parent; 710 doreclaim(pn); 711 } 712 713 return 0; 714 } 715
Indexes created Thu Sep 25 08:09:54 GMT 2025