LXR linux/fs/nfs/internal.h

   1/*
   2 * NFS internal definitions
   3 */
   4
   5#include "nfs4_fs.h"
   6#include <linux/mount.h>
   7#include <linux/security.h>
   8
   9#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
  10
  11struct nfs_string;
  12
  13/* Maximum number of readahead requests
  14 * FIXME: this should really be a sysctl so that users may tune it to suit
  15 *        their needs. People that do NFS over a slow network, might for
  16 *        instance want to reduce it to something closer to 1 for improved
  17 *        interactive response.
  18 */
  19#define NFS_MAX_READAHEAD       (RPC_DEF_SLOT_TABLE - 1)
  20
  21/*
  22 * Determine if sessions are in use.
  23 */
  24static inline int nfs4_has_session(const struct nfs_client *clp)
  25{
  26#ifdef CONFIG_NFS_V4_1
  27        if (clp->cl_session)
  28                return 1;
  29#endif /* CONFIG_NFS_V4_1 */
  30        return 0;
  31}
  32
  33static inline int nfs4_has_persistent_session(const struct nfs_client *clp)
  34{
  35#ifdef CONFIG_NFS_V4_1
  36        if (nfs4_has_session(clp))
  37                return (clp->cl_session->flags & SESSION4_PERSIST);
  38#endif /* CONFIG_NFS_V4_1 */
  39        return 0;
  40}
  41
  42struct nfs_clone_mount {
  43        const struct super_block *sb;
  44        const struct dentry *dentry;
  45        struct nfs_fh *fh;
  46        struct nfs_fattr *fattr;
  47        char *hostname;
  48        char *mnt_path;
  49        struct sockaddr *addr;
  50        size_t addrlen;
  51        rpc_authflavor_t authflavor;
  52};
  53
  54/*
  55 * Note: RFC 1813 doesn't limit the number of auth flavors that
  56 * a server can return, so make something up.
  57 */
  58#define NFS_MAX_SECFLAVORS      (12)
  59
  60/*
  61 * Value used if the user did not specify a port value.
  62 */
  63#define NFS_UNSPEC_PORT         (-1)
  64
  65/*
  66 * Maximum number of pages that readdir can use for creating
  67 * a vmapped array of pages.
  68 */
  69#define NFS_MAX_READDIR_PAGES 8
  70
  71/*
  72 * In-kernel mount arguments
  73 */
  74struct nfs_parsed_mount_data {
  75        int                     flags;
  76        int                     rsize, wsize;
  77        int                     timeo, retrans;
  78        int                     acregmin, acregmax,
  79                                acdirmin, acdirmax;
  80        int                     namlen;
  81        unsigned int            options;
  82        unsigned int            bsize;
  83        unsigned int            auth_flavor_len;
  84        rpc_authflavor_t        auth_flavors[1];
  85        char                    *client_address;
  86        unsigned int            version;
  87        unsigned int            minorversion;
  88        char                    *fscache_uniq;
  89
  90        struct {
  91                struct sockaddr_storage address;
  92                size_t                  addrlen;
  93                char                    *hostname;
  94                u32                     version;
  95                int                     port;
  96                unsigned short          protocol;
  97        } mount_server;
  98
  99        struct {
 100                struct sockaddr_storage address;
 101                size_t                  addrlen;
 102                char                    *hostname;
 103                char                    *export_path;
 104                int                     port;
 105                unsigned short          protocol;
 106        } nfs_server;
 107
 108        struct security_mnt_opts lsm_opts;
 109};
 110
 111/* mount_clnt.c */
 112struct nfs_mount_request {
 113        struct sockaddr         *sap;
 114        size_t                  salen;
 115        char                    *hostname;
 116        char                    *dirpath;
 117        u32                     version;
 118        unsigned short          protocol;
 119        struct nfs_fh           *fh;
 120        int                     noresvport;
 121        unsigned int            *auth_flav_len;
 122        rpc_authflavor_t        *auth_flavs;
 123};
 124
 125extern int nfs_mount(struct nfs_mount_request *info);
 126extern void nfs_umount(const struct nfs_mount_request *info);
 127
 128/* client.c */
 129extern struct rpc_program nfs_program;
 130
 131extern void nfs_cleanup_cb_ident_idr(void);
 132extern void nfs_put_client(struct nfs_client *);
 133extern struct nfs_client *nfs4_find_client_no_ident(const struct sockaddr *);
 134extern struct nfs_client *nfs4_find_client_ident(int);
 135extern struct nfs_client *
 136nfs4_find_client_sessionid(const struct sockaddr *, struct nfs4_sessionid *);
 137extern struct nfs_server *nfs_create_server(
 138                                        const struct nfs_parsed_mount_data *,
 139                                        struct nfs_fh *);
 140extern struct nfs_server *nfs4_create_server(
 141                                        const struct nfs_parsed_mount_data *,
 142                                        struct nfs_fh *);
 143extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
 144                                                      struct nfs_fh *);
 145extern void nfs_free_server(struct nfs_server *server);
 146extern struct nfs_server *nfs_clone_server(struct nfs_server *,
 147                                           struct nfs_fh *,
 148                                           struct nfs_fattr *);
 149extern void nfs_mark_client_ready(struct nfs_client *clp, int state);
 150extern int nfs4_check_client_ready(struct nfs_client *clp);
 151#ifdef CONFIG_PROC_FS
 152extern int __init nfs_fs_proc_init(void);
 153extern void nfs_fs_proc_exit(void);
 154#else
 155static inline int nfs_fs_proc_init(void)
 156{
 157        return 0;
 158}
 159static inline void nfs_fs_proc_exit(void)
 160{
 161}
 162#endif
 163
 164/* nfs4namespace.c */
 165#ifdef CONFIG_NFS_V4
 166extern struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry);
 167#else
 168static inline
 169struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
 170{
 171        return ERR_PTR(-ENOENT);
 172}
 173#endif
 174
 175/* callback_xdr.c */
 176extern struct svc_version nfs4_callback_version1;
 177extern struct svc_version nfs4_callback_version4;
 178
 179/* pagelist.c */
 180extern int __init nfs_init_nfspagecache(void);
 181extern void nfs_destroy_nfspagecache(void);
 182extern int __init nfs_init_readpagecache(void);
 183extern void nfs_destroy_readpagecache(void);
 184extern int __init nfs_init_writepagecache(void);
 185extern void nfs_destroy_writepagecache(void);
 186
 187extern int __init nfs_init_directcache(void);
 188extern void nfs_destroy_directcache(void);
 189
 190/* nfs2xdr.c */
 191extern int nfs_stat_to_errno(enum nfs_stat);
 192extern struct rpc_procinfo nfs_procedures[];
 193extern int nfs2_decode_dirent(struct xdr_stream *,
 194                                struct nfs_entry *, int);
 195
 196/* nfs3xdr.c */
 197extern struct rpc_procinfo nfs3_procedures[];
 198extern int nfs3_decode_dirent(struct xdr_stream *,
 199                                struct nfs_entry *, int);
 200
 201/* nfs4xdr.c */
 202#ifdef CONFIG_NFS_V4
 203extern int nfs4_decode_dirent(struct xdr_stream *,
 204                                struct nfs_entry *, int);
 205#endif
 206#ifdef CONFIG_NFS_V4_1
 207extern const u32 nfs41_maxread_overhead;
 208extern const u32 nfs41_maxwrite_overhead;
 209#endif
 210
 211/* nfs4proc.c */
 212#ifdef CONFIG_NFS_V4
 213extern struct rpc_procinfo nfs4_procedures[];
 214#endif
 215
 216/* proc.c */
 217void nfs_close_context(struct nfs_open_context *ctx, int is_sync);
 218
 219/* dir.c */
 220extern int nfs_access_cache_shrinker(struct shrinker *shrink,
 221                                        int nr_to_scan, gfp_t gfp_mask);
 222
 223/* inode.c */
 224extern struct workqueue_struct *nfsiod_workqueue;
 225extern struct inode *nfs_alloc_inode(struct super_block *sb);
 226extern void nfs_destroy_inode(struct inode *);
 227extern int nfs_write_inode(struct inode *, struct writeback_control *);
 228extern void nfs_evict_inode(struct inode *);
 229#ifdef CONFIG_NFS_V4
 230extern void nfs4_evict_inode(struct inode *);
 231#endif
 232void nfs_zap_acl_cache(struct inode *inode);
 233extern int nfs_wait_bit_killable(void *word);
 234
 235/* super.c */
 236extern struct file_system_type nfs_xdev_fs_type;
 237#ifdef CONFIG_NFS_V4
 238extern struct file_system_type nfs4_xdev_fs_type;
 239extern struct file_system_type nfs4_referral_fs_type;
 240#endif
 241
 242extern struct rpc_stat nfs_rpcstat;
 243
 244extern int __init register_nfs_fs(void);
 245extern void __exit unregister_nfs_fs(void);
 246extern void nfs_sb_active(struct super_block *sb);
 247extern void nfs_sb_deactive(struct super_block *sb);
 248
 249/* namespace.c */
 250extern char *nfs_path(const char *base,
 251                      const struct dentry *droot,
 252                      const struct dentry *dentry,
 253                      char *buffer, ssize_t buflen);
 254extern struct vfsmount *nfs_d_automount(struct path *path);
 255
 256/* getroot.c */
 257extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *);
 258#ifdef CONFIG_NFS_V4
 259extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *);
 260
 261extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh);
 262#endif
 263
 264/* read.c */
 265extern void nfs_read_prepare(struct rpc_task *task, void *calldata);
 266
 267/* write.c */
 268extern void nfs_write_prepare(struct rpc_task *task, void *calldata);
 269#ifdef CONFIG_MIGRATION
 270extern int nfs_migrate_page(struct address_space *,
 271                struct page *, struct page *);
 272#else
 273#define nfs_migrate_page NULL
 274#endif
 275
 276/* nfs4proc.c */
 277extern int _nfs4_call_sync(struct nfs_server *server,
 278                           struct rpc_message *msg,
 279                           struct nfs4_sequence_args *args,
 280                           struct nfs4_sequence_res *res,
 281                           int cache_reply);
 282extern int _nfs4_call_sync_session(struct nfs_server *server,
 283                                   struct rpc_message *msg,
 284                                   struct nfs4_sequence_args *args,
 285                                   struct nfs4_sequence_res *res,
 286                                   int cache_reply);
 287
 288/*
 289 * Determine the device name as a string
 290 */
 291static inline char *nfs_devname(const struct vfsmount *mnt_parent,
 292                                const struct dentry *dentry,
 293                                char *buffer, ssize_t buflen)
 294{
 295        return nfs_path(mnt_parent->mnt_devname, mnt_parent->mnt_root,
 296                        dentry, buffer, buflen);
 297}
 298
 299/*
 300 * Determine the actual block size (and log2 thereof)
 301 */
 302static inline
 303unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
 304{
 305        /* make sure blocksize is a power of two */
 306        if ((bsize & (bsize - 1)) || nrbitsp) {
 307                unsigned char   nrbits;
 308
 309                for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
 310                        ;
 311                bsize = 1 << nrbits;
 312                if (nrbitsp)
 313                        *nrbitsp = nrbits;
 314        }
 315
 316        return bsize;
 317}
 318
 319/*
 320 * Calculate the number of 512byte blocks used.
 321 */
 322static inline blkcnt_t nfs_calc_block_size(u64 tsize)
 323{
 324        blkcnt_t used = (tsize + 511) >> 9;
 325        return (used > ULONG_MAX) ? ULONG_MAX : used;
 326}
 327
 328/*
 329 * Compute and set NFS server blocksize
 330 */
 331static inline
 332unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
 333{
 334        if (bsize < NFS_MIN_FILE_IO_SIZE)
 335                bsize = NFS_DEF_FILE_IO_SIZE;
 336        else if (bsize >= NFS_MAX_FILE_IO_SIZE)
 337                bsize = NFS_MAX_FILE_IO_SIZE;
 338
 339        return nfs_block_bits(bsize, nrbitsp);
 340}
 341
 342/*
 343 * Determine the maximum file size for a superblock
 344 */
 345static inline
 346void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
 347{
 348        sb->s_maxbytes = (loff_t)maxfilesize;
 349        if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
 350                sb->s_maxbytes = MAX_LFS_FILESIZE;
 351}
 352
 353/*
 354 * Determine the number of bytes of data the page contains
 355 */
 356static inline
 357unsigned int nfs_page_length(struct page *page)
 358{
 359        loff_t i_size = i_size_read(page->mapping->host);
 360
 361        if (i_size > 0) {
 362                pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
 363                if (page->index < end_index)
 364                        return PAGE_CACHE_SIZE;
 365                if (page->index == end_index)
 366                        return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1;
 367        }
 368        return 0;
 369}
 370
 371/*
 372 * Convert a umode to a dirent->d_type
 373 */
 374static inline
 375unsigned char nfs_umode_to_dtype(umode_t mode)
 376{
 377        return (mode >> 12) & 15;
 378}
 379
 380/*
 381 * Determine the number of pages in an array of length 'len' and
 382 * with a base offset of 'base'
 383 */
 384static inline
 385unsigned int nfs_page_array_len(unsigned int base, size_t len)
 386{
 387        return ((unsigned long)len + (unsigned long)base +
 388                PAGE_SIZE - 1) >> PAGE_SHIFT;
 389}
 390
 391/*
 392 * Helper for restarting RPC calls in the possible presence of NFSv4.1
 393 * sessions.
 394 */
 395static inline int nfs_restart_rpc(struct rpc_task *task, const struct nfs_client *clp)
 396{
 397        if (nfs4_has_session(clp))
 398                return rpc_restart_call_prepare(task);
 399        return rpc_restart_call(task);
 400}
 401