David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 1 | /* |
| 2 | * NFS internal definitions |
| 3 | */ |
| 4 | |
Andy Adamson | eedc020 | 2009-04-01 09:22:41 -0400 | [diff] [blame^] | 5 | #include "nfs4_fs.h" |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 6 | #include <linux/mount.h> |
Eric Paris | f9c3a38 | 2008-03-05 14:20:18 -0500 | [diff] [blame] | 7 | #include <linux/security.h> |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 8 | |
David Howells | 0873404 | 2009-04-03 16:42:42 +0100 | [diff] [blame] | 9 | #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS) |
| 10 | |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 11 | struct nfs_string; |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 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 | |
Andy Adamson | eedc020 | 2009-04-01 09:22:41 -0400 | [diff] [blame^] | 21 | /* |
| 22 | * Determine if sessions are in use. |
| 23 | */ |
| 24 | static 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 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 33 | struct nfs_clone_mount { |
| 34 | const struct super_block *sb; |
| 35 | const struct dentry *dentry; |
| 36 | struct nfs_fh *fh; |
| 37 | struct nfs_fattr *fattr; |
| 38 | char *hostname; |
| 39 | char *mnt_path; |
Chuck Lever | 6677d09 | 2007-12-10 14:59:06 -0500 | [diff] [blame] | 40 | struct sockaddr *addr; |
| 41 | size_t addrlen; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 42 | rpc_authflavor_t authflavor; |
| 43 | }; |
| 44 | |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 45 | /* |
| 46 | * In-kernel mount arguments |
| 47 | */ |
| 48 | struct nfs_parsed_mount_data { |
| 49 | int flags; |
| 50 | int rsize, wsize; |
| 51 | int timeo, retrans; |
| 52 | int acregmin, acregmax, |
| 53 | acdirmin, acdirmax; |
| 54 | int namlen; |
David Howells | b797cac | 2009-04-03 16:42:48 +0100 | [diff] [blame] | 55 | unsigned int options; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 56 | unsigned int bsize; |
| 57 | unsigned int auth_flavor_len; |
| 58 | rpc_authflavor_t auth_flavors[1]; |
| 59 | char *client_address; |
Mike Sager | 3fd5be9 | 2009-04-01 09:21:48 -0400 | [diff] [blame] | 60 | unsigned int minorversion; |
David Howells | 0873404 | 2009-04-03 16:42:42 +0100 | [diff] [blame] | 61 | char *fscache_uniq; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 62 | |
| 63 | struct { |
Chuck Lever | 4c56801 | 2007-12-10 14:59:28 -0500 | [diff] [blame] | 64 | struct sockaddr_storage address; |
| 65 | size_t addrlen; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 66 | char *hostname; |
Chuck Lever | 78fa701 | 2008-03-14 14:10:15 -0400 | [diff] [blame] | 67 | u32 version; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 68 | unsigned short port; |
Chuck Lever | 78fa701 | 2008-03-14 14:10:15 -0400 | [diff] [blame] | 69 | unsigned short protocol; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 70 | } mount_server; |
| 71 | |
| 72 | struct { |
Chuck Lever | 4c56801 | 2007-12-10 14:59:28 -0500 | [diff] [blame] | 73 | struct sockaddr_storage address; |
| 74 | size_t addrlen; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 75 | char *hostname; |
| 76 | char *export_path; |
Chuck Lever | f22d6d7 | 2008-03-14 14:10:22 -0400 | [diff] [blame] | 77 | unsigned short port; |
Chuck Lever | 78fa701 | 2008-03-14 14:10:15 -0400 | [diff] [blame] | 78 | unsigned short protocol; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 79 | } nfs_server; |
Eric Paris | f9c3a38 | 2008-03-05 14:20:18 -0500 | [diff] [blame] | 80 | |
| 81 | struct security_mnt_opts lsm_opts; |
\"Talpey, Thomas\ | 6b18eaa | 2007-09-10 13:43:29 -0400 | [diff] [blame] | 82 | }; |
| 83 | |
Chuck Lever | 146ec94 | 2008-12-23 15:21:34 -0500 | [diff] [blame] | 84 | /* mount_clnt.c */ |
Chuck Lever | c5d120f | 2008-12-23 15:21:35 -0500 | [diff] [blame] | 85 | struct nfs_mount_request { |
| 86 | struct sockaddr *sap; |
| 87 | size_t salen; |
| 88 | char *hostname; |
| 89 | char *dirpath; |
| 90 | u32 version; |
| 91 | unsigned short protocol; |
| 92 | struct nfs_fh *fh; |
Chuck Lever | 50a737f | 2008-12-23 15:21:37 -0500 | [diff] [blame] | 93 | int noresvport; |
Chuck Lever | c5d120f | 2008-12-23 15:21:35 -0500 | [diff] [blame] | 94 | }; |
| 95 | |
| 96 | extern int nfs_mount(struct nfs_mount_request *info); |
Chuck Lever | 146ec94 | 2008-12-23 15:21:34 -0500 | [diff] [blame] | 97 | |
David Howells | 24c8dbb | 2006-08-22 20:06:10 -0400 | [diff] [blame] | 98 | /* client.c */ |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 99 | extern struct rpc_program nfs_program; |
| 100 | |
David Howells | 24c8dbb | 2006-08-22 20:06:10 -0400 | [diff] [blame] | 101 | extern void nfs_put_client(struct nfs_client *); |
Chuck Lever | ff05264 | 2007-12-10 14:58:44 -0500 | [diff] [blame] | 102 | extern struct nfs_client *nfs_find_client(const struct sockaddr *, u32); |
Trond Myklebust | 3fbd67a | 2008-01-26 01:06:40 -0500 | [diff] [blame] | 103 | extern struct nfs_client *nfs_find_client_next(struct nfs_client *); |
\"Talpey, Thomas\ | 2283f8d | 2007-09-10 13:43:56 -0400 | [diff] [blame] | 104 | extern struct nfs_server *nfs_create_server( |
| 105 | const struct nfs_parsed_mount_data *, |
| 106 | struct nfs_fh *); |
\"Talpey, Thomas\ | 91ea40b | 2007-09-10 13:44:33 -0400 | [diff] [blame] | 107 | extern struct nfs_server *nfs4_create_server( |
| 108 | const struct nfs_parsed_mount_data *, |
| 109 | struct nfs_fh *); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 110 | extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *, |
| 111 | struct nfs_fh *); |
| 112 | extern void nfs_free_server(struct nfs_server *server); |
| 113 | extern struct nfs_server *nfs_clone_server(struct nfs_server *, |
| 114 | struct nfs_fh *, |
| 115 | struct nfs_fattr *); |
Andy Adamson | 76db6d9 | 2009-04-01 09:22:38 -0400 | [diff] [blame] | 116 | extern void nfs_mark_client_ready(struct nfs_client *clp, int state); |
David Howells | 6aaca56 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 117 | #ifdef CONFIG_PROC_FS |
| 118 | extern int __init nfs_fs_proc_init(void); |
| 119 | extern void nfs_fs_proc_exit(void); |
| 120 | #else |
| 121 | static inline int nfs_fs_proc_init(void) |
| 122 | { |
| 123 | return 0; |
| 124 | } |
| 125 | static inline void nfs_fs_proc_exit(void) |
| 126 | { |
| 127 | } |
| 128 | #endif |
David Howells | 24c8dbb | 2006-08-22 20:06:10 -0400 | [diff] [blame] | 129 | |
David Howells | 7d4e274 | 2006-08-22 20:06:07 -0400 | [diff] [blame] | 130 | /* nfs4namespace.c */ |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 131 | #ifdef CONFIG_NFS_V4 |
| 132 | extern struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry); |
| 133 | #else |
| 134 | static inline |
| 135 | struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry) |
| 136 | { |
| 137 | return ERR_PTR(-ENOENT); |
| 138 | } |
| 139 | #endif |
| 140 | |
| 141 | /* callback_xdr.c */ |
| 142 | extern struct svc_version nfs4_callback_version1; |
| 143 | |
| 144 | /* pagelist.c */ |
| 145 | extern int __init nfs_init_nfspagecache(void); |
David Brownell | 266bee8 | 2006-06-27 12:59:15 -0700 | [diff] [blame] | 146 | extern void nfs_destroy_nfspagecache(void); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 147 | extern int __init nfs_init_readpagecache(void); |
David Brownell | 266bee8 | 2006-06-27 12:59:15 -0700 | [diff] [blame] | 148 | extern void nfs_destroy_readpagecache(void); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 149 | extern int __init nfs_init_writepagecache(void); |
David Brownell | 266bee8 | 2006-06-27 12:59:15 -0700 | [diff] [blame] | 150 | extern void nfs_destroy_writepagecache(void); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 151 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 152 | extern int __init nfs_init_directcache(void); |
David Brownell | 266bee8 | 2006-06-27 12:59:15 -0700 | [diff] [blame] | 153 | extern void nfs_destroy_directcache(void); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 154 | |
| 155 | /* nfs2xdr.c */ |
David Howells | 7d4e274 | 2006-08-22 20:06:07 -0400 | [diff] [blame] | 156 | extern int nfs_stat_to_errno(int); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 157 | extern struct rpc_procinfo nfs_procedures[]; |
Al Viro | 0dbb4c6 | 2006-10-19 23:28:49 -0700 | [diff] [blame] | 158 | extern __be32 * nfs_decode_dirent(__be32 *, struct nfs_entry *, int); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 159 | |
| 160 | /* nfs3xdr.c */ |
| 161 | extern struct rpc_procinfo nfs3_procedures[]; |
Al Viro | 0dbb4c6 | 2006-10-19 23:28:49 -0700 | [diff] [blame] | 162 | extern __be32 *nfs3_decode_dirent(__be32 *, struct nfs_entry *, int); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 163 | |
Andy Adamson | eedc020 | 2009-04-01 09:22:41 -0400 | [diff] [blame^] | 164 | /* nfs4proc.c */ |
| 165 | static inline void nfs4_restart_rpc(struct rpc_task *task, |
| 166 | const struct nfs_client *clp) |
| 167 | { |
| 168 | #ifdef CONFIG_NFS_V4_1 |
| 169 | if (nfs4_has_session(clp) && |
| 170 | test_bit(NFS4CLNT_SESSION_SETUP, &clp->cl_state)) { |
| 171 | rpc_restart_call_prepare(task); |
| 172 | return; |
| 173 | } |
| 174 | #endif /* CONFIG_NFS_V4_1 */ |
| 175 | rpc_restart_call(task); |
| 176 | } |
| 177 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 178 | /* nfs4xdr.c */ |
David Howells | 7d4e274 | 2006-08-22 20:06:07 -0400 | [diff] [blame] | 179 | #ifdef CONFIG_NFS_V4 |
Al Viro | 0dbb4c6 | 2006-10-19 23:28:49 -0700 | [diff] [blame] | 180 | extern __be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus); |
David Howells | 7d4e274 | 2006-08-22 20:06:07 -0400 | [diff] [blame] | 181 | #endif |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 182 | |
| 183 | /* nfs4proc.c */ |
Andrew Morton | d75d541 | 2006-06-25 02:41:26 -0700 | [diff] [blame] | 184 | #ifdef CONFIG_NFS_V4 |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 185 | extern struct rpc_procinfo nfs4_procedures[]; |
Andrew Morton | d75d541 | 2006-06-25 02:41:26 -0700 | [diff] [blame] | 186 | #endif |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 187 | |
Trond Myklebust | 7fe5c39 | 2009-03-19 15:35:50 -0400 | [diff] [blame] | 188 | /* proc.c */ |
| 189 | void nfs_close_context(struct nfs_open_context *ctx, int is_sync); |
| 190 | |
Trond Myklebust | 979df72 | 2006-07-25 11:28:19 -0400 | [diff] [blame] | 191 | /* dir.c */ |
| 192 | extern int nfs_access_cache_shrinker(int nr_to_scan, gfp_t gfp_mask); |
| 193 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 194 | /* inode.c */ |
Trond Myklebust | 5746006 | 2008-02-19 20:04:22 -0500 | [diff] [blame] | 195 | extern struct workqueue_struct *nfsiod_workqueue; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 196 | extern struct inode *nfs_alloc_inode(struct super_block *sb); |
| 197 | extern void nfs_destroy_inode(struct inode *); |
| 198 | extern int nfs_write_inode(struct inode *,int); |
| 199 | extern void nfs_clear_inode(struct inode *); |
| 200 | #ifdef CONFIG_NFS_V4 |
| 201 | extern void nfs4_clear_inode(struct inode *); |
| 202 | #endif |
Trond Myklebust | f41f741 | 2008-06-11 17:39:04 -0400 | [diff] [blame] | 203 | void nfs_zap_acl_cache(struct inode *inode); |
Trond Myklebust | 72cb77f | 2009-03-11 14:10:30 -0400 | [diff] [blame] | 204 | extern int nfs_wait_bit_killable(void *word); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 205 | |
| 206 | /* super.c */ |
J. Bruce Fields | ea31a443 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 207 | void nfs_parse_ip_address(char *, size_t, struct sockaddr *, size_t *); |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 208 | extern struct file_system_type nfs_xdev_fs_type; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 209 | #ifdef CONFIG_NFS_V4 |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 210 | extern struct file_system_type nfs4_xdev_fs_type; |
| 211 | extern struct file_system_type nfs4_referral_fs_type; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 212 | #endif |
Dominik Hackl | 4ebd9ab | 2006-07-02 17:29:26 +0200 | [diff] [blame] | 213 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 214 | extern struct rpc_stat nfs_rpcstat; |
Dominik Hackl | 4ebd9ab | 2006-07-02 17:29:26 +0200 | [diff] [blame] | 215 | |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 216 | extern int __init register_nfs_fs(void); |
| 217 | extern void __exit unregister_nfs_fs(void); |
Trond Myklebust | 1daef0a | 2008-07-27 18:19:01 -0400 | [diff] [blame] | 218 | extern void nfs_sb_active(struct super_block *sb); |
| 219 | extern void nfs_sb_deactive(struct super_block *sb); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 220 | |
| 221 | /* namespace.c */ |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 222 | extern char *nfs_path(const char *base, |
| 223 | const struct dentry *droot, |
| 224 | const struct dentry *dentry, |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 225 | char *buffer, ssize_t buflen); |
| 226 | |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 227 | /* getroot.c */ |
| 228 | extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *); |
David Howells | 7d4e274 | 2006-08-22 20:06:07 -0400 | [diff] [blame] | 229 | #ifdef CONFIG_NFS_V4 |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 230 | extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *); |
| 231 | |
| 232 | extern int nfs4_path_walk(struct nfs_server *server, |
| 233 | struct nfs_fh *mntfh, |
| 234 | const char *path); |
David Howells | 7d4e274 | 2006-08-22 20:06:07 -0400 | [diff] [blame] | 235 | #endif |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 236 | |
Andy Adamson | f11c88a | 2009-04-01 09:22:25 -0400 | [diff] [blame] | 237 | /* read.c */ |
| 238 | extern void nfs_read_prepare(struct rpc_task *task, void *calldata); |
| 239 | |
Andy Adamson | def6ed7 | 2009-04-01 09:22:26 -0400 | [diff] [blame] | 240 | /* write.c */ |
| 241 | extern void nfs_write_prepare(struct rpc_task *task, void *calldata); |
| 242 | |
Andy Adamson | cccef3b | 2009-04-01 09:22:03 -0400 | [diff] [blame] | 243 | /* nfs4proc.c */ |
| 244 | extern int _nfs4_call_sync(struct nfs_server *server, |
| 245 | struct rpc_message *msg, |
| 246 | struct nfs4_sequence_args *args, |
| 247 | struct nfs4_sequence_res *res, |
| 248 | int cache_reply); |
| 249 | extern int _nfs4_call_sync_session(struct nfs_server *server, |
| 250 | struct rpc_message *msg, |
| 251 | struct nfs4_sequence_args *args, |
| 252 | struct nfs4_sequence_res *res, |
| 253 | int cache_reply); |
| 254 | |
Andy Adamson | 1361587 | 2009-04-01 09:22:17 -0400 | [diff] [blame] | 255 | #ifdef CONFIG_NFS_V4_1 |
| 256 | extern void nfs41_sequence_free_slot(const struct nfs_client *, |
| 257 | struct nfs4_sequence_res *res); |
| 258 | #endif /* CONFIG_NFS_V4_1 */ |
| 259 | |
| 260 | static inline void nfs4_sequence_free_slot(const struct nfs_client *clp, |
| 261 | struct nfs4_sequence_res *res) |
| 262 | { |
| 263 | #ifdef CONFIG_NFS_V4_1 |
| 264 | if (nfs4_has_session(clp)) |
| 265 | nfs41_sequence_free_slot(clp, res); |
| 266 | #endif /* CONFIG_NFS_V4_1 */ |
| 267 | } |
| 268 | |
Andy Adamson | 557134a | 2009-04-01 09:21:53 -0400 | [diff] [blame] | 269 | /* |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 270 | * Determine the device name as a string |
| 271 | */ |
| 272 | static inline char *nfs_devname(const struct vfsmount *mnt_parent, |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 273 | const struct dentry *dentry, |
| 274 | char *buffer, ssize_t buflen) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 275 | { |
David Howells | 54ceac4 | 2006-08-22 20:06:13 -0400 | [diff] [blame] | 276 | return nfs_path(mnt_parent->mnt_devname, mnt_parent->mnt_root, |
| 277 | dentry, buffer, buflen); |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | /* |
| 281 | * Determine the actual block size (and log2 thereof) |
| 282 | */ |
| 283 | static inline |
| 284 | unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp) |
| 285 | { |
| 286 | /* make sure blocksize is a power of two */ |
| 287 | if ((bsize & (bsize - 1)) || nrbitsp) { |
| 288 | unsigned char nrbits; |
| 289 | |
| 290 | for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--) |
| 291 | ; |
| 292 | bsize = 1 << nrbits; |
| 293 | if (nrbitsp) |
| 294 | *nrbitsp = nrbits; |
| 295 | } |
| 296 | |
| 297 | return bsize; |
| 298 | } |
| 299 | |
| 300 | /* |
| 301 | * Calculate the number of 512byte blocks used. |
| 302 | */ |
Chuck Lever | 9eaa67c | 2007-07-01 12:12:19 -0400 | [diff] [blame] | 303 | static inline blkcnt_t nfs_calc_block_size(u64 tsize) |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 304 | { |
Chuck Lever | 9eaa67c | 2007-07-01 12:12:19 -0400 | [diff] [blame] | 305 | blkcnt_t used = (tsize + 511) >> 9; |
David Howells | f7b422b | 2006-06-09 09:34:33 -0400 | [diff] [blame] | 306 | return (used > ULONG_MAX) ? ULONG_MAX : used; |
| 307 | } |
| 308 | |
| 309 | /* |
| 310 | * Compute and set NFS server blocksize |
| 311 | */ |
| 312 | static inline |
| 313 | unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp) |
| 314 | { |
| 315 | if (bsize < NFS_MIN_FILE_IO_SIZE) |
| 316 | bsize = NFS_DEF_FILE_IO_SIZE; |
| 317 | else if (bsize >= NFS_MAX_FILE_IO_SIZE) |
| 318 | bsize = NFS_MAX_FILE_IO_SIZE; |
| 319 | |
| 320 | return nfs_block_bits(bsize, nrbitsp); |
| 321 | } |
| 322 | |
| 323 | /* |
| 324 | * Determine the maximum file size for a superblock |
| 325 | */ |
| 326 | static inline |
| 327 | void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize) |
| 328 | { |
| 329 | sb->s_maxbytes = (loff_t)maxfilesize; |
| 330 | if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0) |
| 331 | sb->s_maxbytes = MAX_LFS_FILESIZE; |
| 332 | } |
Trond Myklebust | 49a70f2 | 2006-12-05 00:35:38 -0500 | [diff] [blame] | 333 | |
| 334 | /* |
| 335 | * Determine the number of bytes of data the page contains |
| 336 | */ |
| 337 | static inline |
| 338 | unsigned int nfs_page_length(struct page *page) |
| 339 | { |
| 340 | loff_t i_size = i_size_read(page->mapping->host); |
| 341 | |
| 342 | if (i_size > 0) { |
| 343 | pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT; |
| 344 | if (page->index < end_index) |
| 345 | return PAGE_CACHE_SIZE; |
| 346 | if (page->index == end_index) |
| 347 | return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1; |
| 348 | } |
| 349 | return 0; |
| 350 | } |
Trond Myklebust | 8d5658c | 2007-04-10 09:26:35 -0400 | [diff] [blame] | 351 | |
| 352 | /* |
| 353 | * Determine the number of pages in an array of length 'len' and |
| 354 | * with a base offset of 'base' |
| 355 | */ |
| 356 | static inline |
| 357 | unsigned int nfs_page_array_len(unsigned int base, size_t len) |
| 358 | { |
| 359 | return ((unsigned long)len + (unsigned long)base + |
| 360 | PAGE_SIZE - 1) >> PAGE_SHIFT; |
| 361 | } |
| 362 | |
J. Bruce Fields | ea31a443 | 2008-08-20 16:10:23 -0400 | [diff] [blame] | 363 | #define IPV6_SCOPE_DELIMITER '%' |
J. Bruce Fields | f0c92925 | 2008-08-20 16:10:22 -0400 | [diff] [blame] | 364 | |
| 365 | /* |
| 366 | * Set the port number in an address. Be agnostic about the address |
| 367 | * family. |
| 368 | */ |
| 369 | static inline void nfs_set_port(struct sockaddr *sap, unsigned short port) |
| 370 | { |
J. Bruce Fields | 456018d | 2008-10-08 15:31:14 -0400 | [diff] [blame] | 371 | struct sockaddr_in *ap = (struct sockaddr_in *)sap; |
| 372 | struct sockaddr_in6 *ap6 = (struct sockaddr_in6 *)sap; |
| 373 | |
J. Bruce Fields | f0c92925 | 2008-08-20 16:10:22 -0400 | [diff] [blame] | 374 | switch (sap->sa_family) { |
J. Bruce Fields | 456018d | 2008-10-08 15:31:14 -0400 | [diff] [blame] | 375 | case AF_INET: |
| 376 | ap->sin_port = htons(port); |
| 377 | break; |
| 378 | case AF_INET6: |
| 379 | ap6->sin6_port = htons(port); |
| 380 | break; |
J. Bruce Fields | f0c92925 | 2008-08-20 16:10:22 -0400 | [diff] [blame] | 381 | } |
| 382 | } |