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