~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/internal.h

Version: ~ [ linux-5.3-rc4 ] ~ [ linux-5.2.8 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.66 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.138 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.71 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * NFS internal definitions
  3  */
  4 
  5 #include "nfs4_fs.h"
  6 #include <linux/mount.h>
  7 #include <linux/security.h>
  8 #include <linux/crc32.h>
  9 
 10 #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
 11 
 12 struct nfs_string;
 13 
 14 /* Maximum number of readahead requests
 15  * FIXME: this should really be a sysctl so that users may tune it to suit
 16  *        their needs. People that do NFS over a slow network, might for
 17  *        instance want to reduce it to something closer to 1 for improved
 18  *        interactive response.
 19  */
 20 #define NFS_MAX_READAHEAD       (RPC_DEF_SLOT_TABLE - 1)
 21 
 22 static inline void nfs_attr_check_mountpoint(struct super_block *parent, struct nfs_fattr *fattr)
 23 {
 24         if (!nfs_fsid_equal(&NFS_SB(parent)->fsid, &fattr->fsid))
 25                 fattr->valid |= NFS_ATTR_FATTR_MOUNTPOINT;
 26 }
 27 
 28 static inline int nfs_attr_use_mounted_on_fileid(struct nfs_fattr *fattr)
 29 {
 30         if (((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) == 0) ||
 31             (((fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT) == 0) &&
 32              ((fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) == 0)))
 33                 return 0;
 34 
 35         fattr->fileid = fattr->mounted_on_fileid;
 36         return 1;
 37 }
 38 
 39 struct nfs_clone_mount {
 40         const struct super_block *sb;
 41         const struct dentry *dentry;
 42         struct nfs_fh *fh;
 43         struct nfs_fattr *fattr;
 44         char *hostname;
 45         char *mnt_path;
 46         struct sockaddr *addr;
 47         size_t addrlen;
 48         rpc_authflavor_t authflavor;
 49 };
 50 
 51 /*
 52  * Note: RFC 1813 doesn't limit the number of auth flavors that
 53  * a server can return, so make something up.
 54  */
 55 #define NFS_MAX_SECFLAVORS      (12)
 56 
 57 /*
 58  * Value used if the user did not specify a port value.
 59  */
 60 #define NFS_UNSPEC_PORT         (-1)
 61 
 62 /*
 63  * Maximum number of pages that readdir can use for creating
 64  * a vmapped array of pages.
 65  */
 66 #define NFS_MAX_READDIR_PAGES 8
 67 
 68 struct nfs_client_initdata {
 69         unsigned long init_flags;
 70         const char *hostname;
 71         const struct sockaddr *addr;
 72         size_t addrlen;
 73         struct nfs_subversion *nfs_mod;
 74         int proto;
 75         u32 minorversion;
 76         struct net *net;
 77 };
 78 
 79 /*
 80  * In-kernel mount arguments
 81  */
 82 struct nfs_parsed_mount_data {
 83         int                     flags;
 84         unsigned int            rsize, wsize;
 85         unsigned int            timeo, retrans;
 86         unsigned int            acregmin, acregmax,
 87                                 acdirmin, acdirmax;
 88         unsigned int            namlen;
 89         unsigned int            options;
 90         unsigned int            bsize;
 91         unsigned int            auth_flavor_len;
 92         rpc_authflavor_t        auth_flavors[1];
 93         char                    *client_address;
 94         unsigned int            version;
 95         unsigned int            minorversion;
 96         char                    *fscache_uniq;
 97         bool                    need_mount;
 98 
 99         struct {
100                 struct sockaddr_storage address;
101                 size_t                  addrlen;
102                 char                    *hostname;
103                 u32                     version;
104                 int                     port;
105                 unsigned short          protocol;
106         } mount_server;
107 
108         struct {
109                 struct sockaddr_storage address;
110                 size_t                  addrlen;
111                 char                    *hostname;
112                 char                    *export_path;
113                 int                     port;
114                 unsigned short          protocol;
115         } nfs_server;
116 
117         struct security_mnt_opts lsm_opts;
118         struct net              *net;
119 };
120 
121 /* mount_clnt.c */
122 struct nfs_mount_request {
123         struct sockaddr         *sap;
124         size_t                  salen;
125         char                    *hostname;
126         char                    *dirpath;
127         u32                     version;
128         unsigned short          protocol;
129         struct nfs_fh           *fh;
130         int                     noresvport;
131         unsigned int            *auth_flav_len;
132         rpc_authflavor_t        *auth_flavs;
133         struct net              *net;
134 };
135 
136 struct nfs_mount_info {
137         void (*fill_super)(struct super_block *, struct nfs_mount_info *);
138         int (*set_security)(struct super_block *, struct dentry *, struct nfs_mount_info *);
139         struct nfs_parsed_mount_data *parsed;
140         struct nfs_clone_mount *cloned;
141         struct nfs_fh *mntfh;
142 };
143 
144 extern int nfs_mount(struct nfs_mount_request *info);
145 extern void nfs_umount(const struct nfs_mount_request *info);
146 
147 /* client.c */
148 extern const struct rpc_program nfs_program;
149 extern void nfs_clients_init(struct net *net);
150 extern struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *);
151 int nfs_create_rpc_client(struct nfs_client *, const struct rpc_timeout *, rpc_authflavor_t);
152 struct nfs_client *nfs_get_client(const struct nfs_client_initdata *,
153                                   const struct rpc_timeout *, const char *,
154                                   rpc_authflavor_t);
155 int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *, struct nfs_fattr *);
156 void nfs_server_insert_lists(struct nfs_server *);
157 void nfs_init_timeout_values(struct rpc_timeout *, int, unsigned int, unsigned int);
158 int nfs_init_server_rpcclient(struct nfs_server *, const struct rpc_timeout *t,
159                 rpc_authflavor_t);
160 struct nfs_server *nfs_alloc_server(void);
161 void nfs_server_copy_userdata(struct nfs_server *, struct nfs_server *);
162 
163 extern void nfs_cleanup_cb_ident_idr(struct net *);
164 extern void nfs_put_client(struct nfs_client *);
165 extern void nfs_free_client(struct nfs_client *);
166 extern struct nfs_client *nfs4_find_client_ident(struct net *, int);
167 extern struct nfs_client *
168 nfs4_find_client_sessionid(struct net *, const struct sockaddr *,
169                                 struct nfs4_sessionid *, u32);
170 extern struct nfs_server *nfs_create_server(struct nfs_mount_info *,
171                                         struct nfs_subversion *);
172 extern struct nfs_server *nfs4_create_server(
173                                         struct nfs_mount_info *,
174                                         struct nfs_subversion *);
175 extern struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *,
176                                                       struct nfs_fh *);
177 extern void nfs_free_server(struct nfs_server *server);
178 extern struct nfs_server *nfs_clone_server(struct nfs_server *,
179                                            struct nfs_fh *,
180                                            struct nfs_fattr *,
181                                            rpc_authflavor_t);
182 extern int nfs_wait_client_init_complete(const struct nfs_client *clp);
183 extern void nfs_mark_client_ready(struct nfs_client *clp, int state);
184 extern struct nfs_client *nfs4_set_ds_client(struct nfs_client* mds_clp,
185                                              const struct sockaddr *ds_addr,
186                                              int ds_addrlen, int ds_proto,
187                                              unsigned int ds_timeo,
188                                              unsigned int ds_retrans);
189 extern struct rpc_clnt *nfs4_find_or_create_ds_client(struct nfs_client *,
190                                                 struct inode *);
191 #ifdef CONFIG_PROC_FS
192 extern int __init nfs_fs_proc_init(void);
193 extern void nfs_fs_proc_exit(void);
194 #else
195 static inline int nfs_fs_proc_init(void)
196 {
197         return 0;
198 }
199 static inline void nfs_fs_proc_exit(void)
200 {
201 }
202 #endif
203 
204 #ifdef CONFIG_NFS_V4_1
205 int nfs_sockaddr_match_ipaddr(const struct sockaddr *, const struct sockaddr *);
206 #endif
207 
208 /* nfs3client.c */
209 #if IS_ENABLED(CONFIG_NFS_V3)
210 struct nfs_server *nfs3_create_server(struct nfs_mount_info *, struct nfs_subversion *);
211 struct nfs_server *nfs3_clone_server(struct nfs_server *, struct nfs_fh *,
212                                      struct nfs_fattr *, rpc_authflavor_t);
213 #endif
214 
215 /* callback_xdr.c */
216 extern struct svc_version nfs4_callback_version1;
217 extern struct svc_version nfs4_callback_version4;
218 
219 struct nfs_pageio_descriptor;
220 /* pagelist.c */
221 extern int __init nfs_init_nfspagecache(void);
222 extern void nfs_destroy_nfspagecache(void);
223 extern int __init nfs_init_readpagecache(void);
224 extern void nfs_destroy_readpagecache(void);
225 extern int __init nfs_init_writepagecache(void);
226 extern void nfs_destroy_writepagecache(void);
227 
228 extern int __init nfs_init_directcache(void);
229 extern void nfs_destroy_directcache(void);
230 extern bool nfs_pgarray_set(struct nfs_page_array *p, unsigned int pagecount);
231 extern void nfs_pgheader_init(struct nfs_pageio_descriptor *desc,
232                               struct nfs_pgio_header *hdr,
233                               void (*release)(struct nfs_pgio_header *hdr));
234 void nfs_set_pgio_error(struct nfs_pgio_header *hdr, int error, loff_t pos);
235 int nfs_iocounter_wait(struct nfs_io_counter *c);
236 
237 static inline void nfs_iocounter_init(struct nfs_io_counter *c)
238 {
239         c->flags = 0;
240         atomic_set(&c->io_count, 0);
241 }
242 
243 /* nfs2xdr.c */
244 extern struct rpc_procinfo nfs_procedures[];
245 extern int nfs2_decode_dirent(struct xdr_stream *,
246                                 struct nfs_entry *, int);
247 
248 /* nfs3xdr.c */
249 extern struct rpc_procinfo nfs3_procedures[];
250 extern int nfs3_decode_dirent(struct xdr_stream *,
251                                 struct nfs_entry *, int);
252 
253 /* nfs4xdr.c */
254 #if IS_ENABLED(CONFIG_NFS_V4)
255 extern int nfs4_decode_dirent(struct xdr_stream *,
256                                 struct nfs_entry *, int);
257 #endif
258 #ifdef CONFIG_NFS_V4_1
259 extern const u32 nfs41_maxread_overhead;
260 extern const u32 nfs41_maxwrite_overhead;
261 extern const u32 nfs41_maxgetdevinfo_overhead;
262 #endif
263 
264 /* nfs4proc.c */
265 #if IS_ENABLED(CONFIG_NFS_V4)
266 extern struct rpc_procinfo nfs4_procedures[];
267 #endif
268 
269 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
270 static inline void nfs_zap_label_cache_locked(struct nfs_inode *nfsi)
271 {
272         if (nfs_server_capable(&nfsi->vfs_inode, NFS_CAP_SECURITY_LABEL))
273                 nfsi->cache_validity |= NFS_INO_INVALID_LABEL;
274 }
275 #else
276 static inline void nfs_zap_label_cache_locked(struct nfs_inode *nfsi)
277 {
278 }
279 #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
280 
281 /* proc.c */
282 void nfs_close_context(struct nfs_open_context *ctx, int is_sync);
283 extern struct nfs_client *nfs_init_client(struct nfs_client *clp,
284                            const struct rpc_timeout *timeparms,
285                            const char *ip_addr);
286 
287 /* dir.c */
288 extern unsigned long nfs_access_cache_count(struct shrinker *shrink,
289                                             struct shrink_control *sc);
290 extern unsigned long nfs_access_cache_scan(struct shrinker *shrink,
291                                            struct shrink_control *sc);
292 struct dentry *nfs_lookup(struct inode *, struct dentry *, unsigned int);
293 int nfs_create(struct inode *, struct dentry *, umode_t, bool);
294 int nfs_mkdir(struct inode *, struct dentry *, umode_t);
295 int nfs_rmdir(struct inode *, struct dentry *);
296 int nfs_unlink(struct inode *, struct dentry *);
297 int nfs_symlink(struct inode *, struct dentry *, const char *);
298 int nfs_link(struct dentry *, struct inode *, struct dentry *);
299 int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
300 int nfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
301 
302 /* file.c */
303 int nfs_file_fsync_commit(struct file *, loff_t, loff_t, int);
304 loff_t nfs_file_llseek(struct file *, loff_t, int);
305 int nfs_file_flush(struct file *, fl_owner_t);
306 ssize_t nfs_file_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
307 ssize_t nfs_file_splice_read(struct file *, loff_t *, struct pipe_inode_info *,
308                              size_t, unsigned int);
309 int nfs_file_mmap(struct file *, struct vm_area_struct *);
310 ssize_t nfs_file_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
311 int nfs_file_release(struct inode *, struct file *);
312 int nfs_lock(struct file *, int, struct file_lock *);
313 int nfs_flock(struct file *, int, struct file_lock *);
314 ssize_t nfs_file_splice_write(struct pipe_inode_info *, struct file *, loff_t *,
315                               size_t, unsigned int);
316 int nfs_check_flags(int);
317 int nfs_setlease(struct file *, long, struct file_lock **);
318 
319 /* inode.c */
320 extern struct workqueue_struct *nfsiod_workqueue;
321 extern struct inode *nfs_alloc_inode(struct super_block *sb);
322 extern void nfs_destroy_inode(struct inode *);
323 extern int nfs_write_inode(struct inode *, struct writeback_control *);
324 extern int nfs_drop_inode(struct inode *);
325 extern void nfs_clear_inode(struct inode *);
326 extern void nfs_evict_inode(struct inode *);
327 void nfs_zap_acl_cache(struct inode *inode);
328 extern int nfs_wait_bit_killable(void *word);
329 
330 /* super.c */
331 extern const struct super_operations nfs_sops;
332 extern struct file_system_type nfs_fs_type;
333 extern struct file_system_type nfs_xdev_fs_type;
334 #if IS_ENABLED(CONFIG_NFS_V4)
335 extern struct file_system_type nfs4_xdev_fs_type;
336 extern struct file_system_type nfs4_referral_fs_type;
337 #endif
338 struct dentry *nfs_try_mount(int, const char *, struct nfs_mount_info *,
339                         struct nfs_subversion *);
340 void nfs_initialise_sb(struct super_block *);
341 int nfs_set_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
342 int nfs_clone_sb_security(struct super_block *, struct dentry *, struct nfs_mount_info *);
343 struct dentry *nfs_fs_mount_common(struct nfs_server *, int, const char *,
344                                    struct nfs_mount_info *, struct nfs_subversion *);
345 struct dentry *nfs_fs_mount(struct file_system_type *, int, const char *, void *);
346 struct dentry * nfs_xdev_mount_common(struct file_system_type *, int,
347                 const char *, struct nfs_mount_info *);
348 void nfs_kill_super(struct super_block *);
349 void nfs_fill_super(struct super_block *, struct nfs_mount_info *);
350 
351 extern struct rpc_stat nfs_rpcstat;
352 
353 extern int __init register_nfs_fs(void);
354 extern void __exit unregister_nfs_fs(void);
355 extern void nfs_sb_active(struct super_block *sb);
356 extern void nfs_sb_deactive(struct super_block *sb);
357 
358 /* namespace.c */
359 #define NFS_PATH_CANONICAL 1
360 extern char *nfs_path(char **p, struct dentry *dentry,
361                       char *buffer, ssize_t buflen, unsigned flags);
362 extern struct vfsmount *nfs_d_automount(struct path *path);
363 struct vfsmount *nfs_submount(struct nfs_server *, struct dentry *,
364                               struct nfs_fh *, struct nfs_fattr *);
365 struct vfsmount *nfs_do_submount(struct dentry *, struct nfs_fh *,
366                                  struct nfs_fattr *, rpc_authflavor_t);
367 
368 /* getroot.c */
369 extern struct dentry *nfs_get_root(struct super_block *, struct nfs_fh *,
370                                    const char *);
371 #if IS_ENABLED(CONFIG_NFS_V4)
372 extern struct dentry *nfs4_get_root(struct super_block *, struct nfs_fh *,
373                                     const char *);
374 
375 extern int nfs4_get_rootfh(struct nfs_server *server, struct nfs_fh *mntfh, bool);
376 #endif
377 
378 struct nfs_pgio_completion_ops;
379 /* read.c */
380 extern struct nfs_read_header *nfs_readhdr_alloc(void);
381 extern void nfs_readhdr_free(struct nfs_pgio_header *hdr);
382 extern void nfs_pageio_init_read(struct nfs_pageio_descriptor *pgio,
383                         struct inode *inode,
384                         const struct nfs_pgio_completion_ops *compl_ops);
385 extern int nfs_initiate_read(struct rpc_clnt *clnt,
386                              struct nfs_read_data *data,
387                              const struct rpc_call_ops *call_ops, int flags);
388 extern void nfs_read_prepare(struct rpc_task *task, void *calldata);
389 extern int nfs_generic_pagein(struct nfs_pageio_descriptor *desc,
390                               struct nfs_pgio_header *hdr);
391 extern void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio);
392 extern void nfs_readdata_release(struct nfs_read_data *rdata);
393 
394 /* super.c */
395 void nfs_clone_super(struct super_block *, struct nfs_mount_info *);
396 void nfs_umount_begin(struct super_block *);
397 int  nfs_statfs(struct dentry *, struct kstatfs *);
398 int  nfs_show_options(struct seq_file *, struct dentry *);
399 int  nfs_show_devname(struct seq_file *, struct dentry *);
400 int  nfs_show_path(struct seq_file *, struct dentry *);
401 int  nfs_show_stats(struct seq_file *, struct dentry *);
402 void nfs_put_super(struct super_block *);
403 int nfs_remount(struct super_block *sb, int *flags, char *raw_data);
404 
405 /* write.c */
406 extern void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
407                         struct inode *inode, int ioflags,
408                         const struct nfs_pgio_completion_ops *compl_ops);
409 extern struct nfs_write_header *nfs_writehdr_alloc(void);
410 extern void nfs_writehdr_free(struct nfs_pgio_header *hdr);
411 extern int nfs_generic_flush(struct nfs_pageio_descriptor *desc,
412                              struct nfs_pgio_header *hdr);
413 extern void nfs_pageio_reset_write_mds(struct nfs_pageio_descriptor *pgio);
414 extern void nfs_writedata_release(struct nfs_write_data *wdata);
415 extern void nfs_commit_free(struct nfs_commit_data *p);
416 extern int nfs_initiate_write(struct rpc_clnt *clnt,
417                               struct nfs_write_data *data,
418                               const struct rpc_call_ops *call_ops,
419                               int how, int flags);
420 extern void nfs_write_prepare(struct rpc_task *task, void *calldata);
421 extern void nfs_commit_prepare(struct rpc_task *task, void *calldata);
422 extern int nfs_initiate_commit(struct rpc_clnt *clnt,
423                                struct nfs_commit_data *data,
424                                const struct rpc_call_ops *call_ops,
425                                int how, int flags);
426 extern void nfs_init_commit(struct nfs_commit_data *data,
427                             struct list_head *head,
428                             struct pnfs_layout_segment *lseg,
429                             struct nfs_commit_info *cinfo);
430 int nfs_scan_commit_list(struct list_head *src, struct list_head *dst,
431                          struct nfs_commit_info *cinfo, int max);
432 int nfs_scan_commit(struct inode *inode, struct list_head *dst,
433                     struct nfs_commit_info *cinfo);
434 void nfs_mark_request_commit(struct nfs_page *req,
435                              struct pnfs_layout_segment *lseg,
436                              struct nfs_commit_info *cinfo);
437 int nfs_generic_commit_list(struct inode *inode, struct list_head *head,
438                             int how, struct nfs_commit_info *cinfo);
439 void nfs_retry_commit(struct list_head *page_list,
440                       struct pnfs_layout_segment *lseg,
441                       struct nfs_commit_info *cinfo);
442 void nfs_commitdata_release(struct nfs_commit_data *data);
443 void nfs_request_add_commit_list(struct nfs_page *req, struct list_head *dst,
444                                  struct nfs_commit_info *cinfo);
445 void nfs_request_remove_commit_list(struct nfs_page *req,
446                                     struct nfs_commit_info *cinfo);
447 void nfs_init_cinfo(struct nfs_commit_info *cinfo,
448                     struct inode *inode,
449                     struct nfs_direct_req *dreq);
450 int nfs_key_timeout_notify(struct file *filp, struct inode *inode);
451 bool nfs_ctx_key_to_expire(struct nfs_open_context *ctx);
452 
453 #ifdef CONFIG_MIGRATION
454 extern int nfs_migrate_page(struct address_space *,
455                 struct page *, struct page *, enum migrate_mode);
456 #else
457 #define nfs_migrate_page NULL
458 #endif
459 
460 /* direct.c */
461 void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo,
462                               struct nfs_direct_req *dreq);
463 static inline void nfs_inode_dio_wait(struct inode *inode)
464 {
465         inode_dio_wait(inode);
466 }
467 extern ssize_t nfs_dreq_bytes_left(struct nfs_direct_req *dreq);
468 
469 /* nfs4proc.c */
470 extern void __nfs4_read_done_cb(struct nfs_read_data *);
471 extern struct nfs_client *nfs4_init_client(struct nfs_client *clp,
472                             const struct rpc_timeout *timeparms,
473                             const char *ip_addr);
474 extern int nfs40_walk_client_list(struct nfs_client *clp,
475                                 struct nfs_client **result,
476                                 struct rpc_cred *cred);
477 extern int nfs41_walk_client_list(struct nfs_client *clp,
478                                 struct nfs_client **result,
479                                 struct rpc_cred *cred);
480 
481 /*
482  * Determine the device name as a string
483  */
484 static inline char *nfs_devname(struct dentry *dentry,
485                                 char *buffer, ssize_t buflen)
486 {
487         char *dummy;
488         return nfs_path(&dummy, dentry, buffer, buflen, NFS_PATH_CANONICAL);
489 }
490 
491 /*
492  * Determine the actual block size (and log2 thereof)
493  */
494 static inline
495 unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
496 {
497         /* make sure blocksize is a power of two */
498         if ((bsize & (bsize - 1)) || nrbitsp) {
499                 unsigned char   nrbits;
500 
501                 for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
502                         ;
503                 bsize = 1 << nrbits;
504                 if (nrbitsp)
505                         *nrbitsp = nrbits;
506         }
507 
508         return bsize;
509 }
510 
511 /*
512  * Calculate the number of 512byte blocks used.
513  */
514 static inline blkcnt_t nfs_calc_block_size(u64 tsize)
515 {
516         blkcnt_t used = (tsize + 511) >> 9;
517         return (used > ULONG_MAX) ? ULONG_MAX : used;
518 }
519 
520 /*
521  * Compute and set NFS server blocksize
522  */
523 static inline
524 unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
525 {
526         if (bsize < NFS_MIN_FILE_IO_SIZE)
527                 bsize = NFS_DEF_FILE_IO_SIZE;
528         else if (bsize >= NFS_MAX_FILE_IO_SIZE)
529                 bsize = NFS_MAX_FILE_IO_SIZE;
530 
531         return nfs_block_bits(bsize, nrbitsp);
532 }
533 
534 /*
535  * Determine the maximum file size for a superblock
536  */
537 static inline
538 void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
539 {
540         sb->s_maxbytes = (loff_t)maxfilesize;
541         if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
542                 sb->s_maxbytes = MAX_LFS_FILESIZE;
543 }
544 
545 /*
546  * Determine the number of bytes of data the page contains
547  */
548 static inline
549 unsigned int nfs_page_length(struct page *page)
550 {
551         loff_t i_size = i_size_read(page_file_mapping(page)->host);
552 
553         if (i_size > 0) {
554                 pgoff_t page_index = page_file_index(page);
555                 pgoff_t end_index = (i_size - 1) >> PAGE_CACHE_SHIFT;
556                 if (page_index < end_index)
557                         return PAGE_CACHE_SIZE;
558                 if (page_index == end_index)
559                         return ((i_size - 1) & ~PAGE_CACHE_MASK) + 1;
560         }
561         return 0;
562 }
563 
564 /*
565  * Convert a umode to a dirent->d_type
566  */
567 static inline
568 unsigned char nfs_umode_to_dtype(umode_t mode)
569 {
570         return (mode >> 12) & 15;
571 }
572 
573 /*
574  * Determine the number of pages in an array of length 'len' and
575  * with a base offset of 'base'
576  */
577 static inline
578 unsigned int nfs_page_array_len(unsigned int base, size_t len)
579 {
580         return ((unsigned long)len + (unsigned long)base +
581                 PAGE_SIZE - 1) >> PAGE_SHIFT;
582 }
583 
584 /*
585  * Convert a struct timespec into a 64-bit change attribute
586  *
587  * This does approximately the same thing as timespec_to_ns(),
588  * but for calculation efficiency, we multiply the seconds by
589  * 1024*1024*1024.
590  */
591 static inline
592 u64 nfs_timespec_to_change_attr(const struct timespec *ts)
593 {
594         return ((u64)ts->tv_sec << 30) + ts->tv_nsec;
595 }
596 
597 #ifdef CONFIG_CRC32
598 /**
599  * nfs_fhandle_hash - calculate the crc32 hash for the filehandle
600  * @fh - pointer to filehandle
601  *
602  * returns a crc32 hash for the filehandle that is compatible with
603  * the one displayed by "wireshark".
604  */
605 static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
606 {
607         return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);
608 }
609 #else
610 static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
611 {
612         return 0;
613 }
614 #endif
615 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp