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 60 enum 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 73 struct nlm_holder { 74 bool exclusive; 75 int svid; 76 netobj oh; 77 unsigned l_offset; 78 unsigned l_len; 79 }; 80 81 union nlm_testrply switch (nlm_stats stat) { 82 case nlm_denied: 83 struct nlm_holder holder; 84 default: 85 void; 86 }; 87 88 struct nlm_stat { 89 nlm_stats stat; 90 }; 91 92 struct nlm_res { 93 netobj cookie; 94 nlm_stat stat; 95 }; 96 97 struct nlm_testres { 98 netobj cookie; 99 nlm_testrply stat; 100 }; 101 102 struct 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 111 struct 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 120 struct nlm_cancargs { 121 netobj cookie; 122 bool block; 123 bool exclusive; 124 struct nlm_lock alock; 125 }; 126 127 struct nlm_testargs { 128 netobj cookie; 129 bool exclusive; 130 struct nlm_lock alock; 131 }; 132 133 struct 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 147 enum 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 154 enum 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 161 struct nlm_share { 162 string caller_name<LM_MAXSTRLEN>; 163 netobj fh; 164 netobj oh; 165 fsh_mode mode; 166 fsh_access access; 167 }; 168 169 struct nlm_shareargs { 170 netobj cookie; 171 nlm_share share; 172 bool reclaim; 173 }; 174 175 struct nlm_shareres { 176 netobj cookie; 177 nlm_stats stat; 178 int sequence; 179 }; 180 181 struct 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 203 enum 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 224 struct nlm4_holder { 225 bool exclusive; 226 int32 svid; 227 netobj oh; 228 uint64 l_offset; 229 uint64 l_len; 230 }; 231 232 union nlm4_testrply switch (nlm4_stats stat) { 233 case NLM4_DENIED: 234 struct nlm4_holder holder; 235 default: 236 void; 237 }; 238 239 struct nlm4_stat { 240 nlm4_stats stat; 241 }; 242 243 struct nlm4_res { 244 netobj cookie; 245 nlm4_stat stat; 246 }; 247 248 struct nlm4_testres { 249 netobj cookie; 250 nlm4_testrply stat; 251 }; 252 253 struct 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 262 struct 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 271 struct nlm4_cancargs { 272 netobj cookie; 273 bool block; 274 bool exclusive; 275 struct nlm4_lock alock; 276 }; 277 278 struct nlm4_testargs { 279 netobj cookie; 280 bool exclusive; 281 struct nlm4_lock alock; 282 }; 283 284 struct 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 296 enum 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 303 enum 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 310 struct nlm4_share { 311 string caller_name<LM_MAXSTRLEN>; 312 netobj fh; 313 netobj oh; 314 fsh4_mode mode; 315 fsh4_access access; 316 }; 317 318 struct nlm4_shareargs { 319 netobj cookie; 320 nlm4_share share; 321 bool reclaim; 322 }; 323 324 struct nlm4_shareres { 325 netobj cookie; 326 nlm4_stats stat; 327 int32 sequence; 328 }; 329 330 struct 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 339 program 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