1 /* NFSv4.1 client for Windows 2 * Copyright � 2012 The Regents of the University of Michigan 3 * 4 * Olga Kornievskaia <aglo@umich.edu> 5 * Casey Bodley <cbodley@umich.edu> 6 * 7 * This library is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU Lesser General Public License as published by 9 * the Free Software Foundation; either version 2.1 of the License, or (at 10 * your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, but 13 * without any warranty; without even the implied warranty of merchantability 14 * or fitness for a particular purpose. See the GNU Lesser General Public 15 * License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public License 18 * along with this library; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20 */ 21 22 #ifndef __NFS41_NFS_OPS_H__ 23 #define __NFS41_NFS_OPS_H__ 24 25 #include "nfs41.h" 26 #include "pnfs.h" 27 28 29 /* Operation arrays */ 30 enum nfs_opnum4 { 31 OP_ACCESS = 3, 32 OP_CLOSE = 4, 33 OP_COMMIT = 5, 34 OP_CREATE = 6, 35 OP_DELEGPURGE = 7, 36 OP_DELEGRETURN = 8, 37 OP_GETATTR = 9, 38 OP_GETFH = 10, 39 OP_LINK = 11, 40 OP_LOCK = 12, 41 OP_LOCKT = 13, 42 OP_LOCKU = 14, 43 OP_LOOKUP = 15, 44 OP_LOOKUPP = 16, 45 OP_NVERIFY = 17, 46 OP_OPEN = 18, 47 OP_OPENATTR = 19, 48 OP_OPEN_CONFIRM = 20, /* Mandatory not-to-implement */ 49 OP_OPEN_DOWNGRADE = 21, 50 OP_PUTFH = 22, 51 OP_PUTPUBFH = 23, 52 OP_PUTROOTFH = 24, 53 OP_READ = 25, 54 OP_READDIR = 26, 55 OP_READLINK = 27, 56 OP_REMOVE = 28, 57 OP_RENAME = 29, 58 OP_RENEW = 30, /* Mandatory not-to-implement */ 59 OP_RESTOREFH = 31, 60 OP_SAVEFH = 32, 61 OP_SECINFO = 33, 62 OP_SETATTR = 34, 63 OP_SETCLIENTID = 35, /* Mandatory not-to-implement */ 64 OP_SETCLIENTID_CONFIRM = 36, /* Mandatory not-to-implement */ 65 OP_VERIFY = 37, 66 OP_WRITE = 38, 67 OP_RELEASE_LOCKOWNER = 39, /* Mandatory not-to-implement */ 68 69 /* new operations for NFSv4.1 */ 70 OP_BACKCHANNEL_CTL = 40, 71 OP_BIND_CONN_TO_SESSION = 41, 72 OP_EXCHANGE_ID = 42, 73 OP_CREATE_SESSION = 43, 74 OP_DESTROY_SESSION = 44, 75 OP_FREE_STATEID = 45, 76 OP_GET_DIR_DELEGATION = 46, 77 OP_GETDEVICEINFO = 47, 78 OP_GETDEVICELIST = 48, 79 OP_LAYOUTCOMMIT = 49, 80 OP_LAYOUTGET = 50, 81 OP_LAYOUTRETURN = 51, 82 OP_SECINFO_NO_NAME = 52, 83 OP_SEQUENCE = 53, 84 OP_SET_SSV = 54, 85 OP_TEST_STATEID = 55, 86 OP_WANT_DELEGATION = 56, 87 OP_DESTROY_CLIENTID = 57, 88 OP_RECLAIM_COMPLETE = 58, 89 OP_ILLEGAL = 10044 90 }; 91 92 93 /* OP_EXCHANGE_ID */ 94 enum { 95 EXCHGID4_FLAG_SUPP_MOVED_REFER = 0x00000001, 96 EXCHGID4_FLAG_SUPP_MOVED_MIGR = 0x00000002, 97 98 EXCHGID4_FLAG_BIND_PRINC_STATEID = 0x00000100, 99 100 EXCHGID4_FLAG_USE_NON_PNFS = 0x00010000, 101 EXCHGID4_FLAG_USE_PNFS_MDS = 0x00020000, 102 EXCHGID4_FLAG_USE_PNFS_DS = 0x00040000, 103 104 EXCHGID4_FLAG_MASK_PNFS = 0x00070000, 105 106 EXCHGID4_FLAG_UPD_CONFIRMED_REC_A = 0x40000000, 107 EXCHGID4_FLAG_CONFIRMED_R = 0x80000000 108 }; 109 110 typedef enum { 111 SP4_NONE = 0, 112 SP4_MACH_CRED = 1, 113 SP4_SSV = 2 114 } state_protect_how4; 115 116 typedef struct __state_protect4_a { 117 state_protect_how4 spa_how; 118 } state_protect4_a; 119 120 typedef struct __nfs41_exchange_id_args { 121 client_owner4 *eia_clientowner; 122 uint32_t eia_flags; 123 state_protect4_a eia_state_protect; 124 nfs_impl_id4 *eia_client_impl_id; /* <1> */ 125 } nfs41_exchange_id_args; 126 127 typedef struct __state_protect4_r { 128 state_protect_how4 spr_how; 129 } state_protect4_r; 130 131 typedef struct __nfs41_exchange_id_res { 132 uint32_t status; 133 uint64_t clientid; 134 uint32_t sequenceid; 135 uint32_t flags; 136 state_protect4_r state_protect; 137 server_owner4 server_owner; 138 uint32_t server_scope_len; 139 char server_scope[NFS4_OPAQUE_LIMIT]; 140 } nfs41_exchange_id_res; 141 142 typedef struct __nfs41_callback_sec_parms { 143 uint32_t type; 144 union { 145 /* case AUTH_SYS */ 146 struct __authsys_parms { 147 uint32_t stamp; 148 char *machinename; 149 } auth_sys; 150 /* case RPCSEC_GSS */ 151 struct __rpcsec_gss_parms { 152 uint32_t gss_srv_type; 153 char *srv_gssctx_handle; 154 uint32_t srv_gssctx_hdle_len; 155 char *clnt_gssctx_handle; 156 uint32_t clnt_gssctx_hdle_len; 157 } rpcsec_gss; 158 } u; 159 } nfs41_callback_secparms; 160 161 /* OP_CREATE_SESSION */ 162 typedef struct __nfs41_create_session_args { 163 uint64_t csa_clientid; 164 uint32_t csa_sequence; 165 uint32_t csa_flags; 166 nfs41_channel_attrs csa_fore_chan_attrs; 167 nfs41_channel_attrs csa_back_chan_attrs; 168 uint32_t csa_cb_program; 169 nfs41_callback_secparms csa_cb_secparams[2]; 170 } nfs41_create_session_args; 171 172 typedef struct __nfs41_create_session_res { 173 unsigned char *csr_sessionid; 174 uint32_t csr_sequence; 175 uint32_t csr_flags; 176 nfs41_channel_attrs *csr_fore_chan_attrs; 177 nfs41_channel_attrs *csr_back_chan_attrs; 178 } nfs41_create_session_res; 179 180 181 /* OP_BIND_CONN_TO_SESSION */ 182 enum channel_dir_from_client4 { 183 CDFC4_FORE = 0x1, 184 CDFC4_BACK = 0x2, 185 CDFC4_FORE_OR_BOTH = 0x3, 186 CDFC4_BACK_OR_BOTH = 0x7 187 }; 188 189 enum channel_dir_from_server4 { 190 CDFS4_FORE = 0x1, 191 CDFS4_BACK = 0x2, 192 CDFS4_BOTH = 0x3 193 }; 194 195 typedef struct __nfs41_bind_conn_to_session_args { 196 unsigned char *sessionid; 197 enum channel_dir_from_client4 dir; 198 } nfs41_bind_conn_to_session_args; 199 200 typedef struct __nfs41_bind_conn_to_session_res { 201 enum nfsstat4 status; 202 /* case NFS4_OK: */ 203 enum channel_dir_from_server4 dir; 204 } nfs41_bind_conn_to_session_res; 205 206 207 /* OP_DESTROY_SESSION */ 208 typedef struct __nfs41_destroy_session_args { 209 unsigned char *dsa_sessionid; 210 } nfs41_destroy_session_args; 211 212 typedef struct __nfs41_destroy_session_res { 213 uint32_t dsr_status; 214 } nfs41_destroy_session_res; 215 216 217 /* OP_DESTROY_CLIENTID */ 218 typedef struct __nfs41_destroy_clientid_args { 219 uint64_t dca_clientid; 220 } nfs41_destroy_clientid_args; 221 222 typedef struct __nfs41_destroy_clientid_res { 223 uint32_t dcr_status; 224 } nfs41_destroy_clientid_res; 225 226 227 /* OP_SEQUENCE */ 228 typedef struct __nfs41_sequence_args { 229 unsigned char *sa_sessionid; 230 uint32_t sa_sequenceid; 231 uint32_t sa_slotid; 232 uint32_t sa_highest_slotid; 233 bool_t sa_cachethis; 234 } nfs41_sequence_args; 235 236 enum { 237 SEQ4_STATUS_CB_PATH_DOWN = 0x00000001, 238 SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING = 0x00000002, 239 SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED = 0x00000004, 240 SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED = 0x00000008, 241 SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED = 0x00000010, 242 SEQ4_STATUS_ADMIN_STATE_REVOKED = 0x00000020, 243 SEQ4_STATUS_RECALLABLE_STATE_REVOKED = 0x00000040, 244 SEQ4_STATUS_LEASE_MOVED = 0x00000080, 245 SEQ4_STATUS_RESTART_RECLAIM_NEEDED = 0x00000100, 246 SEQ4_STATUS_CB_PATH_DOWN_SESSION = 0x00000200, 247 SEQ4_STATUS_BACKCHANNEL_FAULT = 0x00000400, 248 SEQ4_STATUS_DEVID_CHANGED = 0x00000800, 249 SEQ4_STATUS_DEVID_DELETED = 0x00001000 250 }; 251 252 typedef struct __nfs41_sequence_res_ok { 253 unsigned char sr_sessionid[NFS4_SESSIONID_SIZE]; 254 uint32_t sr_sequenceid; 255 uint32_t sr_slotid; 256 uint32_t sr_highest_slotid; 257 uint32_t sr_target_highest_slotid; 258 uint32_t sr_status_flags; 259 } nfs41_sequence_res_ok; 260 261 typedef struct __nfs41_sequence_res { 262 uint32_t sr_status; 263 /* case NFS4_OK: */ 264 nfs41_sequence_res_ok sr_resok4; 265 } nfs41_sequence_res; 266 267 268 /* OP_RECLAIM_COMPLETE */ 269 typedef struct __nfs41_reclaim_complete_res { 270 enum nfsstat4 status; 271 } nfs41_reclaim_complete_res; 272 273 274 /* recoverable stateid argument */ 275 enum stateid_type { 276 STATEID_OPEN, 277 STATEID_LOCK, 278 STATEID_DELEG_FILE, 279 STATEID_DELEG_DIR, 280 STATEID_LAYOUT, 281 STATEID_SPECIAL 282 }; 283 typedef struct __stateid_arg { 284 stateid4 stateid; 285 enum stateid_type type; 286 nfs41_open_state *open; 287 nfs41_delegation_state *delegation; 288 } stateid_arg; 289 290 291 /* OP_ACCESS */ 292 enum { 293 ACCESS4_READ = 0x00000001, 294 ACCESS4_LOOKUP = 0x00000002, 295 ACCESS4_MODIFY = 0x00000004, 296 ACCESS4_EXTEND = 0x00000008, 297 ACCESS4_DELETE = 0x00000010, 298 ACCESS4_EXECUTE = 0x00000020 299 }; 300 301 typedef struct __nfs41_access_args { 302 uint32_t access; 303 } nfs41_access_args; 304 305 typedef struct __nfs41_access_res { 306 uint32_t status; 307 /* case NFS4_OK: */ 308 uint32_t supported; 309 uint32_t access; 310 } nfs41_access_res; 311 312 313 /* OP_CLOSE */ 314 typedef struct __nfs41_op_close_args { 315 // uint32_t seqid; // not used, always 0 316 stateid_arg *stateid; 317 } nfs41_op_close_args; 318 319 typedef struct __nfs41_op_close_res { 320 uint32_t status; 321 } nfs41_op_close_res; 322 323 324 /* OP_COMMIT */ 325 typedef struct __nfs41_commit_args { 326 uint64_t offset; 327 uint32_t count; 328 } nfs41_commit_args; 329 330 typedef struct __nfs41_commit_res { 331 uint32_t status; 332 nfs41_write_verf *verf; 333 } nfs41_commit_res; 334 335 336 /* OP_CREATE */ 337 typedef struct __specdata4 { 338 uint32_t specdata1; 339 uint32_t specdata2; 340 } specdata4; 341 342 typedef struct __createtype4 { 343 uint32_t type; 344 union { 345 /* case NF4LNK: */ 346 struct __create_type_lnk { 347 uint32_t linkdata_len; 348 const char *linkdata; 349 } lnk; 350 /* case NF4BLK, NF4CHR: */ 351 specdata4 devdata; 352 } u; 353 } createtype4; 354 355 typedef struct __nfs41_create_args { 356 createtype4 objtype; 357 const nfs41_component *name; 358 nfs41_file_info *createattrs; 359 } nfs41_create_args; 360 361 typedef struct __nfs41_create_res { 362 uint32_t status; 363 /* case NFS4_OK: */ 364 change_info4 cinfo; 365 bitmap4 attrset; 366 } nfs41_create_res; 367 368 369 /* OP_DELEGPURGE */ 370 typedef struct __nfs41_delegpurge_res { 371 uint32_t status; 372 } nfs41_delegpurge_res; 373 374 375 /* OP_DELEGRETURN */ 376 typedef struct __nfs41_delegreturn_args { 377 stateid_arg *stateid; 378 } nfs41_delegreturn_args; 379 380 typedef struct __nfs41_delegreturn_res { 381 uint32_t status; 382 } nfs41_delegreturn_res; 383 384 385 /* OP_LINK */ 386 typedef struct __nfs41_link_args { 387 const nfs41_component *newname; 388 } nfs41_link_args; 389 390 typedef struct __nfs41_link_res { 391 uint32_t status; 392 /* case NFS4_OK */ 393 change_info4 cinfo; 394 } nfs41_link_res; 395 396 397 /* OP_LOCK */ 398 enum { 399 READ_LT = 1, 400 WRITE_LT = 2, 401 READW_LT = 3, /* blocking read */ 402 WRITEW_LT = 4 /* blocking write */ 403 }; 404 405 typedef struct __open_to_lock_owner4 { 406 uint32_t open_seqid; 407 stateid_arg *open_stateid; 408 uint32_t lock_seqid; 409 state_owner4 *lock_owner; 410 } open_to_lock_owner4; 411 412 typedef struct __exist_lock_owner4 { 413 stateid_arg *lock_stateid; 414 uint32_t lock_seqid; 415 } exist_lock_owner4; 416 417 typedef struct __locker4 { 418 bool_t new_lock_owner; 419 union { 420 /* case TRUE: */ 421 open_to_lock_owner4 open_owner; 422 /* case FALSE: */ 423 exist_lock_owner4 lock_owner; 424 } u; 425 } locker4; 426 427 typedef struct __nfs41_lock_args { 428 uint32_t locktype; 429 bool_t reclaim; 430 uint64_t offset; 431 uint64_t length; 432 locker4 locker; 433 } nfs41_lock_args; 434 435 typedef struct __lock_res_denied { 436 uint64_t offset; 437 uint64_t length; 438 uint32_t locktype; 439 state_owner4 owner; 440 } lock_res_denied; 441 442 typedef struct __lock_res_ok { 443 stateid4 *lock_stateid; 444 } lock_res_ok; 445 446 typedef struct __nfs41_lock_res { 447 uint32_t status; 448 union { 449 /* case NFS4_OK: */ 450 lock_res_ok resok4; 451 /* case NFS4ERR_DENIED: */ 452 lock_res_denied denied; 453 /* default: void; */ 454 } u; 455 } nfs41_lock_res; 456 457 458 /* OP_LOCKT */ 459 typedef struct __nfs41_lockt_args { 460 uint32_t locktype; 461 uint64_t offset; 462 uint64_t length; 463 state_owner4 *owner; 464 } nfs41_lockt_args; 465 466 typedef struct __nfs41_lockt_res { 467 uint32_t status; 468 /* case NFS4ERR_DENIED: */ 469 lock_res_denied denied; 470 /* default: void; */ 471 } nfs41_lockt_res; 472 473 474 /* OP_LOCKU */ 475 typedef struct __nfs41_locku_args { 476 uint32_t locktype; 477 uint32_t seqid; 478 stateid_arg *lock_stateid; 479 uint64_t offset; 480 uint64_t length; 481 } nfs41_locku_args; 482 483 typedef struct __nfs41_locku_res { 484 uint32_t status; 485 /* case NFS4_OK: */ 486 stateid4 *lock_stateid; 487 } nfs41_locku_res; 488 489 490 /* OP_LOOKUP */ 491 typedef struct __nfs41_lookup_args { 492 const nfs41_component *name; 493 } nfs41_lookup_args; 494 495 typedef struct __nfs41_lookup_res { 496 uint32_t status; 497 } nfs41_lookup_res; 498 499 500 /* OP_GETFH */ 501 typedef struct __nfs41_getfh_res { 502 uint32_t status; 503 /* case NFS4_OK: */ 504 nfs41_fh *fh; 505 } nfs41_getfh_res; 506 507 508 /* OP_PUTFH */ 509 typedef struct __nfs41_putfh_args { 510 nfs41_path_fh *file; 511 bool_t in_recovery; 512 } nfs41_putfh_args; 513 514 typedef struct __nfs41_putfh_res { 515 uint32_t status; 516 } nfs41_putfh_res; 517 518 519 /* OP_PUTROOTFH */ 520 typedef struct __nfs41_putrootfh_res { 521 uint32_t status; 522 } nfs41_putrootfh_res; 523 524 525 /* OP_GETATTR */ 526 typedef struct __nfs41_getattr_args { 527 bitmap4 *attr_request; 528 } nfs41_getattr_args; 529 530 typedef struct __nfs41_getattr_res { 531 uint32_t status; 532 /* case NFS4_OK: */ 533 fattr4 obj_attributes; 534 nfs41_file_info *info; 535 } nfs41_getattr_res; 536 537 538 /* OP_OPEN */ 539 enum createmode4 { 540 UNCHECKED4 = 0, 541 GUARDED4 = 1, 542 EXCLUSIVE4 = 2, 543 EXCLUSIVE4_1 = 3 544 }; 545 546 typedef struct __createhow4 { 547 uint32_t mode; 548 nfs41_file_info *createattrs; 549 unsigned char createverf[NFS4_VERIFIER_SIZE]; 550 } createhow4; 551 552 enum opentype4 { 553 OPEN4_NOCREATE = 0, 554 OPEN4_CREATE = 1 555 }; 556 557 typedef struct __openflag4 { 558 uint32_t opentype; 559 /* case OPEN4_CREATE: */ 560 createhow4 how; 561 } openflag4; 562 563 enum { 564 OPEN4_SHARE_ACCESS_READ = 0x00000001, 565 OPEN4_SHARE_ACCESS_WRITE = 0x00000002, 566 OPEN4_SHARE_ACCESS_BOTH = 0x00000003, 567 568 OPEN4_SHARE_DENY_NONE = 0x00000000, 569 OPEN4_SHARE_DENY_READ = 0x00000001, 570 OPEN4_SHARE_DENY_WRITE = 0x00000002, 571 OPEN4_SHARE_DENY_BOTH = 0x00000003, 572 573 OPEN4_SHARE_ACCESS_WANT_DELEG_MASK = 0xFF00, 574 OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE = 0x0000, 575 OPEN4_SHARE_ACCESS_WANT_READ_DELEG = 0x0100, 576 OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG = 0x0200, 577 OPEN4_SHARE_ACCESS_WANT_ANY_DELEG = 0x0300, 578 OPEN4_SHARE_ACCESS_WANT_NO_DELEG = 0x0400, 579 OPEN4_SHARE_ACCESS_WANT_CANCEL = 0x0500, 580 581 OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL = 0x10000, 582 OPEN4_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED = 0x20000 583 }; 584 585 enum open_delegation_type4 { 586 OPEN_DELEGATE_NONE = 0, 587 OPEN_DELEGATE_READ = 1, 588 OPEN_DELEGATE_WRITE = 2, 589 OPEN_DELEGATE_NONE_EXT = 3 590 }; 591 592 enum open_claim_type4 { 593 CLAIM_NULL = 0, 594 CLAIM_PREVIOUS = 1, 595 CLAIM_DELEGATE_CUR = 2, 596 CLAIM_DELEGATE_PREV = 3, 597 CLAIM_FH = 4, 598 CLAIM_DELEG_CUR_FH = 5, 599 CLAIM_DELEG_PREV_FH = 6 600 }; 601 602 enum why_no_delegation4 { 603 WND4_NOT_WANTED = 0, 604 WND4_CONTENTION = 1, 605 WND4_RESOURCE = 2, 606 WND4_NOT_SUPP_FTYPE = 3, 607 WND4_WRITE_DELEG_NOT_SUPP_FTYPE = 4, 608 WND4_NOT_SUPP_UPGRADE = 5, 609 WND4_NOT_SUPP_DOWNGRADE = 6, 610 WND4_CANCELED = 7, 611 WND4_IS_DIR = 8 612 }; 613 614 typedef struct __open_claim4 { 615 uint32_t claim; 616 union { 617 /* case CLAIM_NULL: */ 618 struct __open_claim_null { 619 const nfs41_component *filename; 620 } null; 621 /* case CLAIM_PREVIOUS: */ 622 struct __open_claim_prev { 623 uint32_t delegate_type; 624 } prev; 625 /* case CLAIM_DELEGATE_CUR: */ 626 struct __open_claim_deleg_cur { 627 stateid_arg *delegate_stateid; 628 nfs41_component *name; 629 } deleg_cur; 630 /* case CLAIM_DELEG_CUR_FH: */ 631 struct __open_claim_deleg_cur_fh { 632 stateid_arg *delegate_stateid; 633 } deleg_cur_fh; 634 /* case CLAIM_DELEGATE_PREV: */ 635 struct __open_claim_deleg_prev { 636 const nfs41_component *filename; 637 } deleg_prev; 638 } u; 639 } open_claim4; 640 641 typedef struct __nfs41_op_open_args { 642 uint32_t seqid; 643 uint32_t share_access; 644 uint32_t share_deny; 645 state_owner4 *owner; 646 openflag4 openhow; 647 open_claim4 *claim; 648 } nfs41_op_open_args; 649 650 enum { 651 OPEN4_RESULT_CONFIRM = 0x00000002, 652 OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004, 653 OPEN4_RESULT_PRESERVE_UNLINKED = 0x00000008, 654 OPEN4_RESULT_MAY_NOTIFY_LOCK = 0x00000020 655 }; 656 657 typedef struct __nfs41_op_open_res_ok { 658 stateid4 *stateid; 659 change_info4 cinfo; 660 uint32_t rflags; 661 bitmap4 attrset; 662 open_delegation4 *delegation; 663 } nfs41_op_open_res_ok; 664 665 typedef struct __nfs41_op_open_res { 666 uint32_t status; 667 /* case NFS4_OK: */ 668 nfs41_op_open_res_ok resok4; 669 } nfs41_op_open_res; 670 671 672 /* OP_OPENATTR */ 673 typedef struct __nfs41_openattr_args { 674 bool_t createdir; 675 } nfs41_openattr_args; 676 677 typedef struct __nfs41_openattr_res { 678 uint32_t status; 679 } nfs41_openattr_res; 680 681 682 /* OP_READ */ 683 typedef struct __nfs41_read_args { 684 stateid_arg *stateid; /* -> nfs41_op_open_res_ok.stateid */ 685 uint64_t offset; 686 uint32_t count; 687 } nfs41_read_args; 688 689 typedef struct __nfs41_read_res_ok { 690 bool_t eof; 691 uint32_t data_len; 692 unsigned char *data; /* caller-allocated */ 693 } nfs41_read_res_ok; 694 695 typedef struct __nfs41_read_res { 696 uint32_t status; 697 /* case NFS4_OK: */ 698 nfs41_read_res_ok resok4; 699 } nfs41_read_res; 700 701 702 /* OP_READDIR */ 703 typedef struct __nfs41_readdir_args { 704 nfs41_readdir_cookie cookie; 705 uint32_t dircount; 706 uint32_t maxcount; 707 bitmap4 *attr_request; 708 } nfs41_readdir_args; 709 710 typedef struct __nfs41_readdir_entry { 711 uint64_t cookie; 712 uint32_t name_len; 713 uint32_t next_entry_offset; 714 nfs41_file_info attr_info; 715 char name[1]; 716 } nfs41_readdir_entry; 717 718 typedef struct __nfs41_readdir_list { 719 bool_t has_entries; 720 uint32_t entries_len; 721 unsigned char *entries; 722 bool_t eof; 723 } nfs41_readdir_list; 724 725 typedef struct __nfs41_readdir_res { 726 uint32_t status; 727 /* case NFS4_OK: */ 728 unsigned char cookieverf[NFS4_VERIFIER_SIZE]; 729 nfs41_readdir_list reply; 730 } nfs41_readdir_res; 731 732 733 /* OP_READLINK */ 734 typedef struct __nfs41_readlink_res { 735 uint32_t status; 736 /* case NFS4_OK: */ 737 uint32_t link_len; 738 char *link; 739 } nfs41_readlink_res; 740 741 742 /* OP_REMOVE */ 743 typedef struct __nfs41_remove_args { 744 const nfs41_component *target; 745 } nfs41_remove_args; 746 747 typedef struct __nfs41_remove_res { 748 uint32_t status; 749 /* case NFS4_OK: */ 750 change_info4 cinfo; 751 } nfs41_remove_res; 752 753 754 /* OP_RENAME */ 755 typedef struct __nfs41_rename_args { 756 const nfs41_component *oldname; 757 const nfs41_component *newname; 758 } nfs41_rename_args; 759 760 typedef struct __nfs41_rename_res { 761 uint32_t status; 762 /* case NFS4_OK: */ 763 change_info4 source_cinfo; 764 change_info4 target_cinfo; 765 } nfs41_rename_res; 766 767 768 /* OP_RESTOREFH */ 769 /* OP_SAVEFH */ 770 typedef struct __nfs41_restorefh_savefh_res { 771 uint32_t status; 772 } nfs41_restorefh_res, nfs41_savefh_res; 773 774 775 /* OP_SETATTR */ 776 enum time_how4 { 777 SET_TO_SERVER_TIME4 = 0, 778 SET_TO_CLIENT_TIME4 = 1 779 }; 780 781 typedef struct __nfs41_setattr_args { 782 stateid_arg *stateid; 783 nfs41_file_info *info; 784 } nfs41_setattr_args; 785 786 typedef struct __nfs41_setattr_res { 787 uint32_t status; 788 bitmap4 attrsset; 789 } nfs41_setattr_res; 790 791 792 /* OP_WANT_DELEGATION */ 793 typedef struct __deleg_claim4 { 794 uint32_t claim; 795 /* case CLAIM_PREVIOUS: */ 796 uint32_t prev_delegate_type; 797 } deleg_claim4; 798 799 typedef struct __nfs41_want_delegation_args { 800 uint32_t want; 801 deleg_claim4 *claim; 802 } nfs41_want_delegation_args; 803 804 typedef struct __nfs41_want_delegation_res { 805 uint32_t status; 806 /* case NFS4_OK: */ 807 open_delegation4 *delegation; 808 } nfs41_want_delegation_res; 809 /* OP_FREE_STATEID */ 810 typedef struct __nfs41_free_stateid_args { 811 stateid4 *stateid; 812 } nfs41_free_stateid_args; 813 814 typedef struct __nfs41_free_stateid_res { 815 uint32_t status; 816 } nfs41_free_stateid_res; 817 818 819 /* OP_TEST_STATEID */ 820 typedef struct __nfs41_test_stateid_args { 821 uint32_t count; 822 stateid_arg *stateids; // caller-allocated array 823 } nfs41_test_stateid_args; 824 825 typedef struct __nfs41_test_stateid_res { 826 uint32_t status; 827 struct { 828 uint32_t count; 829 uint32_t *status; // caller-allocated array 830 } resok; 831 } nfs41_test_stateid_res; 832 833 834 /* OP_WRITE */ 835 enum stable_how4 { 836 UNSTABLE4 = 0, 837 DATA_SYNC4 = 1, 838 FILE_SYNC4 = 2 839 }; 840 841 typedef struct __nfs41_write_args { 842 stateid_arg *stateid; /* -> nfs41_op_open_res_ok.stateid */ 843 uint64_t offset; 844 uint32_t stable; /* stable_how4 */ 845 uint32_t data_len; 846 unsigned char *data; /* caller-allocated */ 847 } nfs41_write_args; 848 849 typedef struct __nfs41_write_res_ok { 850 uint32_t count; 851 nfs41_write_verf *verf; 852 } nfs41_write_res_ok; 853 854 typedef struct __nfs41_write_res { 855 uint32_t status; 856 /* case NFS4_OK: */ 857 nfs41_write_res_ok resok4; 858 } nfs41_write_res; 859 860 /* OP_SECINFO */ 861 enum sec_flavor { 862 RPC_GSS_SVC_NONE = 1, 863 RPC_GSS_SVC_INTEGRITY = 2, 864 RPC_GSS_SVC_PRIVACY = 3, 865 }; 866 867 #define RPCSEC_GSS 6 868 #define MAX_OID_LEN 128 869 typedef struct __nfs41_secinfo_info { 870 char oid[MAX_OID_LEN]; 871 uint32_t oid_len; 872 uint32_t sec_flavor; 873 uint32_t qop; 874 enum sec_flavor type; 875 } nfs41_secinfo_info; 876 877 typedef struct __nfs41_secinfo_args { 878 const nfs41_component *name; 879 } nfs41_secinfo_args; 880 881 #define MAX_SECINFOS 6 882 883 /* OP_SECINFO_NO_NAME */ 884 enum secinfo_no_name_type { 885 SECINFO_STYLE4_CURRENT_FH = 0, 886 SECINFO_STYLE4_PARENT = 1 887 }; 888 889 typedef struct __nfs41_secinfo_noname_args { 890 #ifdef __REACTOS__ 891 uint32_t type; 892 #else 893 enum secinfo_noname_type type; 894 #endif 895 } nfs41_secinfo_noname_args; 896 897 typedef struct __nfs41_secinfo_noname_res { 898 uint32_t status; 899 /* case NFS4_OK: */ 900 nfs41_secinfo_info *secinfo; 901 uint32_t count; 902 } nfs41_secinfo_noname_res; 903 904 /* LAYOUTGET */ 905 typedef struct __pnfs_layoutget_args { 906 bool_t signal_layout_avail; 907 enum pnfs_layout_type layout_type; 908 enum pnfs_iomode iomode; 909 uint64_t offset; 910 uint64_t length; 911 uint64_t minlength; 912 stateid_arg *stateid; 913 uint32_t maxcount; 914 } pnfs_layoutget_args; 915 916 typedef struct __pnfs_layoutget_res_ok { 917 bool_t return_on_close; 918 stateid4 stateid; 919 uint32_t count; 920 struct list_entry layouts; /* list of pnfs_layouts */ 921 } pnfs_layoutget_res_ok; 922 923 typedef struct __pnfs_layoutget_res { 924 enum nfsstat4 status; 925 union { 926 /* case NFS4_OK: */ 927 pnfs_layoutget_res_ok *res_ok; 928 /* case NFS4ERR_LAYOUTTRYLATER: */ 929 bool_t will_signal_layout_avail; 930 /* default: void; */ 931 } u; 932 } pnfs_layoutget_res; 933 934 935 /* LAYOUTCOMMIT */ 936 typedef struct __pnfs_layoutcommit_args { 937 uint64_t offset; 938 uint64_t length; 939 stateid4 *stateid; 940 nfstime4 *new_time; 941 uint64_t *new_offset; 942 } pnfs_layoutcommit_args; 943 944 typedef struct __pnfs_layoutcommit_res { 945 uint32_t status; 946 /* case NFS4_OK */ 947 bool_t has_new_size; 948 /* case TRUE */ 949 uint64_t new_size; 950 } pnfs_layoutcommit_res; 951 952 953 /* LAYOUTRETURN */ 954 typedef struct __pnfs_layoutreturn_args { 955 bool_t reclaim; 956 enum pnfs_layout_type type; 957 enum pnfs_iomode iomode; 958 enum pnfs_return_type return_type; 959 /* case LAYOUTRETURN4_FILE: */ 960 uint64_t offset; 961 uint64_t length; 962 stateid4 *stateid; 963 } pnfs_layoutreturn_args; 964 965 typedef struct __pnfs_layoutreturn_res { 966 enum nfsstat4 status; 967 /* case NFS4_OK: */ 968 bool_t stateid_present; 969 /* case true: */ 970 stateid4 stateid; 971 } pnfs_layoutreturn_res; 972 973 974 /* GETDEVICEINFO */ 975 typedef struct __pnfs_getdeviceinfo_args { 976 unsigned char *deviceid; 977 enum pnfs_layout_type layout_type; 978 uint32_t maxcount; 979 bitmap4 notify_types; 980 } pnfs_getdeviceinfo_args; 981 982 typedef struct __pnfs_getdeviceinfo_res_ok { 983 pnfs_file_device *device; 984 bitmap4 notification; 985 } pnfs_getdeviceinfo_res_ok; 986 987 typedef struct __pnfs_getdeviceinfo_res { 988 enum nfsstat4 status; 989 union { 990 /* case NFS4_OK: */ 991 pnfs_getdeviceinfo_res_ok res_ok; 992 /* case NFS4ERR_TOOSMALL: */ 993 uint32_t mincount; 994 /* default: void; */ 995 } u; 996 } pnfs_getdeviceinfo_res; 997 998 999 /* nfs41_ops.c */ 1000 int nfs41_exchange_id( 1001 IN nfs41_rpc_clnt *rpc, 1002 IN client_owner4 *owner, 1003 IN uint32_t flags_in, 1004 OUT nfs41_exchange_id_res *res_out); 1005 1006 int nfs41_create_session( 1007 IN nfs41_client *clnt, 1008 OUT nfs41_session *session, 1009 IN bool_t try_recovery); 1010 1011 enum nfsstat4 nfs41_bind_conn_to_session( 1012 IN nfs41_rpc_clnt *rpc, 1013 IN const unsigned char *sessionid, 1014 IN enum channel_dir_from_client4 dir); 1015 1016 int nfs41_destroy_session( 1017 IN nfs41_session *session); 1018 1019 int nfs41_destroy_clientid( 1020 IN nfs41_rpc_clnt *rpc, 1021 IN uint64_t clientid); 1022 1023 int nfs41_send_sequence( 1024 IN nfs41_session *session); 1025 1026 enum nfsstat4 nfs41_reclaim_complete( 1027 IN nfs41_session *session); 1028 1029 int nfs41_lookup( 1030 IN nfs41_root *root, 1031 IN nfs41_session *session, 1032 IN OUT nfs41_abs_path *path, 1033 OUT OPTIONAL nfs41_path_fh *parent_out, 1034 OUT OPTIONAL nfs41_path_fh *target_out, 1035 OUT OPTIONAL nfs41_file_info *info_out, 1036 OUT nfs41_session **session_out); 1037 1038 int nfs41_open( 1039 IN nfs41_session *session, 1040 IN nfs41_path_fh *parent, 1041 IN nfs41_path_fh *file, 1042 IN state_owner4 *owner, 1043 IN open_claim4 *claim, 1044 IN uint32_t allow, 1045 IN uint32_t deny, 1046 IN uint32_t create, 1047 IN uint32_t how_mode, 1048 IN OPTIONAL nfs41_file_info *createattrs, 1049 IN bool_t try_recovery, 1050 OUT stateid4 *stateid, 1051 OUT open_delegation4 *delegation, 1052 OUT OPTIONAL nfs41_file_info *info); 1053 1054 int nfs41_create( 1055 IN nfs41_session *session, 1056 IN uint32_t type, 1057 IN nfs41_file_info *createattrs, 1058 IN OPTIONAL const char *symlink, 1059 IN nfs41_path_fh *parent, 1060 OUT nfs41_path_fh *file, 1061 OUT nfs41_file_info *info); 1062 1063 int nfs41_close( 1064 IN nfs41_session *session, 1065 IN nfs41_path_fh *file, 1066 IN stateid_arg *stateid); 1067 1068 int nfs41_write( 1069 IN nfs41_session *session, 1070 IN nfs41_path_fh *file, 1071 IN stateid_arg *stateid, 1072 IN unsigned char *data, 1073 IN uint32_t data_len, 1074 IN uint64_t offset, 1075 IN enum stable_how4 stable, 1076 OUT uint32_t *bytes_written, 1077 OUT nfs41_write_verf *verf, 1078 OUT nfs41_file_info *cinfo); 1079 1080 int nfs41_read( 1081 IN nfs41_session *session, 1082 IN nfs41_path_fh *file, 1083 IN stateid_arg *stateid, 1084 IN uint64_t offset, 1085 IN uint32_t count, 1086 OUT unsigned char *data_out, 1087 OUT uint32_t *data_len_out, 1088 OUT bool_t *eof_out); 1089 1090 int nfs41_commit( 1091 IN nfs41_session *session, 1092 IN nfs41_path_fh *file, 1093 IN uint64_t offset, 1094 IN uint32_t count, 1095 IN bool_t do_getattr, 1096 OUT nfs41_write_verf *verf, 1097 OUT nfs41_file_info *cinfo); 1098 1099 int nfs41_lock( 1100 IN nfs41_session *session, 1101 IN nfs41_path_fh *file, 1102 IN state_owner4 *owner, 1103 IN uint32_t type, 1104 IN uint64_t offset, 1105 IN uint64_t length, 1106 IN bool_t reclaim, 1107 IN bool_t try_recovery, 1108 IN OUT stateid_arg *stateid); 1109 1110 int nfs41_unlock( 1111 IN nfs41_session *session, 1112 IN nfs41_path_fh *file, 1113 IN uint64_t offset, 1114 IN uint64_t length, 1115 IN OUT stateid_arg *stateid); 1116 1117 stateid4* nfs41_lock_stateid_copy( 1118 IN nfs41_lock_state *lock_state, 1119 IN OUT stateid4 *dest); 1120 1121 int nfs41_readdir( 1122 IN nfs41_session *session, 1123 IN nfs41_path_fh *file, 1124 IN bitmap4 *attr_request, 1125 IN nfs41_readdir_cookie *cookie, 1126 OUT unsigned char *entries, 1127 IN OUT uint32_t *entries_len, 1128 OUT bool_t *eof_out); 1129 1130 int nfs41_getattr( 1131 IN nfs41_session *session, 1132 IN OPTIONAL nfs41_path_fh *file, 1133 IN bitmap4 *attr_request, 1134 OUT nfs41_file_info *info); 1135 1136 int nfs41_superblock_getattr( 1137 IN nfs41_session *session, 1138 IN nfs41_path_fh *file, 1139 IN bitmap4 *attr_request, 1140 OUT nfs41_file_info *info, 1141 OUT bool_t *supports_named_attrs); 1142 1143 /* getattr.c */ 1144 int nfs41_cached_getattr( 1145 IN nfs41_session *session, 1146 IN nfs41_path_fh *file, 1147 OUT nfs41_file_info *info); 1148 1149 int nfs41_remove( 1150 IN nfs41_session *session, 1151 IN nfs41_path_fh *parent, 1152 IN const nfs41_component *target, 1153 IN uint64_t fileid); 1154 1155 int nfs41_rename( 1156 IN nfs41_session *session, 1157 IN nfs41_path_fh *src_dir, 1158 IN const nfs41_component *src_name, 1159 IN nfs41_path_fh *dst_dir, 1160 IN const nfs41_component *dst_name); 1161 1162 int nfs41_setattr( 1163 IN nfs41_session *session, 1164 IN nfs41_path_fh *file, 1165 IN stateid_arg *stateid, 1166 IN nfs41_file_info *info); 1167 1168 int nfs41_link( 1169 IN nfs41_session *session, 1170 IN nfs41_path_fh *src, 1171 IN nfs41_path_fh *dst_dir, 1172 IN const nfs41_component *target, 1173 OUT nfs41_file_info *cinfo); 1174 1175 /* symlink.c */ 1176 int nfs41_symlink_target( 1177 IN nfs41_session *session, 1178 IN nfs41_path_fh *file, 1179 OUT nfs41_abs_path *target); 1180 1181 int nfs41_symlink_follow( 1182 IN nfs41_root *root, 1183 IN nfs41_session *session, 1184 IN nfs41_path_fh *symlink, 1185 OUT nfs41_file_info *info); 1186 1187 int nfs41_readlink( 1188 IN nfs41_session *session, 1189 IN nfs41_path_fh *file, 1190 IN uint32_t max_len, 1191 OUT char *link_out, 1192 OUT uint32_t *len_out); 1193 1194 int nfs41_access( 1195 IN nfs41_session *session, 1196 IN nfs41_path_fh *file, 1197 IN uint32_t requested, 1198 OUT uint32_t *supported OPTIONAL, 1199 OUT uint32_t *access OPTIONAL); 1200 1201 enum nfsstat4 nfs41_want_delegation( 1202 IN nfs41_session *session, 1203 IN nfs41_path_fh *file, 1204 IN deleg_claim4 *claim, 1205 IN uint32_t want, 1206 IN bool_t try_recovery, 1207 OUT open_delegation4 *delegation); 1208 1209 int nfs41_delegpurge( 1210 IN nfs41_session *session); 1211 1212 int nfs41_delegreturn( 1213 IN nfs41_session *session, 1214 IN nfs41_path_fh *file, 1215 IN stateid_arg *stateid, 1216 IN bool_t try_recovery); 1217 1218 enum nfsstat4 nfs41_fs_locations( 1219 IN nfs41_session *session, 1220 IN nfs41_path_fh *parent, 1221 IN const nfs41_component *name, 1222 OUT fs_locations4 *locations); 1223 1224 int nfs41_secinfo( 1225 IN nfs41_session *session, 1226 IN nfs41_path_fh *file, 1227 IN const nfs41_component *name, 1228 OUT nfs41_secinfo_info *secinfo); 1229 1230 int nfs41_secinfo_noname( 1231 IN nfs41_session *session, 1232 IN nfs41_path_fh *file, 1233 OUT nfs41_secinfo_info *secinfo); 1234 1235 enum nfsstat4 nfs41_free_stateid( 1236 IN nfs41_session *session, 1237 IN stateid4 *stateid); 1238 1239 enum nfsstat4 nfs41_test_stateid( 1240 IN nfs41_session *session, 1241 IN stateid_arg *stateid_array, 1242 IN uint32_t count, 1243 OUT uint32_t *status_array); 1244 1245 enum nfsstat4 pnfs_rpc_layoutget( 1246 IN nfs41_session *session, 1247 IN nfs41_path_fh *file, 1248 IN stateid_arg *stateid, 1249 IN enum pnfs_iomode iomode, 1250 IN uint64_t offset, 1251 IN uint64_t minlength, 1252 IN uint64_t length, 1253 OUT pnfs_layoutget_res_ok *layoutget_res); 1254 1255 enum nfsstat4 pnfs_rpc_layoutcommit( 1256 IN nfs41_session *session, 1257 IN nfs41_path_fh *file, 1258 IN stateid4 *stateid, 1259 IN uint64_t offset, 1260 IN uint64_t length, 1261 IN OPTIONAL uint64_t *new_last_offset, 1262 IN OPTIONAL nfstime4 *new_time_modify, 1263 OUT nfs41_file_info *info); 1264 1265 enum nfsstat4 pnfs_rpc_layoutreturn( 1266 IN nfs41_session *session, 1267 IN nfs41_path_fh *file, 1268 IN enum pnfs_layout_type type, 1269 IN enum pnfs_iomode iomode, 1270 IN uint64_t offset, 1271 IN uint64_t length, 1272 IN stateid4 *stateid, 1273 OUT pnfs_layoutreturn_res *layoutreturn_res); 1274 1275 enum nfsstat4 pnfs_rpc_getdeviceinfo( 1276 IN nfs41_session *session, 1277 IN unsigned char *deviceid, 1278 OUT pnfs_file_device *device); 1279 1280 enum nfsstat4 nfs41_rpc_openattr( 1281 IN nfs41_session *session, 1282 IN nfs41_path_fh *file, 1283 IN bool_t createdir, 1284 OUT nfs41_fh *fh_out); 1285 1286 #endif /* !__NFS41_NFS_OPS_H__ */ 1287