SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/nfs/internal.h

   1 /*
   2  * NFS internal definitions
   3  */
   4
   5 #include <linux/mount.h>
   6
   7 struct nfs_string;
   8
   9 /* Maximum number of readahead requests
  10  * FIXME: this should really be a sysctl so that users may tune it to suit
  11  *        their needs. People that do NFS over a slow network, might for
  12  *        instance want to reduce it to something closer to 1 for improved
  13  *        interactive response.
  14  */
  15 #define NFS_MAX_READAHEAD       (RPC_DEF_SLOT_TABLE - 1)
  16
  17 struct nfs_clone_mount {
  18         const struct super_block *sb;
  19         const struct dentry *dentry;
  20         struct nfs_fh *fh;
  21         struct nfs_fattr *fattr;
  22         char *hostname;
  23         char *mnt_path;
  24         struct sockaddr *addr;
  25         size_t addrlen;
  26         rpc_authflavor_t authflavor;
  27 };
  28
  29 /*
  30  * In-kernel mount arguments
  31  */
  32 struct nfs_parsed_mount_data {
  33         int                     flags;
  34         int                     rsize, wsize;
  35         int                     timeo, retrans;
  36         int                     acregmin, acregmax,
  37                                 acdirmin, acdirmax;
  38         int                     namlen;
  39         unsigned int            bsize;
  40         unsigned int            auth_flavor_len;
  41         rpc_authflavor_t        auth_flavors[1];
  42         char                    *client_address;
  43
  44         struct {
  45                 struct sockaddr_in      address;
  46                 char                    *hostname;
  47                 unsigned int            version;
  48                 unsigned short          port;
  49                 int                     protocol;
  50         } mount_server;
  51
  52         struct {
  53                 struct sockaddr_in      address;
  54                 char                    *hostname;
  55                 char                    *export_path;
  56                 int                     protocol;
  57         } nfs_server;
  58 };
  59
  60 /* client.c */
  61 extern struct rpc_program nfs_program;
  62
  63 extern void nfs_put_client(struct nfs_client *);
  64 extern struct nfs_client *nfs_find_client(const struct sockaddr *, u32);
  65 extern struct nfs_server *nfs_create_server(
  66                                         const struct nfs_parsed_mount_data *,
  67                                         struct nfs_fh *);
  68 extern struct nfs_server *nfs4_create_server(
  69                                         const struct nfs_parsed_mount_data *,
  70                                         struct nfs_fh *);
  71 extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
  72                                                       struct nfs_fh *);
  73 extern void nfs_free_server(struct nfs_server *server);
  74 extern struct nfs_server *nfs_clone_server(struct nfs_server *,
  75                                            struct nfs_fh *,
  76                                            struct nfs_fattr *);
  77 #ifdef CONFIG_PROC_FS
  78 extern int __init nfs_fs_proc_init(void);
  79 extern void nfs_fs_proc_exit(void);
  80 #else
  81 static inline int nfs_fs_proc_init(void)
  82 {
  83         return 0;
  84 }
  85 static inline void nfs_fs_proc_exit(void)
  86 {
  87 }
  88 #endif
  89
  90 /* nfs4namespace.c */
  91 #ifdef CONFIG_NFS_V4
  92 extern struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry);
  93 #else
  94 static inline
  95 struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
  96 {
  97         return ERR_PTR(-ENOENT);
  98 }
  99 #endif
 100
 101 /* callback_xdr.c */
 102 extern struct svc_version nfs4_callback_version1;
 103
 104 /* pagelist.c */
 105 extern int __init nfs_init_nfspagecache(void);
 106 extern void nfs_destroy_nfspagecache(void);
 107 extern int __init nfs_init_readpagecache(void);
 108 extern void nfs_destroy_readpagecache(void);
 109 extern int __init nfs_init_writepagecache(void);
 110 extern void nfs_destroy_writepagecache(void);
 111
 112 #ifdef CONFIG_NFS_DIRECTIO
 113 extern int __init nfs_init_directcache(void);
 114 extern void nfs_destroy_directcache(void);
 115 #else
 116 #define nfs_init_directcache() (0)
 117 #define nfs_destroy_directcache() do {} while(0)
 118 #endif
 119
 120 /* nfs2xdr.c */
 121 extern int nfs_stat_to_errno(int);
 122 extern struct rpc_procinfo nfs_procedures[];
 123 extern __be32 * nfs_decode_dirent(__be32 *, struct nfs_entry *, int);
 124
 125 /* nfs3xdr.c */
 126 extern struct rpc_procinfo nfs3_procedures[];
 127 extern __be32 *nfs3_decode_dirent(__be32 *, struct nfs_entry *, int);
 128
 129 /* nfs4xdr.c */
 130 #ifdef CONFIG_NFS_V4
 131 extern __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus);
 132 #endif
 133
 134 /* nfs4proc.c */
 135 #ifdef CONFIG_NFS_V4
 136 extern struct rpc_procinfo nfs4_procedures[];
 137 #endif
 138
 139 /* dir.c */
 140 extern int nfs_access_cache_shrinker(int nr_to_scan, gfp_t gfp_mask);
 141
 142 /* inode.c */
 143 extern struct inode *nfs_alloc_inode(struct super_block *sb);
 144 extern void nfs_destroy_inode(struct inode *);
 145 extern int nfs_write_inode(struct inode *,int);
 146 extern void nfs_clear_inode(struct inode *);
 147 #ifdef CONFIG_NFS_V4
 148 extern void nfs4_clear_inode(struct inode *);
 149 #endif
 150
 151 /* super.c */
 152 extern struct file_system_type nfs_xdev_fs_type;
 153 #ifdef CONFIG_NFS_V4
 154 extern struct file_system_type nfs4_xdev_fs_type;
 155 extern struct file_system_type nfs4_referral_fs_type;
 156 #endif
 157
 158 extern struct rpc_stat nfs_rpcstat;
 159
 160 extern int __init register_nfs_fs(void);
 161 extern void __exit unregister_nfs_fs(void);
 162 extern void nfs_sb_active(struct nfs_server *server);
 163 extern void nfs_sb_deactive(struct nfs_server *server);
 164
 165 /* namespace.c */
 166 extern char *nfs_path(const char *base,
 167                       const struct dentry *droot,
 168                       const struct dentry *dentry,
 169                       char *buffer, ssize_t buflen);
 170
 171 /* getroot.c */
 172 extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *);
 173 #ifdef CONFIG_NFS_V4
 174 extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *);
 175
 176 extern int nfs4_path_walk(struct nfs_server *server,
 177                           struct nfs_fh *mntfh,
 178                           const char *path);
 179 #endif
 180
 181 /*
 182  * Determine the device name as a string
 183  */
 184 static inline char *nfs_devname(const struct vfsmount *mnt_parent,
 185                                 const struct dentry *dentry,
 186                                 char *buffer, ssize_t buflen)
 187 {
 188         return nfs_path(mnt_parent->mnt_devname, mnt_parent->mnt_root,
 189                         dentry, buffer, buflen);
 190 }
 191
 192 /*
 193  * Determine the actual block size (and log2 thereof)
 194  */
 195 static inline
 196 unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
 197 {
 198         /* make sure blocksize is a power of two */
 199         if ((bsize & (bsize - 1)) || nrbitsp) {
 200                 unsigned char   nrbits;
 201
 202                 for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
 203                         ;
 204                 bsize = 1 << nrbits;
 205                 if (nrbitsp)
 206                         *nrbitsp = nrbits;
 207         }
 208
 209         return bsize;
 210 }
 211
 212 /*
 213  * Calculate the number of 512byte blocks used.
 214  */
 215 static inline blkcnt_t nfs_calc_block_size(u64 tsize)
 216 {
 217         blkcnt_t used = (tsize + 511) >> 9;
 218         return (used > ULONG_MAX) ? ULONG_MAX : used;
 219 }
 220
 221 /*
 222  * Compute and set NFS server blocksize
 223  */
 224 static inline
 225 unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
 226 {
 227         if (bsize < NFS_MIN_FILE_IO_SIZE)
 228                 bsize = NFS_DEF_FILE_IO_SIZE;
 229         else if (bsize >= NFS_MAX_FILE_IO_SIZE)
 230                 bsize = NFS_MAX_FILE_IO_SIZE;
 231
 232         return nfs_block_bits(bsize, nrbitsp);
 233 }
 234
 235 /*
 236  * Determine the maximum file size for a superblock
 237  */
 238 static inline
 239 void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
 240 {
 241         sb->s_maxbytes = (loff_t)maxfilesize;
 242         if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
 243                 sb->s_maxbytes = MAX_LFS_FILESIZE;
 244 }
 245
 246 /*
 247  * Determine the number of bytes of data the page contains
 248  */
 249 static inline
 250 unsigned int nfs_page_length(struct page *page)
 251 {
 252         loff_t i_size = i_size_read(page->mapping->host);
 253
 254         if (i_size > 0) {
 255                 pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
 256                 if (page->index < end_index)
 257                         return PAGE_CACHE_SIZE;
 258                 if (page->index == end_index)
 259                         return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1;
 260         }
 261         return 0;
 262 }
 263
 264 /*
 265  * Determine the number of pages in an array of length 'len' and
 266  * with a base offset of 'base'
 267  */
 268 static inline
 269 unsigned int nfs_page_array_len(unsigned int base, size_t len)
 270 {
 271         return ((unsigned long)len + (unsigned long)base +
 272                 PAGE_SIZE - 1) >> PAGE_SHIFT;
 273 }
 274