usr/src/uts/common/rpcsvc/nlm_prot.x

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