LXR linux-old/include/linux/lockd/lockd.h

   1/*
   2 * linux/include/linux/lockd/lockd.h
   3 *
   4 * General-purpose lockd include file.
   5 *
   6 * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
   7 */
   8
   9#ifndef LINUX_LOCKD_LOCKD_H
  10#define LINUX_LOCKD_LOCKD_H
  11
  12#ifdef __KERNEL__
  13
  14#include <linux/config.h>
  15#include <linux/in.h>
  16#include <linux/fs.h>
  17#include <linux/utsname.h>
  18#include <linux/nfsd/nfsfh.h>
  19#include <linux/lockd/bind.h>
  20#include <linux/lockd/xdr.h>
  21#ifdef CONFIG_LOCKD_V4
  22#include <linux/lockd/xdr4.h>
  23#endif
  24#include <linux/lockd/debug.h>
  25
  26/*
  27 * Version string
  28 */
  29#define LOCKD_VERSION           "0.4"
  30
  31/*
  32 * Default timeout for RPC calls (seconds)
  33 */
  34#define LOCKD_DFLT_TIMEO        10
  35
  36/*
  37 * Lockd host handle (used both by the client and server personality).
  38 */
  39struct nlm_host {
  40        struct nlm_host *       h_next;         /* linked list (hash table) */
  41        struct sockaddr_in      h_addr;         /* peer address */
  42        struct svc_client *     h_exportent;    /* NFS client */
  43        struct rpc_clnt *       h_rpcclnt;      /* RPC client to talk to peer */
  44        char                    h_name[20];     /* remote hostname */
  45        u32                     h_version;      /* interface version */
  46        unsigned short          h_proto;        /* transport proto */
  47        unsigned short          h_authflavor;   /* RPC authentication type */
  48        unsigned short          h_reclaiming : 1,
  49                                h_inuse      : 1,
  50                                h_killed     : 1,
  51                                h_monitored  : 1;
  52        wait_queue_head_t       h_gracewait;    /* wait while reclaiming */
  53        u32                     h_state;        /* pseudo-state counter */
  54        u32                     h_nsmstate;     /* true remote NSM state */
  55        unsigned int            h_count;        /* reference count */
  56        struct semaphore        h_sema;         /* mutex for pmap binding */
  57        unsigned long           h_nextrebind;   /* next portmap call */
  58        unsigned long           h_expires;      /* eligible for GC */
  59};
  60
  61/*
  62 * Memory chunk for NLM client RPC request.
  63 */
  64#define NLMCLNT_OHSIZE          (sizeof(system_utsname.nodename)+10)
  65struct nlm_rqst {
  66        unsigned int            a_flags;        /* initial RPC task flags */
  67        struct nlm_host *       a_host;         /* host handle */
  68        struct nlm_args         a_args;         /* arguments */
  69        struct nlm_res          a_res;          /* result */
  70        char                    a_owner[NLMCLNT_OHSIZE];
  71};
  72
  73/*
  74 * This struct describes a file held open by lockd on behalf of
  75 * an NFS client.
  76 */
  77struct nlm_file {
  78        struct nlm_file *       f_next;         /* linked list */
  79        struct nfs_fh           f_handle;       /* NFS file handle */
  80        struct file             f_file;         /* VFS file pointer */
  81        struct nlm_share *      f_shares;       /* DOS shares */
  82        struct nlm_block *      f_blocks;       /* blocked locks */
  83        unsigned int            f_locks;        /* guesstimate # of locks */
  84        unsigned int            f_count;        /* reference count */
  85        struct semaphore        f_sema;         /* avoid concurrent access */
  86        int                     f_hash;         /* hash of f_handle */
  87};
  88
  89/*
  90 * This is a server block (i.e. a lock requested by some client which
  91 * couldn't be granted because of a conflicting lock).
  92 */
  93#define NLM_NEVER               (~(unsigned long) 0)
  94struct nlm_block {
  95        struct nlm_block *      b_next;         /* linked list (all blocks) */
  96        struct nlm_block *      b_fnext;        /* linked list (per file) */
  97        struct nlm_rqst         b_call;         /* RPC args & callback info */
  98        struct svc_serv *       b_daemon;       /* NLM service */
  99        struct nlm_host *       b_host;         /* host handle for RPC clnt */
 100        unsigned long           b_when;         /* next re-xmit */
 101        unsigned int            b_id;           /* block id */
 102        unsigned char           b_queued;       /* re-queued */
 103        unsigned char           b_granted;      /* VFS granted lock */
 104        unsigned char           b_incall;       /* doing callback */
 105        unsigned char           b_done;         /* callback complete */
 106        struct nlm_file *       b_file;         /* file in question */
 107};
 108
 109/*
 110 * Valid actions for nlmsvc_traverse_files
 111 */
 112#define NLM_ACT_CHECK           0               /* check for locks */
 113#define NLM_ACT_MARK            1               /* mark & sweep */
 114#define NLM_ACT_UNLOCK          2               /* release all locks */
 115
 116/*
 117 * Global variables
 118 */
 119extern struct rpc_program       nlm_program;
 120extern struct svc_procedure     nlmsvc_procedures[];
 121#ifdef CONFIG_LOCKD_V4
 122extern struct svc_procedure     nlmsvc_procedures4[];
 123#endif
 124extern int                      nlmsvc_grace_period;
 125extern unsigned long            nlmsvc_timeout;
 126
 127/*
 128 * Lockd client functions
 129 */
 130struct nlm_rqst * nlmclnt_alloc_call(void);
 131int               nlmclnt_call(struct nlm_rqst *, u32);
 132int               nlmclnt_async_call(struct nlm_rqst *, u32, rpc_action);
 133int               nlmclnt_block(struct nlm_host *, struct file_lock *, u32 *);
 134int               nlmclnt_cancel(struct nlm_host *, struct file_lock *);
 135u32               nlmclnt_grant(struct nlm_lock *);
 136void              nlmclnt_recovery(struct nlm_host *, u32);
 137int               nlmclnt_reclaim(struct nlm_host *, struct file_lock *);
 138int               nlmclnt_setgrantargs(struct nlm_rqst *, struct nlm_lock *);
 139void              nlmclnt_freegrantargs(struct nlm_rqst *);
 140
 141/*
 142 * Host cache
 143 */
 144struct nlm_host * nlmclnt_lookup_host(struct sockaddr_in *, int, int);
 145struct nlm_host * nlmsvc_lookup_host(struct svc_rqst *);
 146struct nlm_host * nlm_lookup_host(struct svc_client *,
 147                                        struct sockaddr_in *, int, int);
 148struct rpc_clnt * nlm_bind_host(struct nlm_host *);
 149void              nlm_rebind_host(struct nlm_host *);
 150struct nlm_host * nlm_get_host(struct nlm_host *);
 151void              nlm_release_host(struct nlm_host *);
 152void              nlm_shutdown_hosts(void);
 153
 154/*
 155 * Server-side lock handling
 156 */
 157int               nlmsvc_async_call(struct nlm_rqst *, u32, rpc_action);
 158u32               nlmsvc_lock(struct svc_rqst *, struct nlm_file *,
 159                                        struct nlm_lock *, int, struct nlm_cookie *);
 160u32               nlmsvc_unlock(struct nlm_file *, struct nlm_lock *);
 161u32               nlmsvc_testlock(struct nlm_file *, struct nlm_lock *,
 162                                        struct nlm_lock *);
 163u32               nlmsvc_cancel_blocked(struct nlm_file *, struct nlm_lock *);
 164unsigned long     nlmsvc_retry_blocked(void);
 165int               nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
 166                                        int action);
 167void      nlmsvc_grant_reply(struct svc_rqst *, struct nlm_cookie *, u32);
 168
 169/*
 170 * File handling for the server personality
 171 */
 172u32               nlm_lookup_file(struct svc_rqst *, struct nlm_file **,
 173                                        struct nfs_fh *);
 174void              nlm_release_file(struct nlm_file *);
 175void              nlmsvc_mark_resources(void);
 176void              nlmsvc_free_host_resources(struct nlm_host *);
 177
 178static __inline__ struct inode *
 179nlmsvc_file_inode(struct nlm_file *file)
 180{
 181        return file->f_file.f_dentry->d_inode;
 182}
 183
 184/*
 185 * Compare two host addresses (needs modifying for ipv6)
 186 */
 187static __inline__ int
 188nlm_cmp_addr(struct sockaddr_in *sin1, struct sockaddr_in *sin2)
 189{
 190        return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
 191}
 192
 193/*
 194 * Compare two NLM locks.
 195 * When the second lock is of type F_UNLCK, this acts like a wildcard.
 196 */
 197static __inline__ int
 198nlm_compare_locks(struct file_lock *fl1, struct file_lock *fl2)
 199{
 200        return  fl1->fl_pid   == fl2->fl_pid
 201             && fl1->fl_start == fl2->fl_start
 202             && fl1->fl_end   == fl2->fl_end
 203             &&(fl1->fl_type  == fl2->fl_type || fl2->fl_type == F_UNLCK);
 204}
 205
 206#endif /* __KERNEL__ */
 207
 208#endif /* LINUX_LOCKD_LOCKD_H */
 209