1/* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22/* 23 * Network lock manager protocol definition 24 * Copyright (C) 1986, 1992, 1993, 1997, 1999 by Sun Microsystems, Inc. 25 * All rights reserved. 26 * 27 * Protocol used between local lock manager and remote lock manager. 28 * 29 * There are currently 3 versions of the protocol in use. Versions 1 30 * and 3 are used with NFS version 2. Version 4 is used with NFS 31 * version 3. 32 * 33 * (Note: there is also a version 2, but it defines an orthogonal set of 34 * procedures that the status monitor uses to notify the lock manager of 35 * changes in monitored systems.) 36 */ 37 38%#pragma ident "%Z%%M% %I% %E% SMI" 39 40#if RPC_HDR 41% 42%#include <rpc/rpc_sztypes.h> 43% 44#endif 45 46#ifdef RPC_HDR 47%#define LM_MAXSTRLEN 1024 48%#define LM_MAXNAMELEN (LM_MAXSTRLEN + 1) 49#endif 50 51/* 52 * Types for versions 1 and 3. 53 */ 54 55/* 56 * Status of a call to the lock manager. The lower case enums violate the 57 * current style guide, but we're stuck with 'em. 58 */ 59 60enum nlm_stats { 61 nlm_granted = 0, 62 nlm_denied = 1, 63 nlm_denied_nolocks = 2, 64 nlm_blocked = 3, 65 nlm_denied_grace_period = 4, 66 nlm_deadlck = 5 67}; 68 69/* 70 * The holder of a conflicting lock. 71 */ 72 73struct nlm_holder { 74 bool exclusive; 75 int svid; 76 netobj oh; 77 unsigned l_offset; 78 unsigned l_len; 79}; 80 81union nlm_testrply switch (nlm_stats stat) { 82 case nlm_denied: 83 struct nlm_holder holder; 84 default: 85 void; 86}; 87 88struct nlm_stat { 89 nlm_stats stat; 90}; 91 92struct nlm_res { 93 netobj cookie; 94 nlm_stat stat; 95}; 96 97struct nlm_testres { 98 netobj cookie; 99 nlm_testrply stat; 100}; 101 102struct nlm_lock { 103 string caller_name<LM_MAXSTRLEN>; 104 netobj fh; /* identify a file */ 105 netobj oh; /* identify owner of a lock */ 106 int svid; /* generated from pid for svid */ 107 unsigned l_offset; 108 unsigned l_len; 109}; 110 111struct nlm_lockargs { 112 netobj cookie; 113 bool block; 114 bool exclusive; 115 struct nlm_lock alock; 116 bool reclaim; /* used for recovering locks */ 117 int state; /* specify local status monitor state */ 118}; 119 120struct nlm_cancargs { 121 netobj cookie; 122 bool block; 123 bool exclusive; 124 struct nlm_lock alock; 125}; 126 127struct nlm_testargs { 128 netobj cookie; 129 bool exclusive; 130 struct nlm_lock alock; 131}; 132 133struct nlm_unlockargs { 134 netobj cookie; 135 struct nlm_lock alock; 136}; 137 138#ifdef RPC_HDR 139%/* 140% * The following enums are actually bit encoded for efficient 141% * boolean algebra.... DON'T change them..... 142% * The mixed-case enums violate the present style guide, but we're 143% * stuck with 'em. 144% */ 145#endif 146 147enum fsh_mode { 148 fsm_DN = 0, /* deny none */ 149 fsm_DR = 1, /* deny read */ 150 fsm_DW = 2, /* deny write */ 151 fsm_DRW = 3 /* deny read/write */ 152}; 153 154enum fsh_access { 155 fsa_NONE = 0, /* for completeness */ 156 fsa_R = 1, /* read only */ 157 fsa_W = 2, /* write only */ 158 fsa_RW = 3 /* read/write */ 159}; 160 161struct nlm_share { 162 string caller_name<LM_MAXSTRLEN>; 163 netobj fh; 164 netobj oh; 165 fsh_mode mode; 166 fsh_access access; 167}; 168 169struct nlm_shareargs { 170 netobj cookie; 171 nlm_share share; 172 bool reclaim; 173}; 174 175struct nlm_shareres { 176 netobj cookie; 177 nlm_stats stat; 178 int sequence; 179}; 180 181struct nlm_notify { 182 string name<LM_MAXNAMELEN>; 183 int state; 184}; 185 186/* 187 * Types for version 4. 188 * 189 * This revision is designed to work with NFS V3. The main changes from 190 * NFS V2 to V3 that affect the NLM protocol are that all file offsets 191 * and sizes are now unsigned 64-bit ints, and file handles are now 192 * variable length. In NLM V1 and V3, the fixed-length V2 file handle 193 * was encoded as a 'netobj', which is a count followed by the data 194 * bytes. For NLM 4, the file handle is already a count followed by 195 * data bytes, so the handle is copied directly into the netobj, rather 196 * than being encoded with an additional byte count. 197 */ 198 199/* 200 * Status of a call to the lock manager. 201 */ 202 203enum nlm4_stats { 204 NLM4_GRANTED = 0, /* lock was granted */ 205 NLM4_DENIED = 1, /* lock was not granted, usually */ 206 /* due to conflicting lock */ 207 NLM4_DENIED_NOLOCKS = 2, /* not granted: out of resources */ 208 NLM4_BLOCKED = 3, /* not granted: expect callback */ 209 /* when granted */ 210 NLM4_DENIED_GRACE_PERIOD = 4, /* not granted: server is */ 211 /* reestablishing old locks */ 212 NLM4_DEADLCK = 5, /* not granted: deadlock detected */ 213 NLM4_ROFS = 6, /* not granted: read-only filesystem */ 214 NLM4_STALE_FH = 7, /* not granted: stale file handle */ 215 NLM4_FBIG = 8, /* not granted: offset or length */ 216 /* too big */ 217 NLM4_FAILED = 9 /* not granted: some other error */ 218}; 219 220/* 221 * The holder of a conflicting lock. 222 */ 223 224struct nlm4_holder { 225 bool exclusive; 226 int32 svid; 227 netobj oh; 228 uint64 l_offset; 229 uint64 l_len; 230}; 231 232union nlm4_testrply switch (nlm4_stats stat) { 233 case NLM4_DENIED: 234 struct nlm4_holder holder; 235 default: 236 void; 237}; 238 239struct nlm4_stat { 240 nlm4_stats stat; 241}; 242 243struct nlm4_res { 244 netobj cookie; 245 nlm4_stat stat; 246}; 247 248struct nlm4_testres { 249 netobj cookie; 250 nlm4_testrply stat; 251}; 252 253struct nlm4_lock { 254 string caller_name<LM_MAXSTRLEN>; 255 netobj fh; /* identify a file */ 256 netobj oh; /* identify owner of a lock */ 257 int32 svid; /* generated from pid for svid */ 258 uint64 l_offset; 259 uint64 l_len; 260}; 261 262struct nlm4_lockargs { 263 netobj cookie; 264 bool block; 265 bool exclusive; 266 struct nlm4_lock alock; 267 bool reclaim; /* used for recovering locks */ 268 int32 state; /* specify local status monitor state */ 269}; 270 271struct nlm4_cancargs { 272 netobj cookie; 273 bool block; 274 bool exclusive; 275 struct nlm4_lock alock; 276}; 277 278struct nlm4_testargs { 279 netobj cookie; 280 bool exclusive; 281 struct nlm4_lock alock; 282}; 283 284struct nlm4_unlockargs { 285 netobj cookie; 286 struct nlm4_lock alock; 287}; 288 289#ifdef RPC_HDR 290%/* 291% * The following enums are actually bit encoded for efficient 292% * boolean algebra.... DON'T change them..... 293% */ 294#endif 295 296enum fsh4_mode { 297 FSM_DN = 0, /* deny none */ 298 FSM_DR = 1, /* deny read */ 299 FSM_DW = 2, /* deny write */ 300 FSM_DRW = 3 /* deny read/write */ 301}; 302 303enum fsh4_access { 304 FSA_NONE = 0, /* for completeness */ 305 FSA_R = 1, /* read only */ 306 FSA_W = 2, /* write only */ 307 FSA_RW = 3 /* read/write */ 308}; 309 310struct nlm4_share { 311 string caller_name<LM_MAXSTRLEN>; 312 netobj fh; 313 netobj oh; 314 fsh4_mode mode; 315 fsh4_access access; 316}; 317 318struct nlm4_shareargs { 319 netobj cookie; 320 nlm4_share share; 321 bool reclaim; 322}; 323 324struct nlm4_shareres { 325 netobj cookie; 326 nlm4_stats stat; 327 int32 sequence; 328}; 329 330struct nlm4_notify { 331 string name<LM_MAXNAMELEN>; 332 int32 state; 333}; 334 335/* 336 * Over-the-wire protocol used between the network lock managers 337 */ 338 339program NLM_PROG { 340 version NLM_VERS { 341 342 nlm_testres 343 NLM_TEST(nlm_testargs) = 1; 344 345 nlm_res 346 NLM_LOCK(nlm_lockargs) = 2; 347 348 nlm_res 349 NLM_CANCEL(nlm_cancargs) = 3; 350 351 nlm_res 352 NLM_UNLOCK(nlm_unlockargs) = 4; 353 /* 354 * remote lock manager call-back to grant lock 355 */ 356 nlm_res 357 NLM_GRANTED(nlm_testargs) = 5; 358 359 /* 360 * message passing style of requesting lock 361 */ 362 363 void 364 NLM_TEST_MSG(nlm_testargs) = 6; 365 void 366 NLM_LOCK_MSG(nlm_lockargs) = 7; 367 void 368 NLM_CANCEL_MSG(nlm_cancargs) = 8; 369 void 370 NLM_UNLOCK_MSG(nlm_unlockargs) = 9; 371 void 372 NLM_GRANTED_MSG(nlm_testargs) = 10; 373 void 374 NLM_TEST_RES(nlm_testres) = 11; 375 void 376 NLM_LOCK_RES(nlm_res) = 12; 377 void 378 NLM_CANCEL_RES(nlm_res) = 13; 379 void 380 NLM_UNLOCK_RES(nlm_res) = 14; 381 void 382 NLM_GRANTED_RES(nlm_res) = 15; 383 } = 1; 384 385 version NLM_VERSX { 386 nlm_shareres 387 NLM_SHARE(nlm_shareargs) = 20; 388 nlm_shareres 389 NLM_UNSHARE(nlm_shareargs) = 21; 390 nlm_res 391 NLM_NM_LOCK(nlm_lockargs) = 22; 392 void 393 NLM_FREE_ALL(nlm_notify) = 23; 394 } = 3; 395 396 version NLM4_VERS { 397 void 398 NLMPROC4_NULL(void) = 0; 399 nlm4_testres 400 NLMPROC4_TEST(nlm4_testargs) = 1; 401 nlm4_res 402 NLMPROC4_LOCK(nlm4_lockargs) = 2; 403 nlm4_res 404 NLMPROC4_CANCEL(nlm4_cancargs) = 3; 405 nlm4_res 406 NLMPROC4_UNLOCK(nlm4_unlockargs) = 4; 407 /* 408 * remote lock manager call-back to grant lock 409 */ 410 nlm4_res 411 NLMPROC4_GRANTED(nlm4_testargs) = 5; 412 413 /* 414 * message passing style of requesting lock 415 */ 416 417 void 418 NLMPROC4_TEST_MSG(nlm4_testargs) = 6; 419 void 420 NLMPROC4_LOCK_MSG(nlm4_lockargs) = 7; 421 void 422 NLMPROC4_CANCEL_MSG(nlm4_cancargs) = 8; 423 void 424 NLMPROC4_UNLOCK_MSG(nlm4_unlockargs) = 9; 425 void 426 NLMPROC4_GRANTED_MSG(nlm4_testargs) = 10; 427 void 428 NLMPROC4_TEST_RES(nlm4_testres) = 11; 429 void 430 NLMPROC4_LOCK_RES(nlm4_res) = 12; 431 void 432 NLMPROC4_CANCEL_RES(nlm4_res) = 13; 433 void 434 NLMPROC4_UNLOCK_RES(nlm4_res) = 14; 435 void 436 NLMPROC4_GRANTED_RES(nlm4_res) = 15; 437 438 /* 439 * DOS-style file sharing 440 */ 441 442 nlm4_shareres 443 NLMPROC4_SHARE(nlm4_shareargs) = 20; 444 nlm4_shareres 445 NLMPROC4_UNSHARE(nlm4_shareargs) = 21; 446 nlm4_res 447 NLMPROC4_NM_LOCK(nlm4_lockargs) = 22; 448 void 449 NLMPROC4_FREE_ALL(nlm4_notify) = 23; 450 } = 4; 451 452} = 100021; 453