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

TOMOYO Linux Cross Reference
Linux/include/linux/nfs_fs.h

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ 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.85 ] ~ [ 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-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 /* SPDX-License-Identifier: GPL-2.0 */
  2 /*
  3  *  linux/include/linux/nfs_fs.h
  4  *
  5  *  Copyright (C) 1992  Rick Sladkey
  6  *
  7  *  OS-specific nfs filesystem definitions and declarations
  8  */
  9 #ifndef _LINUX_NFS_FS_H
 10 #define _LINUX_NFS_FS_H
 11 
 12 #include <uapi/linux/nfs_fs.h>
 13 
 14 
 15 /*
 16  * Enable dprintk() debugging support for nfs client.
 17  */
 18 #ifdef CONFIG_NFS_DEBUG
 19 # define NFS_DEBUG
 20 #endif
 21 
 22 #include <linux/in.h>
 23 #include <linux/mm.h>
 24 #include <linux/pagemap.h>
 25 #include <linux/rbtree.h>
 26 #include <linux/refcount.h>
 27 #include <linux/rwsem.h>
 28 #include <linux/wait.h>
 29 
 30 #include <linux/sunrpc/debug.h>
 31 #include <linux/sunrpc/auth.h>
 32 #include <linux/sunrpc/clnt.h>
 33 
 34 #include <linux/nfs.h>
 35 #include <linux/nfs2.h>
 36 #include <linux/nfs3.h>
 37 #include <linux/nfs4.h>
 38 #include <linux/nfs_xdr.h>
 39 #include <linux/nfs_fs_sb.h>
 40 
 41 #include <linux/mempool.h>
 42 
 43 /*
 44  * These are the default flags for swap requests
 45  */
 46 #define NFS_RPC_SWAPFLAGS               (RPC_TASK_SWAPPER|RPC_TASK_ROOTCREDS)
 47 
 48 /*
 49  * NFSv3/v4 Access mode cache entry
 50  */
 51 struct nfs_access_entry {
 52         struct rb_node          rb_node;
 53         struct list_head        lru;
 54         struct rpc_cred *       cred;
 55         __u32                   mask;
 56         struct rcu_head         rcu_head;
 57 };
 58 
 59 struct nfs_lock_context {
 60         refcount_t count;
 61         struct list_head list;
 62         struct nfs_open_context *open_context;
 63         fl_owner_t lockowner;
 64         atomic_t io_count;
 65 };
 66 
 67 struct nfs4_state;
 68 struct nfs_open_context {
 69         struct nfs_lock_context lock_context;
 70         fl_owner_t flock_owner;
 71         struct dentry *dentry;
 72         struct rpc_cred *cred;
 73         struct nfs4_state *state;
 74         fmode_t mode;
 75 
 76         unsigned long flags;
 77 #define NFS_CONTEXT_ERROR_WRITE         (0)
 78 #define NFS_CONTEXT_RESEND_WRITES       (1)
 79 #define NFS_CONTEXT_BAD                 (2)
 80 #define NFS_CONTEXT_UNLOCK      (3)
 81         int error;
 82 
 83         struct list_head list;
 84         struct nfs4_threshold   *mdsthreshold;
 85 };
 86 
 87 struct nfs_open_dir_context {
 88         struct list_head list;
 89         struct rpc_cred *cred;
 90         unsigned long attr_gencount;
 91         __u64 dir_cookie;
 92         __u64 dup_cookie;
 93         signed char duped;
 94 };
 95 
 96 /*
 97  * NFSv4 delegation
 98  */
 99 struct nfs_delegation;
100 
101 struct posix_acl;
102 
103 /*
104  * nfs fs inode data in memory
105  */
106 struct nfs_inode {
107         /*
108          * The 64bit 'inode number'
109          */
110         __u64 fileid;
111 
112         /*
113          * NFS file handle
114          */
115         struct nfs_fh           fh;
116 
117         /*
118          * Various flags
119          */
120         unsigned long           flags;                  /* atomic bit ops */
121         unsigned long           cache_validity;         /* bit mask */
122 
123         /*
124          * read_cache_jiffies is when we started read-caching this inode.
125          * attrtimeo is for how long the cached information is assumed
126          * to be valid. A successful attribute revalidation doubles
127          * attrtimeo (up to acregmax/acdirmax), a failure resets it to
128          * acregmin/acdirmin.
129          *
130          * We need to revalidate the cached attrs for this inode if
131          *
132          *      jiffies - read_cache_jiffies >= attrtimeo
133          *
134          * Please note the comparison is greater than or equal
135          * so that zero timeout values can be specified.
136          */
137         unsigned long           read_cache_jiffies;
138         unsigned long           attrtimeo;
139         unsigned long           attrtimeo_timestamp;
140 
141         unsigned long           attr_gencount;
142         /* "Generation counter" for the attribute cache. This is
143          * bumped whenever we update the metadata on the
144          * server.
145          */
146         unsigned long           cache_change_attribute;
147 
148         struct rb_root          access_cache;
149         struct list_head        access_cache_entry_lru;
150         struct list_head        access_cache_inode_lru;
151 
152         /*
153          * This is the cookie verifier used for NFSv3 readdir
154          * operations
155          */
156         __be32                  cookieverf[2];
157 
158         atomic_long_t           nrequests;
159         struct nfs_mds_commit_info commit_info;
160 
161         /* Open contexts for shared mmap writes */
162         struct list_head        open_files;
163 
164         /* Readers: in-flight sillydelete RPC calls */
165         /* Writers: rmdir */
166         struct rw_semaphore     rmdir_sem;
167         struct mutex            commit_mutex;
168 
169 #if IS_ENABLED(CONFIG_NFS_V4)
170         struct nfs4_cached_acl  *nfs4_acl;
171         /* NFSv4 state */
172         struct list_head        open_states;
173         struct nfs_delegation __rcu *delegation;
174         struct rw_semaphore     rwsem;
175 
176         /* pNFS layout information */
177         struct pnfs_layout_hdr *layout;
178 #endif /* CONFIG_NFS_V4*/
179         /* how many bytes have been written/read and how many bytes queued up */
180         __u64 write_io;
181         __u64 read_io;
182 #ifdef CONFIG_NFS_FSCACHE
183         struct fscache_cookie   *fscache;
184 #endif
185         struct inode            vfs_inode;
186 };
187 
188 /*
189  * Access bit flags
190  */
191 #define NFS_ACCESS_READ        0x0001
192 #define NFS_ACCESS_LOOKUP      0x0002
193 #define NFS_ACCESS_MODIFY      0x0004
194 #define NFS_ACCESS_EXTEND      0x0008
195 #define NFS_ACCESS_DELETE      0x0010
196 #define NFS_ACCESS_EXECUTE     0x0020
197 
198 /*
199  * Cache validity bit flags
200  */
201 #define NFS_INO_INVALID_DATA    BIT(1)          /* cached data is invalid */
202 #define NFS_INO_INVALID_ATIME   BIT(2)          /* cached atime is invalid */
203 #define NFS_INO_INVALID_ACCESS  BIT(3)          /* cached access cred invalid */
204 #define NFS_INO_INVALID_ACL     BIT(4)          /* cached acls are invalid */
205 #define NFS_INO_REVAL_PAGECACHE BIT(5)          /* must revalidate pagecache */
206 #define NFS_INO_REVAL_FORCED    BIT(6)          /* force revalidation ignoring a delegation */
207 #define NFS_INO_INVALID_LABEL   BIT(7)          /* cached label is invalid */
208 #define NFS_INO_INVALID_CHANGE  BIT(8)          /* cached change is invalid */
209 #define NFS_INO_INVALID_CTIME   BIT(9)          /* cached ctime is invalid */
210 #define NFS_INO_INVALID_MTIME   BIT(10)         /* cached mtime is invalid */
211 #define NFS_INO_INVALID_SIZE    BIT(11)         /* cached size is invalid */
212 #define NFS_INO_INVALID_OTHER   BIT(12)         /* other attrs are invalid */
213 
214 #define NFS_INO_INVALID_ATTR    (NFS_INO_INVALID_CHANGE \
215                 | NFS_INO_INVALID_CTIME \
216                 | NFS_INO_INVALID_MTIME \
217                 | NFS_INO_INVALID_SIZE \
218                 | NFS_INO_INVALID_OTHER)        /* inode metadata is invalid */
219 
220 /*
221  * Bit offsets in flags field
222  */
223 #define NFS_INO_ADVISE_RDPLUS   (0)             /* advise readdirplus */
224 #define NFS_INO_STALE           (1)             /* possible stale inode */
225 #define NFS_INO_ACL_LRU_SET     (2)             /* Inode is on the LRU list */
226 #define NFS_INO_INVALIDATING    (3)             /* inode is being invalidated */
227 #define NFS_INO_FSCACHE         (5)             /* inode can be cached by FS-Cache */
228 #define NFS_INO_FSCACHE_LOCK    (6)             /* FS-Cache cookie management lock */
229 #define NFS_INO_LAYOUTCOMMIT    (9)             /* layoutcommit required */
230 #define NFS_INO_LAYOUTCOMMITTING (10)           /* layoutcommit inflight */
231 #define NFS_INO_LAYOUTSTATS     (11)            /* layoutstats inflight */
232 #define NFS_INO_ODIRECT         (12)            /* I/O setting is O_DIRECT */
233 
234 static inline struct nfs_inode *NFS_I(const struct inode *inode)
235 {
236         return container_of(inode, struct nfs_inode, vfs_inode);
237 }
238 
239 static inline struct nfs_server *NFS_SB(const struct super_block *s)
240 {
241         return (struct nfs_server *)(s->s_fs_info);
242 }
243 
244 static inline struct nfs_fh *NFS_FH(const struct inode *inode)
245 {
246         return &NFS_I(inode)->fh;
247 }
248 
249 static inline struct nfs_server *NFS_SERVER(const struct inode *inode)
250 {
251         return NFS_SB(inode->i_sb);
252 }
253 
254 static inline struct rpc_clnt *NFS_CLIENT(const struct inode *inode)
255 {
256         return NFS_SERVER(inode)->client;
257 }
258 
259 static inline const struct nfs_rpc_ops *NFS_PROTO(const struct inode *inode)
260 {
261         return NFS_SERVER(inode)->nfs_client->rpc_ops;
262 }
263 
264 static inline unsigned NFS_MINATTRTIMEO(const struct inode *inode)
265 {
266         struct nfs_server *nfss = NFS_SERVER(inode);
267         return S_ISDIR(inode->i_mode) ? nfss->acdirmin : nfss->acregmin;
268 }
269 
270 static inline unsigned NFS_MAXATTRTIMEO(const struct inode *inode)
271 {
272         struct nfs_server *nfss = NFS_SERVER(inode);
273         return S_ISDIR(inode->i_mode) ? nfss->acdirmax : nfss->acregmax;
274 }
275 
276 static inline int NFS_STALE(const struct inode *inode)
277 {
278         return test_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
279 }
280 
281 static inline struct fscache_cookie *nfs_i_fscache(struct inode *inode)
282 {
283 #ifdef CONFIG_NFS_FSCACHE
284         return NFS_I(inode)->fscache;
285 #else
286         return NULL;
287 #endif
288 }
289 
290 static inline __u64 NFS_FILEID(const struct inode *inode)
291 {
292         return NFS_I(inode)->fileid;
293 }
294 
295 static inline void set_nfs_fileid(struct inode *inode, __u64 fileid)
296 {
297         NFS_I(inode)->fileid = fileid;
298 }
299 
300 static inline void nfs_mark_for_revalidate(struct inode *inode)
301 {
302         struct nfs_inode *nfsi = NFS_I(inode);
303 
304         spin_lock(&inode->i_lock);
305         nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE
306                 | NFS_INO_INVALID_ACCESS
307                 | NFS_INO_INVALID_ACL
308                 | NFS_INO_INVALID_CHANGE
309                 | NFS_INO_INVALID_CTIME;
310         if (S_ISDIR(inode->i_mode))
311                 nfsi->cache_validity |= NFS_INO_INVALID_DATA;
312         spin_unlock(&inode->i_lock);
313 }
314 
315 static inline int nfs_server_capable(struct inode *inode, int cap)
316 {
317         return NFS_SERVER(inode)->caps & cap;
318 }
319 
320 static inline void nfs_set_verifier(struct dentry * dentry, unsigned long verf)
321 {
322         dentry->d_time = verf;
323 }
324 
325 /**
326  * nfs_save_change_attribute - Returns the inode attribute change cookie
327  * @dir - pointer to parent directory inode
328  * The "change attribute" is updated every time we finish an operation
329  * that will result in a metadata change on the server.
330  */
331 static inline unsigned long nfs_save_change_attribute(struct inode *dir)
332 {
333         return NFS_I(dir)->cache_change_attribute;
334 }
335 
336 /**
337  * nfs_verify_change_attribute - Detects NFS remote directory changes
338  * @dir - pointer to parent directory inode
339  * @chattr - previously saved change attribute
340  * Return "false" if the verifiers doesn't match the change attribute.
341  * This would usually indicate that the directory contents have changed on
342  * the server, and that any dentries need revalidating.
343  */
344 static inline int nfs_verify_change_attribute(struct inode *dir, unsigned long chattr)
345 {
346         return chattr == NFS_I(dir)->cache_change_attribute;
347 }
348 
349 /*
350  * linux/fs/nfs/inode.c
351  */
352 extern int nfs_sync_mapping(struct address_space *mapping);
353 extern void nfs_zap_mapping(struct inode *inode, struct address_space *mapping);
354 extern void nfs_zap_caches(struct inode *);
355 extern void nfs_invalidate_atime(struct inode *);
356 extern struct inode *nfs_fhget(struct super_block *, struct nfs_fh *,
357                                 struct nfs_fattr *, struct nfs4_label *);
358 struct inode *nfs_ilookup(struct super_block *sb, struct nfs_fattr *, struct nfs_fh *);
359 extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
360 extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr);
361 extern int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr);
362 extern int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr);
363 extern int nfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
364 extern void nfs_access_add_cache(struct inode *, struct nfs_access_entry *);
365 extern void nfs_access_set_mask(struct nfs_access_entry *, u32);
366 extern int nfs_permission(struct inode *, int);
367 extern int nfs_open(struct inode *, struct file *);
368 extern int nfs_attribute_cache_expired(struct inode *inode);
369 extern int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode);
370 extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
371 extern bool nfs_mapping_need_revalidate_inode(struct inode *inode);
372 extern int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping);
373 extern int nfs_revalidate_mapping_rcu(struct inode *inode);
374 extern int nfs_setattr(struct dentry *, struct iattr *);
375 extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr, struct nfs_fattr *);
376 extern void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
377                                 struct nfs4_label *label);
378 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
379 extern void put_nfs_open_context(struct nfs_open_context *ctx);
380 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
381 extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode, struct file *filp);
382 extern void nfs_inode_attach_open_context(struct nfs_open_context *ctx);
383 extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
384 extern void nfs_file_clear_open_context(struct file *flip);
385 extern struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx);
386 extern void nfs_put_lock_context(struct nfs_lock_context *l_ctx);
387 extern u64 nfs_compat_user_ino64(u64 fileid);
388 extern void nfs_fattr_init(struct nfs_fattr *fattr);
389 extern void nfs_fattr_set_barrier(struct nfs_fattr *fattr);
390 extern unsigned long nfs_inc_attr_generation_counter(void);
391 
392 extern struct nfs_fattr *nfs_alloc_fattr(void);
393 
394 static inline void nfs_free_fattr(const struct nfs_fattr *fattr)
395 {
396         kfree(fattr);
397 }
398 
399 extern struct nfs_fh *nfs_alloc_fhandle(void);
400 
401 static inline void nfs_free_fhandle(const struct nfs_fh *fh)
402 {
403         kfree(fh);
404 }
405 
406 #ifdef NFS_DEBUG
407 extern u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh);
408 static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh)
409 {
410         return _nfs_display_fhandle_hash(fh);
411 }
412 extern void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption);
413 #define nfs_display_fhandle(fh, caption)                        \
414         do {                                                    \
415                 if (unlikely(nfs_debug & NFSDBG_FACILITY))      \
416                         _nfs_display_fhandle(fh, caption);      \
417         } while (0)
418 #else
419 static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh)
420 {
421         return 0;
422 }
423 static inline void nfs_display_fhandle(const struct nfs_fh *fh,
424                                        const char *caption)
425 {
426 }
427 #endif
428 
429 /*
430  * linux/fs/nfs/nfsroot.c
431  */
432 extern int  nfs_root_data(char **root_device, char **root_data); /*__init*/
433 /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
434 extern __be32 root_nfs_parse_addr(char *name); /*__init*/
435 
436 /*
437  * linux/fs/nfs/file.c
438  */
439 extern const struct file_operations nfs_file_operations;
440 #if IS_ENABLED(CONFIG_NFS_V4)
441 extern const struct file_operations nfs4_file_operations;
442 #endif /* CONFIG_NFS_V4 */
443 extern const struct address_space_operations nfs_file_aops;
444 extern const struct address_space_operations nfs_dir_aops;
445 
446 static inline struct nfs_open_context *nfs_file_open_context(struct file *filp)
447 {
448         return filp->private_data;
449 }
450 
451 static inline struct rpc_cred *nfs_file_cred(struct file *file)
452 {
453         if (file != NULL) {
454                 struct nfs_open_context *ctx =
455                         nfs_file_open_context(file);
456                 if (ctx)
457                         return ctx->cred;
458         }
459         return NULL;
460 }
461 
462 /*
463  * linux/fs/nfs/direct.c
464  */
465 extern ssize_t nfs_direct_IO(struct kiocb *, struct iov_iter *);
466 extern ssize_t nfs_file_direct_read(struct kiocb *iocb,
467                         struct iov_iter *iter);
468 extern ssize_t nfs_file_direct_write(struct kiocb *iocb,
469                         struct iov_iter *iter);
470 
471 /*
472  * linux/fs/nfs/dir.c
473  */
474 extern const struct file_operations nfs_dir_operations;
475 extern const struct dentry_operations nfs_dentry_operations;
476 
477 extern void nfs_force_lookup_revalidate(struct inode *dir);
478 extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh,
479                         struct nfs_fattr *fattr, struct nfs4_label *label);
480 extern int nfs_may_open(struct inode *inode, struct rpc_cred *cred, int openflags);
481 extern void nfs_access_zap_cache(struct inode *inode);
482 
483 /*
484  * linux/fs/nfs/symlink.c
485  */
486 extern const struct inode_operations nfs_symlink_inode_operations;
487 
488 /*
489  * linux/fs/nfs/sysctl.c
490  */
491 #ifdef CONFIG_SYSCTL
492 extern int nfs_register_sysctl(void);
493 extern void nfs_unregister_sysctl(void);
494 #else
495 #define nfs_register_sysctl() 0
496 #define nfs_unregister_sysctl() do { } while(0)
497 #endif
498 
499 /*
500  * linux/fs/nfs/namespace.c
501  */
502 extern const struct inode_operations nfs_mountpoint_inode_operations;
503 extern const struct inode_operations nfs_referral_inode_operations;
504 extern int nfs_mountpoint_expiry_timeout;
505 extern void nfs_release_automount_timer(void);
506 
507 /*
508  * linux/fs/nfs/unlink.c
509  */
510 extern void nfs_complete_unlink(struct dentry *dentry, struct inode *);
511 
512 /*
513  * linux/fs/nfs/write.c
514  */
515 extern int  nfs_congestion_kb;
516 extern int  nfs_writepage(struct page *page, struct writeback_control *wbc);
517 extern int  nfs_writepages(struct address_space *, struct writeback_control *);
518 extern int  nfs_flush_incompatible(struct file *file, struct page *page);
519 extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
520 
521 /*
522  * Try to write back everything synchronously (but check the
523  * return value!)
524  */
525 extern int nfs_sync_inode(struct inode *inode);
526 extern int nfs_wb_all(struct inode *inode);
527 extern int nfs_wb_page(struct inode *inode, struct page *page);
528 extern int nfs_wb_page_cancel(struct inode *inode, struct page* page);
529 extern int  nfs_commit_inode(struct inode *, int);
530 extern struct nfs_commit_data *nfs_commitdata_alloc(bool never_fail);
531 extern void nfs_commit_free(struct nfs_commit_data *data);
532 
533 static inline int
534 nfs_have_writebacks(struct inode *inode)
535 {
536         return atomic_long_read(&NFS_I(inode)->nrequests) != 0;
537 }
538 
539 /*
540  * linux/fs/nfs/read.c
541  */
542 extern int  nfs_readpage(struct file *, struct page *);
543 extern int  nfs_readpages(struct file *, struct address_space *,
544                 struct list_head *, unsigned);
545 extern int  nfs_readpage_async(struct nfs_open_context *, struct inode *,
546                                struct page *);
547 
548 /*
549  * inline functions
550  */
551 
552 static inline loff_t nfs_size_to_loff_t(__u64 size)
553 {
554         return min_t(u64, size, OFFSET_MAX);
555 }
556 
557 static inline ino_t
558 nfs_fileid_to_ino_t(u64 fileid)
559 {
560         ino_t ino = (ino_t) fileid;
561         if (sizeof(ino_t) < sizeof(u64))
562                 ino ^= fileid >> (sizeof(u64)-sizeof(ino_t)) * 8;
563         return ino;
564 }
565 
566 #define NFS_JUKEBOX_RETRY_TIME (5 * HZ)
567 
568 
569 # undef ifdebug
570 # ifdef NFS_DEBUG
571 #  define ifdebug(fac)          if (unlikely(nfs_debug & NFSDBG_##fac))
572 #  define NFS_IFDEBUG(x)        x
573 # else
574 #  define ifdebug(fac)          if (0)
575 #  define NFS_IFDEBUG(x)
576 # endif
577 #endif
578 

~ [ 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