LCOV - code coverage report
Current view: top level - fs/lockd - svcproc.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 176 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 28 0.0 %
Branches: 0 85 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * linux/fs/lockd/svcproc.c
       4                 :            :  *
       5                 :            :  * Lockd server procedures. We don't implement the NLM_*_RES 
       6                 :            :  * procedures because we don't use the async procedures.
       7                 :            :  *
       8                 :            :  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/types.h>
      12                 :            : #include <linux/time.h>
      13                 :            : #include <linux/lockd/lockd.h>
      14                 :            : #include <linux/lockd/share.h>
      15                 :            : #include <linux/sunrpc/svc_xprt.h>
      16                 :            : 
      17                 :            : #define NLMDBG_FACILITY         NLMDBG_CLIENT
      18                 :            : 
      19                 :            : #ifdef CONFIG_LOCKD_V4
      20                 :            : static __be32
      21                 :          0 : cast_to_nlm(__be32 status, u32 vers)
      22                 :            : {
      23                 :            :         /* Note: status is assumed to be in network byte order !!! */
      24         [ #  # ]:          0 :         if (vers != 4){
      25      [ #  #  # ]:          0 :                 switch (status) {
      26                 :            :                 case nlm_granted:
      27                 :            :                 case nlm_lck_denied:
      28                 :            :                 case nlm_lck_denied_nolocks:
      29                 :            :                 case nlm_lck_blocked:
      30                 :            :                 case nlm_lck_denied_grace_period:
      31                 :            :                 case nlm_drop_reply:
      32                 :            :                         break;
      33                 :            :                 case nlm4_deadlock:
      34                 :            :                         status = nlm_lck_denied;
      35                 :          0 :                         break;
      36                 :            :                 default:
      37                 :            :                         status = nlm_lck_denied_nolocks;
      38                 :            :                 }
      39                 :            :         }
      40                 :            : 
      41                 :          0 :         return (status);
      42                 :            : }
      43                 :            : #define cast_status(status) (cast_to_nlm(status, rqstp->rq_vers))
      44                 :            : #else
      45                 :            : #define cast_status(status) (status)
      46                 :            : #endif
      47                 :            : 
      48                 :            : /*
      49                 :            :  * Obtain client and file from arguments
      50                 :            :  */
      51                 :            : static __be32
      52                 :          0 : nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
      53                 :            :                         struct nlm_host **hostp, struct nlm_file **filp)
      54                 :            : {
      55                 :            :         struct nlm_host         *host = NULL;
      56                 :          0 :         struct nlm_file         *file = NULL;
      57                 :            :         struct nlm_lock         *lock = &argp->lock;
      58                 :            :         __be32                  error = 0;
      59                 :            : 
      60                 :            :         /* nfsd callbacks must have been installed for this procedure */
      61         [ #  # ]:          0 :         if (!nlmsvc_ops)
      62                 :            :                 return nlm_lck_denied_nolocks;
      63                 :            : 
      64                 :            :         /* Obtain host handle */
      65         [ #  # ]:          0 :         if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len))
      66   [ #  #  #  # ]:          0 :          || (argp->monitor && nsm_monitor(host) < 0))
      67                 :            :                 goto no_locks;
      68                 :          0 :         *hostp = host;
      69                 :            : 
      70                 :            :         /* Obtain file pointer. Not used by FREE_ALL call. */
      71         [ #  # ]:          0 :         if (filp != NULL) {
      72                 :          0 :                 error = cast_status(nlm_lookup_file(rqstp, &file, &lock->fh));
      73         [ #  # ]:          0 :                 if (error != 0)
      74                 :            :                         goto no_locks;
      75                 :          0 :                 *filp = file;
      76                 :            : 
      77                 :            :                 /* Set up the missing parts of the file_lock structure */
      78                 :          0 :                 lock->fl.fl_file  = file->f_file;
      79                 :          0 :                 lock->fl.fl_pid = current->tgid;
      80                 :          0 :                 lock->fl.fl_lmops = &nlmsvc_lock_operations;
      81                 :          0 :                 nlmsvc_locks_init_private(&lock->fl, host, (pid_t)lock->svid);
      82         [ #  # ]:          0 :                 if (!lock->fl.fl_owner) {
      83                 :            :                         /* lockowner allocation has failed */
      84                 :          0 :                         nlmsvc_release_host(host);
      85                 :          0 :                         return nlm_lck_denied_nolocks;
      86                 :            :                 }
      87                 :            :         }
      88                 :            : 
      89                 :            :         return 0;
      90                 :            : 
      91                 :            : no_locks:
      92                 :          0 :         nlmsvc_release_host(host);
      93         [ #  # ]:          0 :         if (error)
      94                 :          0 :                 return error;
      95                 :            :         return nlm_lck_denied_nolocks;
      96                 :            : }
      97                 :            : 
      98                 :            : /*
      99                 :            :  * NULL: Test for presence of service
     100                 :            :  */
     101                 :            : static __be32
     102                 :          0 : nlmsvc_proc_null(struct svc_rqst *rqstp)
     103                 :            : {
     104                 :            :         dprintk("lockd: NULL          called\n");
     105                 :          0 :         return rpc_success;
     106                 :            : }
     107                 :            : 
     108                 :            : /*
     109                 :            :  * TEST: Check for conflicting lock
     110                 :            :  */
     111                 :            : static __be32
     112                 :          0 : __nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp)
     113                 :            : {
     114                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     115                 :            :         struct nlm_host *host;
     116                 :            :         struct nlm_file *file;
     117                 :            :         __be32 rc = rpc_success;
     118                 :            : 
     119                 :            :         dprintk("lockd: TEST          called\n");
     120                 :          0 :         resp->cookie = argp->cookie;
     121                 :            : 
     122                 :            :         /* Obtain client and file */
     123         [ #  # ]:          0 :         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
     124         [ #  # ]:          0 :                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
     125                 :            : 
     126                 :            :         /* Now check for conflicting locks */
     127                 :          0 :         resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie));
     128         [ #  # ]:          0 :         if (resp->status == nlm_drop_reply)
     129                 :            :                 rc = rpc_drop_reply;
     130                 :            :         else
     131                 :            :                 dprintk("lockd: TEST          status %d vers %d\n",
     132                 :            :                         ntohl(resp->status), rqstp->rq_vers);
     133                 :            : 
     134                 :          0 :         nlmsvc_release_lockowner(&argp->lock);
     135                 :          0 :         nlmsvc_release_host(host);
     136                 :          0 :         nlm_release_file(file);
     137                 :          0 :         return rc;
     138                 :            : }
     139                 :            : 
     140                 :            : static __be32
     141                 :          0 : nlmsvc_proc_test(struct svc_rqst *rqstp)
     142                 :            : {
     143                 :          0 :         return __nlmsvc_proc_test(rqstp, rqstp->rq_resp);
     144                 :            : }
     145                 :            : 
     146                 :            : static __be32
     147                 :          0 : __nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
     148                 :            : {
     149                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     150                 :            :         struct nlm_host *host;
     151                 :            :         struct nlm_file *file;
     152                 :            :         __be32 rc = rpc_success;
     153                 :            : 
     154                 :            :         dprintk("lockd: LOCK          called\n");
     155                 :            : 
     156                 :          0 :         resp->cookie = argp->cookie;
     157                 :            : 
     158                 :            :         /* Obtain client and file */
     159         [ #  # ]:          0 :         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
     160         [ #  # ]:          0 :                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
     161                 :            : 
     162                 :            : #if 0
     163                 :            :         /* If supplied state doesn't match current state, we assume it's
     164                 :            :          * an old request that time-warped somehow. Any error return would
     165                 :            :          * do in this case because it's irrelevant anyway.
     166                 :            :          *
     167                 :            :          * NB: We don't retrieve the remote host's state yet.
     168                 :            :          */
     169                 :            :         if (host->h_nsmstate && host->h_nsmstate != argp->state) {
     170                 :            :                 resp->status = nlm_lck_denied_nolocks;
     171                 :            :         } else
     172                 :            : #endif
     173                 :            : 
     174                 :            :         /* Now try to lock the file */
     175                 :          0 :         resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
     176                 :            :                                                argp->block, &argp->cookie,
     177                 :            :                                                argp->reclaim));
     178         [ #  # ]:          0 :         if (resp->status == nlm_drop_reply)
     179                 :            :                 rc = rpc_drop_reply;
     180                 :            :         else
     181                 :            :                 dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
     182                 :            : 
     183                 :          0 :         nlmsvc_release_lockowner(&argp->lock);
     184                 :          0 :         nlmsvc_release_host(host);
     185                 :          0 :         nlm_release_file(file);
     186                 :          0 :         return rc;
     187                 :            : }
     188                 :            : 
     189                 :            : static __be32
     190                 :          0 : nlmsvc_proc_lock(struct svc_rqst *rqstp)
     191                 :            : {
     192                 :          0 :         return __nlmsvc_proc_lock(rqstp, rqstp->rq_resp);
     193                 :            : }
     194                 :            : 
     195                 :            : static __be32
     196                 :          0 : __nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
     197                 :            : {
     198                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     199                 :            :         struct nlm_host *host;
     200                 :            :         struct nlm_file *file;
     201         [ #  # ]:          0 :         struct net *net = SVC_NET(rqstp);
     202                 :            : 
     203                 :            :         dprintk("lockd: CANCEL        called\n");
     204                 :            : 
     205                 :          0 :         resp->cookie = argp->cookie;
     206                 :            : 
     207                 :            :         /* Don't accept requests during grace period */
     208         [ #  # ]:          0 :         if (locks_in_grace(net)) {
     209                 :          0 :                 resp->status = nlm_lck_denied_grace_period;
     210                 :          0 :                 return rpc_success;
     211                 :            :         }
     212                 :            : 
     213                 :            :         /* Obtain client and file */
     214         [ #  # ]:          0 :         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
     215         [ #  # ]:          0 :                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
     216                 :            : 
     217                 :            :         /* Try to cancel request. */
     218                 :          0 :         resp->status = cast_status(nlmsvc_cancel_blocked(net, file, &argp->lock));
     219                 :            : 
     220                 :            :         dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
     221                 :          0 :         nlmsvc_release_lockowner(&argp->lock);
     222                 :          0 :         nlmsvc_release_host(host);
     223                 :          0 :         nlm_release_file(file);
     224                 :          0 :         return rpc_success;
     225                 :            : }
     226                 :            : 
     227                 :            : static __be32
     228                 :          0 : nlmsvc_proc_cancel(struct svc_rqst *rqstp)
     229                 :            : {
     230                 :          0 :         return __nlmsvc_proc_cancel(rqstp, rqstp->rq_resp);
     231                 :            : }
     232                 :            : 
     233                 :            : /*
     234                 :            :  * UNLOCK: release a lock
     235                 :            :  */
     236                 :            : static __be32
     237                 :          0 : __nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp)
     238                 :            : {
     239                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     240                 :            :         struct nlm_host *host;
     241                 :            :         struct nlm_file *file;
     242         [ #  # ]:          0 :         struct net *net = SVC_NET(rqstp);
     243                 :            : 
     244                 :            :         dprintk("lockd: UNLOCK        called\n");
     245                 :            : 
     246                 :          0 :         resp->cookie = argp->cookie;
     247                 :            : 
     248                 :            :         /* Don't accept new lock requests during grace period */
     249         [ #  # ]:          0 :         if (locks_in_grace(net)) {
     250                 :          0 :                 resp->status = nlm_lck_denied_grace_period;
     251                 :          0 :                 return rpc_success;
     252                 :            :         }
     253                 :            : 
     254                 :            :         /* Obtain client and file */
     255         [ #  # ]:          0 :         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
     256         [ #  # ]:          0 :                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
     257                 :            : 
     258                 :            :         /* Now try to remove the lock */
     259                 :          0 :         resp->status = cast_status(nlmsvc_unlock(net, file, &argp->lock));
     260                 :            : 
     261                 :            :         dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
     262                 :          0 :         nlmsvc_release_lockowner(&argp->lock);
     263                 :          0 :         nlmsvc_release_host(host);
     264                 :          0 :         nlm_release_file(file);
     265                 :          0 :         return rpc_success;
     266                 :            : }
     267                 :            : 
     268                 :            : static __be32
     269                 :          0 : nlmsvc_proc_unlock(struct svc_rqst *rqstp)
     270                 :            : {
     271                 :          0 :         return __nlmsvc_proc_unlock(rqstp, rqstp->rq_resp);
     272                 :            : }
     273                 :            : 
     274                 :            : /*
     275                 :            :  * GRANTED: A server calls us to tell that a process' lock request
     276                 :            :  * was granted
     277                 :            :  */
     278                 :            : static __be32
     279                 :          0 : __nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp)
     280                 :            : {
     281                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     282                 :            : 
     283                 :          0 :         resp->cookie = argp->cookie;
     284                 :            : 
     285                 :            :         dprintk("lockd: GRANTED       called\n");
     286                 :          0 :         resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
     287                 :            :         dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
     288                 :          0 :         return rpc_success;
     289                 :            : }
     290                 :            : 
     291                 :            : static __be32
     292                 :          0 : nlmsvc_proc_granted(struct svc_rqst *rqstp)
     293                 :            : {
     294                 :          0 :         return __nlmsvc_proc_granted(rqstp, rqstp->rq_resp);
     295                 :            : }
     296                 :            : 
     297                 :            : /*
     298                 :            :  * This is the generic lockd callback for async RPC calls
     299                 :            :  */
     300                 :          0 : static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
     301                 :            : {
     302                 :            :         dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
     303                 :            :                         -task->tk_status);
     304                 :          0 : }
     305                 :            : 
     306                 :          0 : void nlmsvc_release_call(struct nlm_rqst *call)
     307                 :            : {
     308         [ #  # ]:          0 :         if (!refcount_dec_and_test(&call->a_count))
     309                 :          0 :                 return;
     310                 :          0 :         nlmsvc_release_host(call->a_host);
     311                 :          0 :         kfree(call);
     312                 :            : }
     313                 :            : 
     314                 :          0 : static void nlmsvc_callback_release(void *data)
     315                 :            : {
     316                 :          0 :         nlmsvc_release_call(data);
     317                 :          0 : }
     318                 :            : 
     319                 :            : static const struct rpc_call_ops nlmsvc_callback_ops = {
     320                 :            :         .rpc_call_done = nlmsvc_callback_exit,
     321                 :            :         .rpc_release = nlmsvc_callback_release,
     322                 :            : };
     323                 :            : 
     324                 :            : /*
     325                 :            :  * `Async' versions of the above service routines. They aren't really,
     326                 :            :  * because we send the callback before the reply proper. I hope this
     327                 :            :  * doesn't break any clients.
     328                 :            :  */
     329                 :          0 : static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc,
     330                 :            :                 __be32 (*func)(struct svc_rqst *, struct nlm_res *))
     331                 :            : {
     332                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     333                 :            :         struct nlm_host *host;
     334                 :            :         struct nlm_rqst *call;
     335                 :            :         __be32 stat;
     336                 :            : 
     337                 :          0 :         host = nlmsvc_lookup_host(rqstp,
     338                 :          0 :                                   argp->lock.caller,
     339                 :            :                                   argp->lock.len);
     340         [ #  # ]:          0 :         if (host == NULL)
     341                 :            :                 return rpc_system_err;
     342                 :            : 
     343                 :          0 :         call = nlm_alloc_call(host);
     344                 :          0 :         nlmsvc_release_host(host);
     345         [ #  # ]:          0 :         if (call == NULL)
     346                 :            :                 return rpc_system_err;
     347                 :            : 
     348                 :          0 :         stat = func(rqstp, &call->a_res);
     349         [ #  # ]:          0 :         if (stat != 0) {
     350                 :          0 :                 nlmsvc_release_call(call);
     351                 :          0 :                 return stat;
     352                 :            :         }
     353                 :            : 
     354                 :          0 :         call->a_flags = RPC_TASK_ASYNC;
     355         [ #  # ]:          0 :         if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
     356                 :            :                 return rpc_system_err;
     357                 :          0 :         return rpc_success;
     358                 :            : }
     359                 :            : 
     360                 :          0 : static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp)
     361                 :            : {
     362                 :            :         dprintk("lockd: TEST_MSG      called\n");
     363                 :          0 :         return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, __nlmsvc_proc_test);
     364                 :            : }
     365                 :            : 
     366                 :          0 : static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp)
     367                 :            : {
     368                 :            :         dprintk("lockd: LOCK_MSG      called\n");
     369                 :          0 :         return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, __nlmsvc_proc_lock);
     370                 :            : }
     371                 :            : 
     372                 :          0 : static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp)
     373                 :            : {
     374                 :            :         dprintk("lockd: CANCEL_MSG    called\n");
     375                 :          0 :         return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, __nlmsvc_proc_cancel);
     376                 :            : }
     377                 :            : 
     378                 :            : static __be32
     379                 :          0 : nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp)
     380                 :            : {
     381                 :            :         dprintk("lockd: UNLOCK_MSG    called\n");
     382                 :          0 :         return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlmsvc_proc_unlock);
     383                 :            : }
     384                 :            : 
     385                 :            : static __be32
     386                 :          0 : nlmsvc_proc_granted_msg(struct svc_rqst *rqstp)
     387                 :            : {
     388                 :            :         dprintk("lockd: GRANTED_MSG   called\n");
     389                 :          0 :         return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, __nlmsvc_proc_granted);
     390                 :            : }
     391                 :            : 
     392                 :            : /*
     393                 :            :  * SHARE: create a DOS share or alter existing share.
     394                 :            :  */
     395                 :            : static __be32
     396                 :          0 : nlmsvc_proc_share(struct svc_rqst *rqstp)
     397                 :            : {
     398                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     399                 :          0 :         struct nlm_res *resp = rqstp->rq_resp;
     400                 :            :         struct nlm_host *host;
     401                 :            :         struct nlm_file *file;
     402                 :            : 
     403                 :            :         dprintk("lockd: SHARE         called\n");
     404                 :            : 
     405                 :          0 :         resp->cookie = argp->cookie;
     406                 :            : 
     407                 :            :         /* Don't accept new lock requests during grace period */
     408   [ #  #  #  #  :          0 :         if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) {
                   #  # ]
     409                 :          0 :                 resp->status = nlm_lck_denied_grace_period;
     410                 :          0 :                 return rpc_success;
     411                 :            :         }
     412                 :            : 
     413                 :            :         /* Obtain client and file */
     414         [ #  # ]:          0 :         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
     415         [ #  # ]:          0 :                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
     416                 :            : 
     417                 :            :         /* Now try to create the share */
     418                 :          0 :         resp->status = cast_status(nlmsvc_share_file(host, file, argp));
     419                 :            : 
     420                 :            :         dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
     421                 :          0 :         nlmsvc_release_lockowner(&argp->lock);
     422                 :          0 :         nlmsvc_release_host(host);
     423                 :          0 :         nlm_release_file(file);
     424                 :          0 :         return rpc_success;
     425                 :            : }
     426                 :            : 
     427                 :            : /*
     428                 :            :  * UNSHARE: Release a DOS share.
     429                 :            :  */
     430                 :            : static __be32
     431                 :          0 : nlmsvc_proc_unshare(struct svc_rqst *rqstp)
     432                 :            : {
     433                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     434                 :          0 :         struct nlm_res *resp = rqstp->rq_resp;
     435                 :            :         struct nlm_host *host;
     436                 :            :         struct nlm_file *file;
     437                 :            : 
     438                 :            :         dprintk("lockd: UNSHARE       called\n");
     439                 :            : 
     440                 :          0 :         resp->cookie = argp->cookie;
     441                 :            : 
     442                 :            :         /* Don't accept requests during grace period */
     443   [ #  #  #  # ]:          0 :         if (locks_in_grace(SVC_NET(rqstp))) {
     444                 :          0 :                 resp->status = nlm_lck_denied_grace_period;
     445                 :          0 :                 return rpc_success;
     446                 :            :         }
     447                 :            : 
     448                 :            :         /* Obtain client and file */
     449         [ #  # ]:          0 :         if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
     450         [ #  # ]:          0 :                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
     451                 :            : 
     452                 :            :         /* Now try to unshare the file */
     453                 :          0 :         resp->status = cast_status(nlmsvc_unshare_file(host, file, argp));
     454                 :            : 
     455                 :            :         dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
     456                 :          0 :         nlmsvc_release_lockowner(&argp->lock);
     457                 :          0 :         nlmsvc_release_host(host);
     458                 :          0 :         nlm_release_file(file);
     459                 :          0 :         return rpc_success;
     460                 :            : }
     461                 :            : 
     462                 :            : /*
     463                 :            :  * NM_LOCK: Create an unmonitored lock
     464                 :            :  */
     465                 :            : static __be32
     466                 :          0 : nlmsvc_proc_nm_lock(struct svc_rqst *rqstp)
     467                 :            : {
     468                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     469                 :            : 
     470                 :            :         dprintk("lockd: NM_LOCK       called\n");
     471                 :            : 
     472                 :          0 :         argp->monitor = 0;           /* just clean the monitor flag */
     473                 :          0 :         return nlmsvc_proc_lock(rqstp);
     474                 :            : }
     475                 :            : 
     476                 :            : /*
     477                 :            :  * FREE_ALL: Release all locks and shares held by client
     478                 :            :  */
     479                 :            : static __be32
     480                 :          0 : nlmsvc_proc_free_all(struct svc_rqst *rqstp)
     481                 :            : {
     482                 :          0 :         struct nlm_args *argp = rqstp->rq_argp;
     483                 :            :         struct nlm_host *host;
     484                 :            : 
     485                 :            :         /* Obtain client */
     486         [ #  # ]:          0 :         if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL))
     487                 :            :                 return rpc_success;
     488                 :            : 
     489                 :          0 :         nlmsvc_free_host_resources(host);
     490                 :          0 :         nlmsvc_release_host(host);
     491                 :          0 :         return rpc_success;
     492                 :            : }
     493                 :            : 
     494                 :            : /*
     495                 :            :  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
     496                 :            :  */
     497                 :            : static __be32
     498                 :          0 : nlmsvc_proc_sm_notify(struct svc_rqst *rqstp)
     499                 :            : {
     500                 :          0 :         struct nlm_reboot *argp = rqstp->rq_argp;
     501                 :            : 
     502                 :            :         dprintk("lockd: SM_NOTIFY     called\n");
     503                 :            : 
     504         [ #  # ]:          0 :         if (!nlm_privileged_requester(rqstp)) {
     505                 :            :                 char buf[RPC_MAX_ADDRBUFLEN];
     506                 :          0 :                 printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
     507                 :            :                                 svc_print_addr(rqstp, buf, sizeof(buf)));
     508                 :            :                 return rpc_system_err;
     509                 :            :         }
     510                 :            : 
     511         [ #  # ]:          0 :         nlm_host_rebooted(SVC_NET(rqstp), argp);
     512                 :          0 :         return rpc_success;
     513                 :            : }
     514                 :            : 
     515                 :            : /*
     516                 :            :  * client sent a GRANTED_RES, let's remove the associated block
     517                 :            :  */
     518                 :            : static __be32
     519                 :          0 : nlmsvc_proc_granted_res(struct svc_rqst *rqstp)
     520                 :            : {
     521                 :          0 :         struct nlm_res *argp = rqstp->rq_argp;
     522                 :            : 
     523         [ #  # ]:          0 :         if (!nlmsvc_ops)
     524                 :            :                 return rpc_success;
     525                 :            : 
     526                 :            :         dprintk("lockd: GRANTED_RES   called\n");
     527                 :            : 
     528                 :          0 :         nlmsvc_grant_reply(&argp->cookie, argp->status);
     529                 :          0 :         return rpc_success;
     530                 :            : }
     531                 :            : 
     532                 :            : /*
     533                 :            :  * NLM Server procedures.
     534                 :            :  */
     535                 :            : 
     536                 :            : #define nlmsvc_encode_norep     nlmsvc_encode_void
     537                 :            : #define nlmsvc_decode_norep     nlmsvc_decode_void
     538                 :            : #define nlmsvc_decode_testres   nlmsvc_decode_void
     539                 :            : #define nlmsvc_decode_lockres   nlmsvc_decode_void
     540                 :            : #define nlmsvc_decode_unlockres nlmsvc_decode_void
     541                 :            : #define nlmsvc_decode_cancelres nlmsvc_decode_void
     542                 :            : #define nlmsvc_decode_grantedres        nlmsvc_decode_void
     543                 :            : 
     544                 :            : #define nlmsvc_proc_none        nlmsvc_proc_null
     545                 :            : #define nlmsvc_proc_test_res    nlmsvc_proc_null
     546                 :            : #define nlmsvc_proc_lock_res    nlmsvc_proc_null
     547                 :            : #define nlmsvc_proc_cancel_res  nlmsvc_proc_null
     548                 :            : #define nlmsvc_proc_unlock_res  nlmsvc_proc_null
     549                 :            : 
     550                 :            : struct nlm_void                 { int dummy; };
     551                 :            : 
     552                 :            : #define PROC(name, xargt, xrest, argt, rest, respsize)  \
     553                 :            :  { .pc_func     = nlmsvc_proc_##name,                   \
     554                 :            :    .pc_decode   = nlmsvc_decode_##xargt,                \
     555                 :            :    .pc_encode   = nlmsvc_encode_##xrest,                \
     556                 :            :    .pc_release  = NULL,                                 \
     557                 :            :    .pc_argsize  = sizeof(struct nlm_##argt),            \
     558                 :            :    .pc_ressize  = sizeof(struct nlm_##rest),            \
     559                 :            :    .pc_xdrressize = respsize,                           \
     560                 :            :  }
     561                 :            : 
     562                 :            : #define Ck      (1+XDR_QUADLEN(NLM_MAXCOOKIELEN))       /* cookie */
     563                 :            : #define St      1                               /* status */
     564                 :            : #define No      (1+1024/4)                      /* Net Obj */
     565                 :            : #define Rg      2                               /* range - offset + size */
     566                 :            : 
     567                 :            : const struct svc_procedure nlmsvc_procedures[] = {
     568                 :            :   PROC(null,            void,           void,           void,   void, 1),
     569                 :            :   PROC(test,            testargs,       testres,        args,   res, Ck+St+2+No+Rg),
     570                 :            :   PROC(lock,            lockargs,       res,            args,   res, Ck+St),
     571                 :            :   PROC(cancel,          cancargs,       res,            args,   res, Ck+St),
     572                 :            :   PROC(unlock,          unlockargs,     res,            args,   res, Ck+St),
     573                 :            :   PROC(granted,         testargs,       res,            args,   res, Ck+St),
     574                 :            :   PROC(test_msg,        testargs,       norep,          args,   void, 1),
     575                 :            :   PROC(lock_msg,        lockargs,       norep,          args,   void, 1),
     576                 :            :   PROC(cancel_msg,      cancargs,       norep,          args,   void, 1),
     577                 :            :   PROC(unlock_msg,      unlockargs,     norep,          args,   void, 1),
     578                 :            :   PROC(granted_msg,     testargs,       norep,          args,   void, 1),
     579                 :            :   PROC(test_res,        testres,        norep,          res,    void, 1),
     580                 :            :   PROC(lock_res,        lockres,        norep,          res,    void, 1),
     581                 :            :   PROC(cancel_res,      cancelres,      norep,          res,    void, 1),
     582                 :            :   PROC(unlock_res,      unlockres,      norep,          res,    void, 1),
     583                 :            :   PROC(granted_res,     res,            norep,          res,    void, 1),
     584                 :            :   /* statd callback */
     585                 :            :   PROC(sm_notify,       reboot,         void,           reboot, void, 1),
     586                 :            :   PROC(none,            void,           void,           void,   void, 1),
     587                 :            :   PROC(none,            void,           void,           void,   void, 1),
     588                 :            :   PROC(none,            void,           void,           void,   void, 1),
     589                 :            :   PROC(share,           shareargs,      shareres,       args,   res, Ck+St+1),
     590                 :            :   PROC(unshare,         shareargs,      shareres,       args,   res, Ck+St+1),
     591                 :            :   PROC(nm_lock,         lockargs,       res,            args,   res, Ck+St),
     592                 :            :   PROC(free_all,        notify,         void,           args,   void, 0),
     593                 :            : 
     594                 :            : };

Generated by: LCOV version 1.14