/* SPDX-License-Identifier: GPL-2.0 */ /* * linux/include/linux/lockd/lockd.h * * General-purpose lockd include file. * * Copyright (C) 1996 Olaf Kirch <[email protected]> */ #ifndef LINUX_LOCKD_LOCKD_H #define LINUX_LOCKD_LOCKD_H /* XXX: a lot of this should really be under fs/lockd. */ #include <linux/in.h> #include <linux/in6.h> #include <net/ipv6.h> #include <linux/fs.h> #include <linux/kref.h> #include <linux/refcount.h> #include <linux/utsname.h> #include <linux/lockd/bind.h> #include <linux/lockd/xdr.h> #ifdef CONFIG_LOCKD_V4 #include <linux/lockd/xdr4.h> #endif #include <linux/lockd/debug.h> #include <linux/sunrpc/svc.h> /* * Version string */ #define LOCKD_VERSION … /* * Default timeout for RPC calls (seconds) */ #define LOCKD_DFLT_TIMEO … /* * Lockd host handle (used both by the client and server personality). */ struct nlm_host { … }; /* * The largest string sm_addrbuf should hold is a full-size IPv6 address * (no "::" anywhere) with a scope ID. The buffer size is computed to * hold eight groups of colon-separated four-hex-digit numbers, a * percent sign, a scope id (at most 32 bits, in decimal), and NUL. */ #define NSM_ADDRBUF … struct nsm_handle { … }; /* * Rigorous type checking on sockaddr type conversions */ static inline struct sockaddr *nlm_addr(const struct nlm_host *host) { … } static inline struct sockaddr *nlm_srcaddr(const struct nlm_host *host) { … } /* * Map an fl_owner_t into a unique 32-bit "pid" */ struct nlm_lockowner { … }; /* * This is the representation of a blocked client lock. */ struct nlm_wait { … }; /* * Memory chunk for NLM client RPC request. */ #define NLMCLNT_OHSIZE … struct nlm_rqst { … }; /* * This struct describes a file held open by lockd on behalf of * an NFS client. */ struct nlm_file { … }; /* * This is a server block (i.e. a lock requested by some client which * couldn't be granted because of a conflicting lock). */ #define NLM_NEVER … /* timeout on non-blocking call: */ #define NLM_TIMEOUT … struct nlm_block { … }; /* * Global variables */ extern const struct rpc_program nlm_program; extern const struct svc_procedure nlmsvc_procedures[24]; #ifdef CONFIG_LOCKD_V4 extern const struct svc_procedure nlmsvc_procedures4[24]; #endif extern int nlmsvc_grace_period; extern unsigned long nlmsvc_timeout; extern bool nsm_use_hostnames; extern u32 nsm_local_state; extern struct timer_list nlmsvc_retry; /* * Lockd client functions */ struct nlm_rqst * nlm_alloc_call(struct nlm_host *host); int nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *); int nlm_async_reply(struct nlm_rqst *, u32, const struct rpc_call_ops *); void nlmclnt_release_call(struct nlm_rqst *); void nlmclnt_prepare_block(struct nlm_wait *block, struct nlm_host *host, struct file_lock *fl); void nlmclnt_queue_block(struct nlm_wait *block); __be32 nlmclnt_dequeue_block(struct nlm_wait *block); int nlmclnt_wait(struct nlm_wait *block, struct nlm_rqst *req, long timeout); __be32 nlmclnt_grant(const struct sockaddr *addr, const struct nlm_lock *lock); void nlmclnt_recovery(struct nlm_host *); int nlmclnt_reclaim(struct nlm_host *, struct file_lock *, struct nlm_rqst *); void nlmclnt_next_cookie(struct nlm_cookie *); /* * Host cache */ struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap, const size_t salen, const unsigned short protocol, const u32 version, const char *hostname, int noresvport, struct net *net, const struct cred *cred); void nlmclnt_release_host(struct nlm_host *); struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp, const char *hostname, const size_t hostname_len); void nlmsvc_release_host(struct nlm_host *); struct rpc_clnt * nlm_bind_host(struct nlm_host *); void nlm_rebind_host(struct nlm_host *); struct nlm_host * nlm_get_host(struct nlm_host *); void nlm_shutdown_hosts(void); void nlm_shutdown_hosts_net(struct net *net); void nlm_host_rebooted(const struct net *net, const struct nlm_reboot *); /* * Host monitoring */ int nsm_monitor(const struct nlm_host *host); void nsm_unmonitor(const struct nlm_host *host); struct nsm_handle *nsm_get_handle(const struct net *net, const struct sockaddr *sap, const size_t salen, const char *hostname, const size_t hostname_len); struct nsm_handle *nsm_reboot_lookup(const struct net *net, const struct nlm_reboot *info); void nsm_release(struct nsm_handle *nsm); /* * This is used in garbage collection and resource reclaim * A return value != 0 means destroy the lock/block/share */ nlm_host_match_fn_t; /* * Server-side lock handling */ int lock_to_openmode(struct file_lock *); __be32 nlmsvc_lock(struct svc_rqst *, struct nlm_file *, struct nlm_host *, struct nlm_lock *, int, struct nlm_cookie *, int); __be32 nlmsvc_unlock(struct net *net, struct nlm_file *, struct nlm_lock *); __be32 nlmsvc_testlock(struct svc_rqst *, struct nlm_file *, struct nlm_host *, struct nlm_lock *, struct nlm_lock *, struct nlm_cookie *); __be32 nlmsvc_cancel_blocked(struct net *net, struct nlm_file *, struct nlm_lock *); void nlmsvc_retry_blocked(struct svc_rqst *rqstp); void nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *, nlm_host_match_fn_t match); void nlmsvc_grant_reply(struct nlm_cookie *, __be32); void nlmsvc_release_call(struct nlm_rqst *); void nlmsvc_locks_init_private(struct file_lock *, struct nlm_host *, pid_t); /* * File handling for the server personality */ __be32 nlm_lookup_file(struct svc_rqst *, struct nlm_file **, struct nlm_lock *); void nlm_release_file(struct nlm_file *); void nlmsvc_put_lockowner(struct nlm_lockowner *); void nlmsvc_release_lockowner(struct nlm_lock *); void nlmsvc_mark_resources(struct net *); void nlmsvc_free_host_resources(struct nlm_host *); void nlmsvc_invalidate_all(void); /* * Cluster failover support */ int nlmsvc_unlock_all_by_sb(struct super_block *sb); int nlmsvc_unlock_all_by_ip(struct sockaddr *server_addr); static inline struct file *nlmsvc_file_file(struct nlm_file *file) { … } static inline struct inode *nlmsvc_file_inode(struct nlm_file *file) { … } static inline int __nlm_privileged_request4(const struct sockaddr *sap) { … } #if IS_ENABLED(CONFIG_IPV6) static inline int __nlm_privileged_request6(const struct sockaddr *sap) { … } #else /* IS_ENABLED(CONFIG_IPV6) */ static inline int __nlm_privileged_request6(const struct sockaddr *sap) { return 0; } #endif /* IS_ENABLED(CONFIG_IPV6) */ /* * Ensure incoming requests are from local privileged callers. * * Return TRUE if sender is local and is connecting via a privileged port; * otherwise return FALSE. */ static inline int nlm_privileged_requester(const struct svc_rqst *rqstp) { … } /* * Compare two NLM locks. * When the second lock is of type F_UNLCK, this acts like a wildcard. */ static inline int nlm_compare_locks(const struct file_lock *fl1, const struct file_lock *fl2) { … } extern const struct lock_manager_operations nlmsvc_lock_operations; #endif /* LINUX_LOCKD_LOCKD_H */
Codebase Browser
linux