1 /* $NetBSD: node.c,v 1.21 2009/01/18 10:10:47 lukem Exp $ */ 2 3 /* 4 * Copyright (c) 2007 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.21 2009/01/18 10:10:47 lukem Exp $"); 31 #endif /* !lint */ 32 33 #include <assert.h> 34 #include <errno.h> 35 #include <puffs.h> 36 #include <stdio.h> 37 #include <stdlib.h> 38 39 #include "ninepuffs.h" 40 #include "nineproto.h" 41 42 static void * 43 nodecmp(struct puffs_usermount *pu, struct puffs_node *pn, void *arg) 44 { 45 struct vattr *vap = &pn->pn_va; 46 struct qid9p *qid = arg; 47 48 if (vap->va_fileid == qid->qidpath && vap->va_gen == qid->qidvers) 49 return pn; 50 51 return NULL; 52 } 53 54 static int 55 do_getattr(struct puffs_usermount *pu, struct puffs_node *pn, struct vattr *vap) 56 { 57 AUTOVAR(pu); 58 struct p9pnode *p9n = pn->pn_data; 59 60 p9pbuf_put_1(pb, P9PROTO_T_STAT); 61 p9pbuf_put_2(pb, tag); 62 p9pbuf_put_4(pb, p9n->fid_base); 63 GETRESPONSE(pb); 64 65 rv = proto_expect_stat(pb, vap); 66 67 out: 68 RETURN(rv); 69 } 70 71 int 72 puffs9p_node_getattr(struct puffs_usermount *pu, void *opc, struct vattr *vap, 73 const struct puffs_cred *pcr) 74 { 75 struct puffs_node *pn = opc; 76 int rv; 77 78 rv = do_getattr(pu, pn, &pn->pn_va); 79 if (rv == 0) 80 memcpy(vap, &pn->pn_va, sizeof(struct vattr)); 81 return rv; 82 } 83 84 int 85 puffs9p_node_lookup(struct puffs_usermount *pu, void *opc, struct puffs_newinfo *pni, 86 const struct puffs_cn *pcn) 87 { 88 AUTOVAR(pu); 89 struct vattr va; 90 struct puffs_node *pn, *pn_dir = opc; 91 struct p9pnode *p9n_dir = pn_dir->pn_data; 92 p9ptag_t tfid = NEXTFID(p9p); 93 struct qid9p newqid; 94 uint16_t nqid; 95 96 p9pbuf_put_1(pb, P9PROTO_T_WALK); 97 p9pbuf_put_2(pb, tag); 98 p9pbuf_put_4(pb, p9n_dir->fid_base); 99 p9pbuf_put_4(pb, tfid); 100 p9pbuf_put_2(pb, 1); 101 p9pbuf_put_str(pb, pcn->pcn_name); 102 GETRESPONSE(pb); 103 104 rv = proto_expect_walk_nqids(pb, &nqid); 105 if (rv) { 106 rv = ENOENT; 107 goto out; 108 } 109 if (nqid != 1) { 110 rv = EPROTO; 111 goto out; 112 } 113 if ((rv = proto_getqid(pb, &newqid))) 114 goto out; 115 116 /* we get the parent vers in walk(?) compensate */ 117 p9pbuf_recycleout(pb); 118 tag = NEXTTAG(p9p); 119 p9pbuf_put_1(pb, P9PROTO_T_STAT); 120 p9pbuf_put_2(pb, tag); 121 p9pbuf_put_4(pb, tfid); 122 GETRESPONSE(pb); 123 if ((rv = proto_expect_stat(pb, &va)) != 0) { 124 proto_cc_clunkfid(pu, tfid, 0); 125 rv = ENOENT; 126 goto out; 127 } 128 if (newqid.qidpath != va.va_fileid) { 129 proto_cc_clunkfid(pu, tfid, 0); 130 rv = EPROTO; 131 goto out; 132 } 133 newqid.qidvers = va.va_gen; 134 135 pn = puffs_pn_nodewalk(pu, nodecmp, &newqid); 136 if (pn == NULL) 137 pn = newp9pnode_qid(pu, &newqid, tfid); 138 else 139 proto_cc_clunkfid(pu, tfid, 0); 140 /* assert pn */ 141 memcpy(&pn->pn_va, &va, sizeof(va)); 142 143 puffs_newinfo_setcookie(pni, pn); 144 puffs_newinfo_setvtype(pni, pn->pn_va.va_type); 145 puffs_newinfo_setsize(pni, pn->pn_va.va_size); 146 puffs_newinfo_setrdev(pni, pn->pn_va.va_rdev); 147 148 out: 149 RETURN(rv); 150 } 151 152 /* 153 * Problem is that 9P doesn't allow seeking into a directory. So we 154 * maintain a list of active fids for any given directory. They 155 * start living at the first read and exist either until the directory 156 * is closed or until they reach the end. 157 */ 158 int 159 puffs9p_node_readdir(struct puffs_usermount *pu, void *opc, struct dirent *dent, 160 off_t *readoff, size_t *reslen, const struct puffs_cred *pcr, 161 int *eofflag, off_t *cookies, size_t *ncookies) 162 { 163 AUTOVAR(pu); 164 struct puffs_node *pn = opc; 165 struct p9pnode *p9n = pn->pn_data; 166 struct vattr va; 167 struct dirfid *dfp; 168 char *name; 169 uint32_t count; 170 uint16_t statsize; 171 172 rv = getdfwithoffset(pu, p9n, *readoff, &dfp); 173 if (rv) 174 goto out; 175 176 tag = NEXTTAG(p9p); 177 p9pbuf_put_1(pb, P9PROTO_T_READ); 178 p9pbuf_put_2(pb, tag); 179 p9pbuf_put_4(pb, dfp->fid); 180 p9pbuf_put_8(pb, *readoff); 181 p9pbuf_put_4(pb, *reslen); /* XXX */ 182 GETRESPONSE(pb); 183 184 p9pbuf_get_4(pb, &count); 185 186 /* 187 * if count is 0, assume we at end-of-dir. dfp is no longer 188 * useful, so nuke it 189 */ 190 if (count == 0) { 191 *eofflag = 1; 192 releasedf(pu, dfp); 193 goto out; 194 } 195 196 while (count > 0) { 197 if ((rv = proto_getstat(pb, &va, &name, &statsize))) { 198 /* 199 * If there was an error, it's unlikely we'll be 200 * coming back, so just nuke the dfp. If we do 201 * come back for some strange reason, we'll just 202 * regen it. 203 */ 204 releasedf(pu, dfp); 205 goto out; 206 } 207 208 puffs_nextdent(&dent, name, va.va_fileid, 209 puffs_vtype2dt(va.va_type), reslen); 210 211 count -= statsize; 212 *readoff += statsize; 213 dfp->seekoff += statsize; 214 free(name); 215 } 216 217 storedf(p9n, dfp); 218 219 out: 220 RETURN(rv); 221 } 222 223 int 224 puffs9p_node_setattr(struct puffs_usermount *pu, void *opc, 225 const struct vattr *va, const struct puffs_cred *pcr) 226 { 227 AUTOVAR(pu); 228 struct puffs_node *pn = opc; 229 struct p9pnode *p9n = pn->pn_data; 230 231 p9pbuf_put_1(pb, P9PROTO_T_WSTAT); 232 p9pbuf_put_2(pb, tag); 233 p9pbuf_put_4(pb, p9n->fid_base); 234 proto_make_stat(pb, va, NULL, pn->pn_va.va_type); 235 GETRESPONSE(pb); 236 237 if (p9pbuf_get_type(pb) != P9PROTO_R_WSTAT) 238 rv = EPROTO; 239 240 out: 241 RETURN(rv); 242 } 243 244 /* 245 * Ok, time to get clever. There are two possible cases: we are 246 * opening a file or we are opening a directory. 247 * 248 * If it's a directory, don't bother opening it here, but rather 249 * wait until readdir, since it's probable we need to be able to 250 * open a directory there in any case. 251 * 252 * If it's a regular file, open it here with whatever credentials 253 * we happen to have. Let the upper layers of the kernel worry 254 * about permission control. 255 */ 256 int 257 puffs9p_node_open(struct puffs_usermount *pu, void *opc, int mode, 258 const struct puffs_cred *pcr) 259 { 260 struct puffs_cc *pcc = puffs_cc_getcc(pu); 261 struct puffs9p *p9p = puffs_getspecific(pu); 262 struct puffs_node *pn = opc; 263 struct p9pnode *p9n = pn->pn_data; 264 p9pfid_t nfid; 265 int error = 0; 266 267 puffs_setback(pcc, PUFFS_SETBACK_INACT_N1); 268 if (pn->pn_va.va_type != VDIR) { 269 if (mode & FREAD && p9n->fid_read == P9P_INVALFID) { 270 nfid = NEXTFID(p9p); 271 error = proto_cc_open(pu, p9n->fid_base, nfid, 272 P9PROTO_OMODE_READ); 273 if (error) 274 return error; 275 p9n->fid_read = nfid; 276 } 277 if (mode & FWRITE && p9n->fid_write == P9P_INVALFID) { 278 nfid = NEXTFID(p9p); 279 error = proto_cc_open(pu, p9n->fid_base, nfid, 280 P9PROTO_OMODE_WRITE); 281 if (error) 282 return error; 283 p9n->fid_write = nfid; 284 } 285 } 286 287 return 0; 288 } 289 290 int 291 puffs9p_node_inactive(struct puffs_usermount *pu, void *opc) 292 { 293 struct puffs_node *pn = opc; 294 struct p9pnode *p9n = pn->pn_data; 295 296 if (pn->pn_va.va_type == VDIR) { 297 nukealldf(pu, p9n); 298 } else { 299 if (p9n->fid_read != P9P_INVALFID) { 300 proto_cc_clunkfid(pu, p9n->fid_read, 0); 301 p9n->fid_read = P9P_INVALFID; 302 } 303 if (p9n->fid_write != P9P_INVALFID) { 304 proto_cc_clunkfid(pu, p9n->fid_write, 0); 305 p9n->fid_write = P9P_INVALFID; 306 } 307 } 308 309 return 0; 310 } 311 312 int 313 puffs9p_node_read(struct puffs_usermount *pu, void *opc, uint8_t *buf, 314 off_t offset, size_t *resid, const struct puffs_cred *pcr, 315 int ioflag) 316 { 317 AUTOVAR(pu); 318 struct puffs_node *pn = opc; 319 struct p9pnode *p9n = pn->pn_data; 320 uint32_t count; 321 size_t nread; 322 323 nread = 0; 324 while (*resid > 0 && (uint64_t)(offset+nread) < pn->pn_va.va_size) { 325 p9pbuf_put_1(pb, P9PROTO_T_READ); 326 p9pbuf_put_2(pb, tag); 327 p9pbuf_put_4(pb, p9n->fid_read); 328 p9pbuf_put_8(pb, offset+nread); 329 p9pbuf_put_4(pb, MIN((uint32_t)*resid,p9p->maxreq-24)); 330 GETRESPONSE(pb); 331 332 if (p9pbuf_get_type(pb) != P9PROTO_R_READ) { 333 rv = EPROTO; 334 break; 335 } 336 337 p9pbuf_get_4(pb, &count); 338 if ((rv = p9pbuf_read_data(pb, buf + nread, count))) 339 break; 340 341 if (count == 0) 342 break; 343 344 *resid -= count; 345 nread += count; 346 347 p9pbuf_recycleout(pb); 348 } 349 350 out: 351 RETURN(rv); 352 } 353 354 int 355 puffs9p_node_write(struct puffs_usermount *pu, void *opc, uint8_t *buf, 356 off_t offset, size_t *resid, const struct puffs_cred *cred, 357 int ioflag) 358 { 359 AUTOVAR(pu); 360 struct puffs_node *pn = opc; 361 struct p9pnode *p9n = pn->pn_data; 362 uint32_t chunk, count; 363 size_t nwrite; 364 365 if (ioflag & PUFFS_IO_APPEND) 366 offset = pn->pn_va.va_size; 367 368 nwrite = 0; 369 while (*resid > 0) { 370 chunk = MIN(*resid, p9p->maxreq-32); 371 372 p9pbuf_put_1(pb, P9PROTO_T_WRITE); 373 p9pbuf_put_2(pb, tag); 374 p9pbuf_put_4(pb, p9n->fid_write); 375 p9pbuf_put_8(pb, offset+nwrite); 376 p9pbuf_put_4(pb, chunk); 377 p9pbuf_write_data(pb, buf+nwrite, chunk); 378 GETRESPONSE(pb); 379 380 if (p9pbuf_get_type(pb) != P9PROTO_R_WRITE) { 381 rv = EPROTO; 382 break; 383 } 384 385 p9pbuf_get_4(pb, &count); 386 *resid -= count; 387 nwrite += count; 388 389 if (count != chunk) { 390 rv = EPROTO; 391 break; 392 } 393 394 p9pbuf_recycleout(pb); 395 } 396 397 out: 398 RETURN(rv); 399 } 400 401 static int 402 nodecreate(struct puffs_usermount *pu, struct puffs_node *pn, 403 struct puffs_newinfo *pni, const char *name, 404 const struct vattr *vap, uint32_t dirbit) 405 { 406 AUTOVAR(pu); 407 struct puffs_node *pn_new; 408 struct p9pnode *p9n = pn->pn_data; 409 p9pfid_t nfid = NEXTFID(p9p); 410 struct qid9p nqid; 411 int tries = 0; 412 413 again: 414 if (++tries > 5) { 415 rv = EPROTO; 416 goto out; 417 } 418 419 rv = proto_cc_dupfid(pu, p9n->fid_base, nfid); 420 if (rv) 421 goto out; 422 423 p9pbuf_put_1(pb, P9PROTO_T_CREATE); 424 p9pbuf_put_2(pb, tag); 425 p9pbuf_put_4(pb, nfid); 426 p9pbuf_put_str(pb, name); 427 p9pbuf_put_4(pb, dirbit | (vap->va_mode & 0777)); 428 p9pbuf_put_1(pb, 0); 429 GETRESPONSE(pb); 430 431 rv = proto_expect_qid(pb, P9PROTO_R_CREATE, &nqid); 432 if (rv) 433 goto out; 434 435 /* 436 * Now, little problem here: create returns an *open* fid. 437 * So, clunk it and walk the parent directory to get a fid 438 * which is not open for I/O yet. 439 */ 440 proto_cc_clunkfid(pu, nfid, 0); 441 nfid = NEXTFID(p9p); 442 443 p9pbuf_recycleout(pb); 444 p9pbuf_put_1(pb, P9PROTO_T_WALK); 445 p9pbuf_put_2(pb, tag); 446 p9pbuf_put_4(pb, p9n->fid_base); 447 p9pbuf_put_4(pb, nfid); 448 p9pbuf_put_2(pb, 1); 449 p9pbuf_put_str(pb, name); 450 GETRESPONSE(pb); 451 452 /* 453 * someone removed it already? try again 454 * note: this is kind of lose/lose 455 */ 456 if (p9pbuf_get_type(pb) != P9PROTO_R_WALK) 457 goto again; 458 459 pn_new = newp9pnode_va(pu, vap, nfid); 460 qid2vattr(&pn_new->pn_va, &nqid); 461 puffs_newinfo_setcookie(pni, pn_new); 462 463 out: 464 RETURN(rv); 465 } 466 467 int 468 puffs9p_node_create(struct puffs_usermount *pu, void *opc, struct puffs_newinfo *pni, 469 const struct puffs_cn *pcn, const struct vattr *va) 470 { 471 472 return nodecreate(pu, opc, pni, pcn->pcn_name, va, 0); 473 } 474 475 int 476 puffs9p_node_mkdir(struct puffs_usermount *pu, void *opc, struct puffs_newinfo *pni, 477 const struct puffs_cn *pcn, const struct vattr *va) 478 { 479 480 return nodecreate(pu, opc, pni, pcn->pcn_name, 481 va, P9PROTO_CPERM_DIR); 482 } 483 484 /* 485 * Need to be a bit clever again: the fid is clunked no matter if 486 * the remove succeeds or not. Re-getting a fid would be way too 487 * difficult in case the remove failed for a valid reason (directory 488 * not empty etcetc.). So walk ourselves another fid to prod the 489 * ice with. 490 */ 491 static int 492 noderemove(struct puffs_usermount *pu, struct puffs_node *pn) 493 { 494 AUTOVAR(pu); 495 struct p9pnode *p9n = pn->pn_data; 496 p9pfid_t testfid = NEXTFID(p9p); 497 498 rv = proto_cc_dupfid(pu, p9n->fid_base, testfid); 499 if (rv) 500 goto out; 501 502 p9pbuf_put_1(pb, P9PROTO_T_REMOVE); 503 p9pbuf_put_2(pb, tag); 504 p9pbuf_put_4(pb, testfid); 505 506 /* 507 * XXX: error handling isn't very robust, but doom is impending 508 * anyway, so just accept we're going belly up and play dead 509 */ 510 GETRESPONSE(pb); 511 512 if (p9pbuf_get_type(pb) != P9PROTO_R_REMOVE) { 513 rv = EPROTO; 514 } else { 515 proto_cc_clunkfid(pu, p9n->fid_base, 0); 516 p9n->fid_base = P9P_INVALFID; 517 puffs_pn_remove(pn); 518 } 519 520 out: 521 if (rv == 0) 522 puffs_setback(pcc, PUFFS_SETBACK_NOREF_N2); 523 524 RETURN(rv); 525 } 526 527 int 528 puffs9p_node_remove(struct puffs_usermount *pu, void *opc, void *targ, 529 const struct puffs_cn *pcn) 530 { 531 struct puffs_node *pn = targ; 532 533 if (pn->pn_va.va_type == VDIR) 534 return EISDIR; 535 536 return noderemove(pu, pn); 537 } 538 539 int 540 puffs9p_node_rmdir(struct puffs_usermount *pu, void *opc, void *targ, 541 const struct puffs_cn *pcn) 542 { 543 struct puffs_node *pn = targ; 544 545 if (pn->pn_va.va_type != VDIR) 546 return ENOTDIR; 547 548 return noderemove(pu, pn); 549 } 550 551 /* 552 * 9P supports renames only for files within a directory 553 * from what I could tell. So just support in-directory renames 554 * for now. 555 */ 556 int 557 puffs9p_node_rename(struct puffs_usermount *pu, void *opc, void *src, 558 const struct puffs_cn *pcn_src, void *targ_dir, void *targ, 559 const struct puffs_cn *pcn_targ) 560 { 561 AUTOVAR(pu); 562 struct puffs_node *pn_src = src; 563 struct p9pnode *p9n_src = pn_src->pn_data; 564 565 if (opc != targ_dir) { 566 rv = EOPNOTSUPP; 567 goto out; 568 } 569 570 /* 9P doesn't allow to overwrite in rename */ 571 if (targ) { 572 struct puffs_node *pn_targ = targ; 573 574 rv = noderemove(pu, pn_targ->pn_data); 575 if (rv) 576 goto out; 577 } 578 579 p9pbuf_put_1(pb, P9PROTO_T_WSTAT); 580 p9pbuf_put_2(pb, tag); 581 p9pbuf_put_4(pb, p9n_src->fid_base); 582 proto_make_stat(pb, NULL, pcn_targ->pcn_name, pn_src->pn_va.va_type); 583 GETRESPONSE(pb); 584 585 if (p9pbuf_get_type(pb) != P9PROTO_R_WSTAT) 586 rv = EPROTO; 587 588 out: 589 RETURN(rv); 590 } 591 592 /* 593 * - "here's one" 594 * - "9P" 595 * ~ "i'm not dead" 596 * - "you're not fooling anyone you know, you'll be stone dead in a minute 597 * - "he says he's not quite dead" 598 * - "isn't there anything you could do?" 599 * - *clunk*! 600 * - "thanks" 601 */ 602 int 603 puffs9p_node_reclaim(struct puffs_usermount *pu, void *opc) 604 { 605 struct puffs_node *pn = opc; 606 struct p9pnode *p9n = pn->pn_data; 607 608 assert(LIST_EMPTY(&p9n->dir_openlist)); 609 assert(p9n->fid_read == P9P_INVALFID && p9n->fid_write == P9P_INVALFID); 610 611 proto_cc_clunkfid(pu, p9n->fid_base, 0); 612 free(p9n); 613 puffs_pn_put(pn); 614 615 return 0; 616 } 617