usr/src/uts/common/klm/nlm_rpc_clnt.c

   1 /*
   2  * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
   3  * Authors: Doug Rabson <dfr@rabson.org>
   4  * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
   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 AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE 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
  21  * OR 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 /*
  29  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  30  */
  31
  32 /*
  33  * Client-side RPC wrappers (nlm_..._rpc)
  34  * Called from nlm_client.c
  35  *
  36  * Source code derived from FreeBSD nlm_advlock.c
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/fcntl.h>
  41 #include <sys/lock.h>
  42 #include <sys/flock.h>
  43 #include <sys/mount.h>
  44 #include <sys/mutex.h>
  45 #include <sys/proc.h>
  46 #include <sys/syslog.h>
  47 #include <sys/systm.h>
  48 #include <sys/unistd.h>
  49 #include <sys/vnode.h>
  50 #include <sys/queue.h>
  51
  52 #include <rpcsvc/nlm_prot.h>
  53
  54 #include <nfs/nfs.h>
  55 #include <nfs/nfs_clnt.h>
  56 #include <nfs/export.h>
  57 #include <nfs/rnode.h>
  58
  59 #include "nlm_impl.h"
  60
  61 static void
  62 nlm_convert_to_nlm_lock(struct nlm_lock *dst, struct nlm4_lock *src)
  63 {
  64         dst->caller_name = src->caller_name;
  65         dst->fh = src->fh;
  66         dst->oh = src->oh;
  67         dst->svid = src->svid;
  68         dst->l_offset = src->l_offset;
  69         dst->l_len = src->l_len;
  70 }
  71
  72 static void
  73 nlm_convert_to_nlm4_holder(struct nlm4_holder *dst, struct nlm_holder *src)
  74 {
  75         dst->exclusive = src->exclusive;
  76         dst->svid = src->svid;
  77         dst->oh = src->oh;
  78         dst->l_offset = src->l_offset;
  79         dst->l_len = src->l_len;
  80 }
  81
  82 static void
  83 nlm_convert_to_nlm4_res(struct nlm4_res *dst, struct nlm_res *src)
  84 {
  85         dst->cookie = src->cookie;
  86         dst->stat.stat = (enum nlm4_stats) src->stat.stat;
  87 }
  88
  89 enum clnt_stat
  90 nlm_test_rpc(nlm4_testargs *args, nlm4_testres *res,
  91     CLIENT *client, rpcvers_t vers)
  92 {
  93         if (vers == NLM4_VERS) {
  94                 return (nlm4_test_4(args, res, client));
  95         } else {
  96                 nlm_testargs args1;
  97                 nlm_testres res1;
  98                 enum clnt_stat stat;
  99
 100                 args1.cookie = args->cookie;
 101                 args1.exclusive = args->exclusive;
 102                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
 103                 (void) memset(&res1, 0, sizeof (res1));
 104
 105                 stat = nlm_test_1(&args1, &res1, client);
 106
 107                 if (stat == RPC_SUCCESS) {
 108                         res->cookie = res1.cookie;
 109                         res->stat.stat = (enum nlm4_stats) res1.stat.stat;
 110                         if (res1.stat.stat == nlm_denied)
 111                                 nlm_convert_to_nlm4_holder(
 112                                     &res->stat.nlm4_testrply_u.holder,
 113                                     &res1.stat.nlm_testrply_u.holder);
 114                 }
 115
 116                 return (stat);
 117         }
 118 }
 119
 120 enum clnt_stat
 121 nlm_lock_rpc(nlm4_lockargs *args, nlm4_res *res,
 122     CLIENT *client, rpcvers_t vers)
 123 {
 124         if (vers == NLM4_VERS) {
 125                 return (nlm4_lock_4(args, res, client));
 126         } else {
 127                 nlm_lockargs args1;
 128                 nlm_res res1;
 129                 enum clnt_stat stat;
 130
 131                 args1.cookie = args->cookie;
 132                 args1.block = args->block;
 133                 args1.exclusive = args->exclusive;
 134                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
 135                 args1.reclaim = args->reclaim;
 136                 args1.state = args->state;
 137                 (void) memset(&res1, 0, sizeof (res1));
 138
 139                 stat = nlm_lock_1(&args1, &res1, client);
 140
 141                 if (stat == RPC_SUCCESS) {
 142                         nlm_convert_to_nlm4_res(res, &res1);
 143                 }
 144
 145                 return (stat);
 146         }
 147 }
 148
 149 enum clnt_stat
 150 nlm_cancel_rpc(nlm4_cancargs *args, nlm4_res *res,
 151     CLIENT *client, rpcvers_t vers)
 152 {
 153         if (vers == NLM4_VERS) {
 154                 return (nlm4_cancel_4(args, res, client));
 155         } else {
 156                 nlm_cancargs args1;
 157                 nlm_res res1;
 158                 enum clnt_stat stat;
 159
 160                 args1.cookie = args->cookie;
 161                 args1.block = args->block;
 162                 args1.exclusive = args->exclusive;
 163                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
 164                 (void) memset(&res1, 0, sizeof (res1));
 165
 166                 stat = nlm_cancel_1(&args1, &res1, client);
 167
 168                 if (stat == RPC_SUCCESS) {
 169                         nlm_convert_to_nlm4_res(res, &res1);
 170                 }
 171
 172                 return (stat);
 173         }
 174 }
 175
 176 enum clnt_stat
 177 nlm_unlock_rpc(nlm4_unlockargs *args, nlm4_res *res,
 178     CLIENT *client, rpcvers_t vers)
 179 {
 180         if (vers == NLM4_VERS) {
 181                 return (nlm4_unlock_4(args, res, client));
 182         } else {
 183                 nlm_unlockargs args1;
 184                 nlm_res res1;
 185                 enum clnt_stat stat;
 186
 187                 args1.cookie = args->cookie;
 188                 nlm_convert_to_nlm_lock(&args1.alock, &args->alock);
 189                 (void) memset(&res1, 0, sizeof (res1));
 190
 191                 stat = nlm_unlock_1(&args1, &res1, client);
 192
 193                 if (stat == RPC_SUCCESS) {
 194                         nlm_convert_to_nlm4_res(res, &res1);
 195                 }
 196
 197                 return (stat);
 198         }
 199 }
 200
 201 enum clnt_stat
 202 nlm_null_rpc(CLIENT *client, rpcvers_t vers)
 203 {
 204         if (vers == NLM4_VERS)
 205                 return (nlm4_null_4(NULL, NULL, client));
 206
 207         return (nlm_null_1(NULL, NULL, client));
 208 }
 209
 210 /*
 211  * Share reservations
 212  */
 213
 214 static void
 215 nlm_convert_to_nlm_share(struct nlm_share *dst, struct nlm4_share *src)
 216 {
 217
 218         dst->caller_name = src->caller_name;
 219         dst->fh = src->fh;
 220         dst->oh = src->oh;
 221         dst->mode = src->mode;
 222         dst->access = src->access;
 223 }
 224
 225 static void
 226 nlm_convert_to_nlm4_shres(struct nlm4_shareres *dst,
 227         struct nlm_shareres *src)
 228 {
 229         dst->cookie = src->cookie;
 230         dst->stat = (enum nlm4_stats) src->stat;
 231         dst->sequence = src->sequence;
 232 }
 233
 234
 235 enum clnt_stat
 236 nlm_share_rpc(nlm4_shareargs *args, nlm4_shareres *res,
 237     CLIENT *client, rpcvers_t vers)
 238 {
 239         if (vers == NLM4_VERS) {
 240                 return (nlm4_share_4(args, res, client));
 241         } else {
 242                 nlm_shareargs args3;
 243                 nlm_shareres res3;
 244                 enum clnt_stat stat;
 245
 246                 args3.cookie = args->cookie;
 247                 nlm_convert_to_nlm_share(&args3.share, &args->share);
 248                 args3.reclaim = args->reclaim;
 249                 (void) memset(&res3, 0, sizeof (res3));
 250
 251                 stat = nlm_share_3(&args3, &res3, client);
 252
 253                 if (stat == RPC_SUCCESS) {
 254                         nlm_convert_to_nlm4_shres(res, &res3);
 255                 }
 256
 257                 return (stat);
 258         }
 259 }
 260
 261 enum clnt_stat
 262 nlm_unshare_rpc(nlm4_shareargs *args, nlm4_shareres *res,
 263     CLIENT *client, rpcvers_t vers)
 264 {
 265         if (vers == NLM4_VERS) {
 266                 return (nlm4_unshare_4(args, res, client));
 267         } else {
 268                 nlm_shareargs args3;
 269                 nlm_shareres res3;
 270                 enum clnt_stat stat;
 271
 272                 args3.cookie = args->cookie;
 273                 nlm_convert_to_nlm_share(&args3.share, &args->share);
 274                 args3.reclaim = args->reclaim;
 275                 (void) memset(&res3, 0, sizeof (res3));
 276
 277                 stat = nlm_unshare_3(&args3, &res3, client);
 278
 279                 if (stat == RPC_SUCCESS) {
 280                         nlm_convert_to_nlm4_shres(res, &res3);
 281                 }
 282
 283                 return (stat);
 284         }
 285 }