linux/fs/nfs/internal.h
<<
>>
Prefs 
   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 * In-kernel mount arguments
  67 */
  68struct nfs_parsed_mount_data {
  69        int                     flags;
  70        int                     rsize, wsize;
  71        int                     timeo, retrans;
  72        int                     acregmin, acregmax,
  73                                acdirmin, acdirmax;
  74        int                     namlen;
  75        unsigned int            options;
  76        unsigned int            bsize;
  77        unsigned int            auth_flavor_len;
  78        rpc_authflavor_t        auth_flavors[1];
  79        char                    *client_address;
  80        unsigned int            version;
  81        unsigned int            minorversion;
  82        char                    *fscache_uniq;
  83
  84        struct {
  85                struct sockaddr_storage address;
  86                size_t                  addrlen;
  87                char                    *hostname;
  88                u32                     version;
  89                int                     port;
  90                unsigned short          protocol;
  91        } mount_server;
  92
  93        struct {
  94                struct sockaddr_storage address;
  95                size_t                  addrlen;
  96                char                    *hostname;
  97                char                    *export_path;
  98                int                     port;
  99                unsigned short          protocol;
 100        } nfs_server;
 101
 102        struct security_mnt_opts lsm_opts;
 103};
 104
 105/* mount_clnt.c */
 106struct nfs_mount_request {
 107        struct sockaddr         *sap;
 108        size_t                  salen;
 109        char                    *hostname;
 110        char                    *dirpath;
 111        u32                     version;
 112        unsigned short          protocol;
 113        struct nfs_fh           *fh;
 114        int                     noresvport;
 115        unsigned int            *auth_flav_len;
 116        rpc_authflavor_t        *auth_flavs;
 117};
 118
 119extern int nfs_mount(struct nfs_mount_request *info);
 120extern void nfs_umount(const struct nfs_mount_request *info);
 121
 122/* client.c */
 123extern struct rpc_program nfs_program;
 124
 125extern void nfs_put_client(struct nfs_client *);
 126extern struct nfs_client *nfs_find_client(const struct sockaddr *, u32);
 127extern struct nfs_client *nfs_find_client_next(struct nfs_client *);
 128extern struct nfs_server *nfs_create_server(
 129                                        const struct nfs_parsed_mount_data *,
 130                                        struct nfs_fh *);
 131extern struct nfs_server *nfs4_create_server(
 132                                        const struct nfs_parsed_mount_data *,
 133                                        struct nfs_fh *);
 134extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
 135                                                      struct nfs_fh *);
 136extern void nfs_free_server(struct nfs_server *server);
 137extern struct nfs_server *nfs_clone_server(struct nfs_server *,
 138                                           struct nfs_fh *,
 139                                           struct nfs_fattr *);
 140extern void nfs_mark_client_ready(struct nfs_client *clp, int state);
 141extern int nfs4_check_client_ready(struct nfs_client *clp);
 142#ifdef CONFIG_PROC_FS
 143extern int __init nfs_fs_proc_init(void);
 144extern void nfs_fs_proc_exit(void);
 145#else
 146static inline int nfs_fs_proc_init(void)
 147{
 148        return 0;
 149}
 150static inline void nfs_fs_proc_exit(void)
 151{
 152}
 153#endif
 154
 155/* nfs4namespace.c */
 156#ifdef CONFIG_NFS_V4
 157extern struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry);
 158#else
 159static inline
 160struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
 161{
 162        return ERR_PTR(-ENOENT);
 163}
 164#endif
 165
 166/* callback_xdr.c */
 167extern struct svc_version nfs4_callback_version1;
 168extern struct svc_version nfs4_callback_version4;
 169
 170/* pagelist.c */
 171extern int __init nfs_init_nfspagecache(void);
 172extern void nfs_destroy_nfspagecache(void);
 173extern int __init nfs_init_readpagecache(void);
 174extern void nfs_destroy_readpagecache(void);
 175extern int __init nfs_init_writepagecache(void);
 176extern void nfs_destroy_writepagecache(void);
 177
 178extern int __init nfs_init_directcache(void);
 179extern void nfs_destroy_directcache(void);
 180
 181/* nfs2xdr.c */
 182extern int nfs_stat_to_errno(int);
 183extern struct rpc_procinfo nfs_procedures[];
 184extern __be32 * nfs_decode_dirent(__be32 *, struct nfs_entry *, int);
 185
 186/* nfs3xdr.c */
 187extern struct rpc_procinfo nfs3_procedures[];
 188extern __be32 *nfs3_decode_dirent(__be32 *, struct nfs_entry *, int);
 189
 190/* nfs4xdr.c */
 191#ifdef CONFIG_NFS_V4
 192extern __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus);
 193#endif
 194#ifdef CONFIG_NFS_V4_1
 195extern const u32 nfs41_maxread_overhead;
 196extern const u32 nfs41_maxwrite_overhead;
 197#endif
 198
 199/* nfs4proc.c */
 200#ifdef CONFIG_NFS_V4
 201extern struct rpc_procinfo nfs4_procedures[];
 202#endif
 203
 204/* proc.c */
 205void nfs_close_context(struct nfs_open_context *ctx, int is_sync);
 206
 207/* dir.c */
 208extern int nfs_access_cache_shrinker(struct shrinker *shrink,
 209                                        int nr_to_scan, gfp_t gfp_mask);
 210
 211/* inode.c */
 212extern struct workqueue_struct *nfsiod_workqueue;
 213extern struct inode *nfs_alloc_inode(struct super_block *sb);
 214extern void nfs_destroy_inode(struct inode *);
 215extern int nfs_write_inode(struct inode *, struct writeback_control *);
 216extern void nfs_clear_inode(struct inode *);
 217#ifdef CONFIG_NFS_V4
 218extern void nfs4_clear_inode(struct inode *);
 219#endif
 220void nfs_zap_acl_cache(struct inode *inode);
 221extern int nfs_wait_bit_killable(void *word);
 222
 223/* super.c */
 224extern struct file_system_type nfs_xdev_fs_type;
 225#ifdef CONFIG_NFS_V4
 226extern struct file_system_type nfs4_xdev_fs_type;
 227extern struct file_system_type nfs4_referral_fs_type;
 228#endif
 229
 230extern struct rpc_stat nfs_rpcstat;
 231
 232extern int __init register_nfs_fs(void);
 233extern void __exit unregister_nfs_fs(void);
 234extern void nfs_sb_active(struct super_block *sb);
 235extern void nfs_sb_deactive(struct super_block *sb);
 236
 237/* namespace.c */
 238extern char *nfs_path(const char *base,
 239                      const struct dentry *droot,
 240                      const struct dentry *dentry,
 241                      char *buffer, ssize_t buflen);
 242
 243/* getroot.c */
 244extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *);
 245#ifdef CONFIG_NFS_V4
 246extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *);
 247
 248extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh);
 249#endif
 250
 251/* read.c */
 252extern void nfs_read_prepare(struct rpc_task *task, void *calldata);
 253
 254/* write.c */
 255extern void nfs_write_prepare(struct rpc_task *task, void *calldata);
 256#ifdef CONFIG_MIGRATION
 257extern int nfs_migrate_page(struct address_space *,
 258                struct page *, struct page *);
 259#else
 260#define nfs_migrate_page NULL
 261#endif
 262
 263/* nfs4proc.c */
 264extern int _nfs4_call_sync(struct nfs_server *server,
 265                           struct rpc_message *msg,
 266                           struct nfs4_sequence_args *args,
 267                           struct nfs4_sequence_res *res,
 268                           int cache_reply);
 269extern int _nfs4_call_sync_session(struct nfs_server *server,
 270                                   struct rpc_message *msg,
 271                                   struct nfs4_sequence_args *args,
 272                                   struct nfs4_sequence_res *res,
 273                                   int cache_reply);
 274
 275/*
 276 * Determine the device name as a string
 277 */
 278static inline char *nfs_devname(const struct vfsmount *mnt_parent,
 279                                const struct dentry *dentry,
 280                                char *buffer, ssize_t buflen)
 281{
 282        return nfs_path(mnt_parent->mnt_devname, mnt_parent->mnt_root,
 283                        dentry, buffer, buflen);
 284}
 285
 286/*
 287 * Determine the actual block size (and log2 thereof)
 288 */
 289static inline
 290unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
 291{
 292        /* make sure blocksize is a power of two */
 293        if ((bsize & (bsize - 1)) || nrbitsp) {
 294                unsigned char   nrbits;
 295
 296                for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
 297                        ;
 298                bsize = 1 << nrbits;
 299                if (nrbitsp)
 300                        *nrbitsp = nrbits;
 301        }
 302
 303        return bsize;
 304}
 305
 306/*
 307 * Calculate the number of 512byte blocks used.
 308 */
 309static inline blkcnt_t nfs_calc_block_size(u64 tsize)
 310{
 311        blkcnt_t used = (tsize + 511) >> 9;
 312        return (used > ULONG_MAX) ? ULONG_MAX : used;
 313}
 314
 315/*
 316 * Compute and set NFS server blocksize
 317 */
 318static inline
 319unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
 320{
 321        if (bsize < NFS_MIN_FILE_IO_SIZE)
 322                bsize = NFS_DEF_FILE_IO_SIZE;
 323        else if (bsize >= NFS_MAX_FILE_IO_SIZE)
 324                bsize = NFS_MAX_FILE_IO_SIZE;
 325
 326        return nfs_block_bits(bsize, nrbitsp);
 327}
 328
 329/*
 330 * Determine the maximum file size for a superblock
 331 */
 332static inline
 333void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
 334{
 335        sb->s_maxbytes = (loff_t)maxfilesize;
 336        if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
 337                sb->s_maxbytes = MAX_LFS_FILESIZE;
 338}
 339
 340/*
 341 * Determine the number of bytes of data the page contains
 342 */
 343static inline
 344unsigned int nfs_page_length(struct page *page)
 345{
 346        loff_t i_size = i_size_read(page->mapping->host);
 347
 348        if (i_size > 0) {
 349                pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
 350                if (page->index < end_index)
 351                        return PAGE_CACHE_SIZE;
 352                if (page->index == end_index)
 353                        return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1;
 354        }
 355        return 0;
 356}
 357
 358/*
 359 * Determine the number of pages in an array of length 'len' and
 360 * with a base offset of 'base'
 361 */
 362static inline
 363unsigned int nfs_page_array_len(unsigned int base, size_t len)
 364{
 365        return ((unsigned long)len + (unsigned long)base +
 366                PAGE_SIZE - 1) >> PAGE_SHIFT;
 367}
 368
 369/*
 370 * Helper for restarting RPC calls in the possible presence of NFSv4.1
 371 * sessions.
 372 */
 373static inline void nfs_restart_rpc(struct rpc_task *task, const struct nfs_client *clp)
 374{
 375        if (nfs4_has_session(clp))
 376                rpc_restart_call_prepare(task);
 377        else
 378                rpc_restart_call(task);
 379}
 380
The original LXR software by the LXR community, this experimental version by lxr@linux.no.
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.