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

TOMOYO Linux Cross Reference
Linux/fs/orangefs/orangefs-kernel.h

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ 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 /*
  2  * (C) 2001 Clemson University and The University of Chicago
  3  *
  4  * See COPYING in top-level directory.
  5  */
  6 
  7 /*
  8  *  The ORANGEFS Linux kernel support allows ORANGEFS volumes to be mounted and
  9  *  accessed through the Linux VFS (i.e. using standard I/O system calls).
 10  *  This support is only needed on clients that wish to mount the file system.
 11  *
 12  */
 13 
 14 /*
 15  *  Declarations and macros for the ORANGEFS Linux kernel support.
 16  */
 17 
 18 #ifndef __ORANGEFSKERNEL_H
 19 #define __ORANGEFSKERNEL_H
 20 
 21 #include <linux/kernel.h>
 22 #include <linux/moduleparam.h>
 23 #include <linux/statfs.h>
 24 #include <linux/backing-dev.h>
 25 #include <linux/device.h>
 26 #include <linux/mpage.h>
 27 #include <linux/namei.h>
 28 #include <linux/errno.h>
 29 #include <linux/init.h>
 30 #include <linux/module.h>
 31 #include <linux/slab.h>
 32 #include <linux/types.h>
 33 #include <linux/fs.h>
 34 #include <linux/vmalloc.h>
 35 
 36 #include <linux/aio.h>
 37 #include <linux/posix_acl.h>
 38 #include <linux/posix_acl_xattr.h>
 39 #include <linux/compat.h>
 40 #include <linux/mount.h>
 41 #include <linux/uaccess.h>
 42 #include <linux/atomic.h>
 43 #include <linux/uio.h>
 44 #include <linux/sched.h>
 45 #include <linux/mm.h>
 46 #include <linux/wait.h>
 47 #include <linux/dcache.h>
 48 #include <linux/pagemap.h>
 49 #include <linux/poll.h>
 50 #include <linux/rwsem.h>
 51 #include <linux/xattr.h>
 52 #include <linux/exportfs.h>
 53 
 54 #include <asm/unaligned.h>
 55 
 56 #include "orangefs-dev-proto.h"
 57 
 58 #ifdef ORANGEFS_KERNEL_DEBUG
 59 #define ORANGEFS_DEFAULT_OP_TIMEOUT_SECS       10
 60 #else
 61 #define ORANGEFS_DEFAULT_OP_TIMEOUT_SECS       20
 62 #endif
 63 
 64 #define ORANGEFS_BUFMAP_WAIT_TIMEOUT_SECS   30
 65 
 66 #define ORANGEFS_DEFAULT_SLOT_TIMEOUT_SECS     900      /* 15 minutes */
 67 
 68 #define ORANGEFS_REQDEVICE_NAME          "pvfs2-req"
 69 
 70 #define ORANGEFS_DEVREQ_MAGIC             0x20030529
 71 #define ORANGEFS_LINK_MAX                 0x000000FF
 72 #define ORANGEFS_PURGE_RETRY_COUNT     0x00000005
 73 #define ORANGEFS_MAX_NUM_OPTIONS          0x00000004
 74 #define ORANGEFS_MAX_MOUNT_OPT_LEN        0x00000080
 75 #define ORANGEFS_MAX_FSKEY_LEN            64
 76 
 77 #define MAX_DEV_REQ_UPSIZE (2 * sizeof(__s32) +   \
 78 sizeof(__u64) + sizeof(struct orangefs_upcall_s))
 79 #define MAX_DEV_REQ_DOWNSIZE (2 * sizeof(__s32) + \
 80 sizeof(__u64) + sizeof(struct orangefs_downcall_s))
 81 
 82 /*
 83  * valid orangefs kernel operation states
 84  *
 85  * unknown  - op was just initialized
 86  * waiting  - op is on request_list (upward bound)
 87  * inprogr  - op is in progress (waiting for downcall)
 88  * serviced - op has matching downcall; ok
 89  * purged   - op has to start a timer since client-core
 90  *            exited uncleanly before servicing op
 91  * given up - submitter has given up waiting for it
 92  */
 93 enum orangefs_vfs_op_states {
 94         OP_VFS_STATE_UNKNOWN = 0,
 95         OP_VFS_STATE_WAITING = 1,
 96         OP_VFS_STATE_INPROGR = 2,
 97         OP_VFS_STATE_SERVICED = 4,
 98         OP_VFS_STATE_PURGED = 8,
 99         OP_VFS_STATE_GIVEN_UP = 16,
100 };
101 
102 /*
103  * An array of client_debug_mask will be built to hold debug keyword/mask
104  * values fetched from userspace.
105  */
106 struct client_debug_mask {
107         char *keyword;
108         __u64 mask1;
109         __u64 mask2;
110 };
111 
112 /*
113  * orangefs kernel memory related flags
114  */
115 
116 #if ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB))
117 #define ORANGEFS_CACHE_CREATE_FLAGS SLAB_RED_ZONE
118 #else
119 #define ORANGEFS_CACHE_CREATE_FLAGS 0
120 #endif /* ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) */
121 
122 /* orangefs xattr and acl related defines */
123 #define ORANGEFS_XATTR_INDEX_POSIX_ACL_ACCESS  1
124 #define ORANGEFS_XATTR_INDEX_POSIX_ACL_DEFAULT 2
125 #define ORANGEFS_XATTR_INDEX_TRUSTED           3
126 #define ORANGEFS_XATTR_INDEX_DEFAULT           4
127 
128 #define ORANGEFS_XATTR_NAME_ACL_ACCESS XATTR_NAME_POSIX_ACL_ACCESS
129 #define ORANGEFS_XATTR_NAME_ACL_DEFAULT XATTR_NAME_POSIX_ACL_DEFAULT
130 #define ORANGEFS_XATTR_NAME_TRUSTED_PREFIX "trusted."
131 #define ORANGEFS_XATTR_NAME_DEFAULT_PREFIX ""
132 
133 /* these functions are defined in orangefs-utils.c */
134 int orangefs_prepare_cdm_array(char *debug_array_string);
135 int orangefs_prepare_debugfs_help_string(int);
136 
137 /* defined in orangefs-debugfs.c */
138 int orangefs_client_debug_init(void);
139 
140 void debug_string_to_mask(char *, void *, int);
141 void do_c_mask(int, char *, struct client_debug_mask **);
142 void do_k_mask(int, char *, __u64 **);
143 
144 void debug_mask_to_string(void *, int);
145 void do_k_string(void *, int);
146 void do_c_string(void *, int);
147 int check_amalgam_keyword(void *, int);
148 int keyword_is_amalgam(char *);
149 
150 /*these variables are defined in orangefs-mod.c */
151 extern char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
152 extern char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
153 extern char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
154 extern unsigned int kernel_mask_set_mod_init;
155 
156 extern int orangefs_init_acl(struct inode *inode, struct inode *dir);
157 extern const struct xattr_handler *orangefs_xattr_handlers[];
158 
159 extern struct posix_acl *orangefs_get_acl(struct inode *inode, int type);
160 extern int orangefs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
161 
162 /*
163  * Redefine xtvec structure so that we could move helper functions out of
164  * the define
165  */
166 struct xtvec {
167         __kernel_off_t xtv_off;         /* must be off_t */
168         __kernel_size_t xtv_len;        /* must be size_t */
169 };
170 
171 /*
172  * orangefs data structures
173  */
174 struct orangefs_kernel_op_s {
175         enum orangefs_vfs_op_states op_state;
176         __u64 tag;
177 
178         /*
179          * Set uses_shared_memory to non zero if this operation uses
180          * shared memory. If true, then a retry on the op must also
181          * get a new shared memory buffer and re-populate it.
182          * Cancels don't care - it only matters for service_operation()
183          * retry logics and cancels don't go through it anymore. It
184          * safely stays non-zero when we use it as slot_to_free.
185          */
186         union {
187                 int uses_shared_memory;
188                 int slot_to_free;
189         };
190 
191         struct orangefs_upcall_s upcall;
192         struct orangefs_downcall_s downcall;
193 
194         struct completion waitq;
195         spinlock_t lock;
196 
197         int attempts;
198 
199         struct list_head list;
200 };
201 
202 #define set_op_state_waiting(op)     ((op)->op_state = OP_VFS_STATE_WAITING)
203 #define set_op_state_inprogress(op)  ((op)->op_state = OP_VFS_STATE_INPROGR)
204 #define set_op_state_given_up(op)  ((op)->op_state = OP_VFS_STATE_GIVEN_UP)
205 static inline void set_op_state_serviced(struct orangefs_kernel_op_s *op)
206 {
207         op->op_state = OP_VFS_STATE_SERVICED;
208         complete(&op->waitq);
209 }
210 
211 #define op_state_waiting(op)     ((op)->op_state & OP_VFS_STATE_WAITING)
212 #define op_state_in_progress(op) ((op)->op_state & OP_VFS_STATE_INPROGR)
213 #define op_state_serviced(op)    ((op)->op_state & OP_VFS_STATE_SERVICED)
214 #define op_state_purged(op)      ((op)->op_state & OP_VFS_STATE_PURGED)
215 #define op_state_given_up(op)    ((op)->op_state & OP_VFS_STATE_GIVEN_UP)
216 #define op_is_cancel(op)         ((op)->upcall.type == ORANGEFS_VFS_OP_CANCEL)
217 
218 void op_release(struct orangefs_kernel_op_s *op);
219 
220 extern void orangefs_bufmap_put(int);
221 static inline void put_cancel(struct orangefs_kernel_op_s *op)
222 {
223         orangefs_bufmap_put(op->slot_to_free);
224         op_release(op);
225 }
226 
227 static inline void set_op_state_purged(struct orangefs_kernel_op_s *op)
228 {
229         spin_lock(&op->lock);
230         if (unlikely(op_is_cancel(op))) {
231                 list_del_init(&op->list);
232                 spin_unlock(&op->lock);
233                 put_cancel(op);
234         } else {
235                 op->op_state |= OP_VFS_STATE_PURGED;
236                 complete(&op->waitq);
237                 spin_unlock(&op->lock);
238         }
239 }
240 
241 /* per inode private orangefs info */
242 struct orangefs_inode_s {
243         struct orangefs_object_kref refn;
244         char link_target[ORANGEFS_NAME_MAX];
245         __s64 blksize;
246         /*
247          * Reading/Writing Extended attributes need to acquire the appropriate
248          * reader/writer semaphore on the orangefs_inode_s structure.
249          */
250         struct rw_semaphore xattr_sem;
251 
252         struct inode vfs_inode;
253         sector_t last_failed_block_index_read;
254 
255         /*
256          * State of in-memory attributes not yet flushed to disk associated
257          * with this object
258          */
259         unsigned long pinode_flags;
260 };
261 
262 #define P_ATIME_FLAG 0
263 #define P_MTIME_FLAG 1
264 #define P_CTIME_FLAG 2
265 #define P_MODE_FLAG  3
266 
267 #define ClearAtimeFlag(pinode) clear_bit(P_ATIME_FLAG, &(pinode)->pinode_flags)
268 #define SetAtimeFlag(pinode)   set_bit(P_ATIME_FLAG, &(pinode)->pinode_flags)
269 #define AtimeFlag(pinode)      test_bit(P_ATIME_FLAG, &(pinode)->pinode_flags)
270 
271 #define ClearMtimeFlag(pinode) clear_bit(P_MTIME_FLAG, &(pinode)->pinode_flags)
272 #define SetMtimeFlag(pinode)   set_bit(P_MTIME_FLAG, &(pinode)->pinode_flags)
273 #define MtimeFlag(pinode)      test_bit(P_MTIME_FLAG, &(pinode)->pinode_flags)
274 
275 #define ClearCtimeFlag(pinode) clear_bit(P_CTIME_FLAG, &(pinode)->pinode_flags)
276 #define SetCtimeFlag(pinode)   set_bit(P_CTIME_FLAG, &(pinode)->pinode_flags)
277 #define CtimeFlag(pinode)      test_bit(P_CTIME_FLAG, &(pinode)->pinode_flags)
278 
279 #define ClearModeFlag(pinode) clear_bit(P_MODE_FLAG, &(pinode)->pinode_flags)
280 #define SetModeFlag(pinode)   set_bit(P_MODE_FLAG, &(pinode)->pinode_flags)
281 #define ModeFlag(pinode)      test_bit(P_MODE_FLAG, &(pinode)->pinode_flags)
282 
283 /* per superblock private orangefs info */
284 struct orangefs_sb_info_s {
285         struct orangefs_khandle root_khandle;
286         __s32 fs_id;
287         int id;
288         int flags;
289 #define ORANGEFS_OPT_INTR       0x01
290 #define ORANGEFS_OPT_LOCAL_LOCK 0x02
291         char devname[ORANGEFS_MAX_SERVER_ADDR_LEN];
292         struct super_block *sb;
293         int mount_pending;
294         struct list_head list;
295 };
296 
297 /*
298  * structure that holds the state of any async I/O operation issued
299  * through the VFS. Needed especially to handle cancellation requests
300  * or even completion notification so that the VFS client-side daemon
301  * can free up its vfs_request slots.
302  */
303 struct orangefs_kiocb_s {
304         /* the pointer to the task that initiated the AIO */
305         struct task_struct *tsk;
306 
307         /* pointer to the kiocb that kicked this operation */
308         struct kiocb *kiocb;
309 
310         /* buffer index that was used for the I/O */
311         struct orangefs_bufmap *bufmap;
312         int buffer_index;
313 
314         /* orangefs kernel operation type */
315         struct orangefs_kernel_op_s *op;
316 
317         /* The user space buffers from/to which I/O is being staged */
318         struct iovec *iov;
319 
320         /* number of elements in the iovector */
321         unsigned long nr_segs;
322 
323         /* set to indicate the type of the operation */
324         int rw;
325 
326         /* file offset */
327         loff_t offset;
328 
329         /* and the count in bytes */
330         size_t bytes_to_be_copied;
331 
332         ssize_t bytes_copied;
333         int needs_cleanup;
334 };
335 
336 struct orangefs_stats {
337         unsigned long cache_hits;
338         unsigned long cache_misses;
339         unsigned long reads;
340         unsigned long writes;
341 };
342 
343 extern struct orangefs_stats g_orangefs_stats;
344 
345 /*
346  * NOTE: See Documentation/filesystems/porting for information
347  * on implementing FOO_I and properly accessing fs private data
348  */
349 static inline struct orangefs_inode_s *ORANGEFS_I(struct inode *inode)
350 {
351         return container_of(inode, struct orangefs_inode_s, vfs_inode);
352 }
353 
354 static inline struct orangefs_sb_info_s *ORANGEFS_SB(struct super_block *sb)
355 {
356         return (struct orangefs_sb_info_s *) sb->s_fs_info;
357 }
358 
359 /* ino_t descends from "unsigned long", 8 bytes, 64 bits. */
360 static inline ino_t orangefs_khandle_to_ino(struct orangefs_khandle *khandle)
361 {
362         union {
363                 unsigned char u[8];
364                 __u64 ino;
365         } ihandle;
366 
367         ihandle.u[0] = khandle->u[0] ^ khandle->u[4];
368         ihandle.u[1] = khandle->u[1] ^ khandle->u[5];
369         ihandle.u[2] = khandle->u[2] ^ khandle->u[6];
370         ihandle.u[3] = khandle->u[3] ^ khandle->u[7];
371         ihandle.u[4] = khandle->u[12] ^ khandle->u[8];
372         ihandle.u[5] = khandle->u[13] ^ khandle->u[9];
373         ihandle.u[6] = khandle->u[14] ^ khandle->u[10];
374         ihandle.u[7] = khandle->u[15] ^ khandle->u[11];
375 
376         return ihandle.ino;
377 }
378 
379 static inline struct orangefs_khandle *get_khandle_from_ino(struct inode *inode)
380 {
381         return &(ORANGEFS_I(inode)->refn.khandle);
382 }
383 
384 static inline __s32 get_fsid_from_ino(struct inode *inode)
385 {
386         return ORANGEFS_I(inode)->refn.fs_id;
387 }
388 
389 static inline ino_t get_ino_from_khandle(struct inode *inode)
390 {
391         struct orangefs_khandle *khandle;
392         ino_t ino;
393 
394         khandle = get_khandle_from_ino(inode);
395         ino = orangefs_khandle_to_ino(khandle);
396         return ino;
397 }
398 
399 static inline ino_t get_parent_ino_from_dentry(struct dentry *dentry)
400 {
401         return get_ino_from_khandle(dentry->d_parent->d_inode);
402 }
403 
404 static inline int is_root_handle(struct inode *inode)
405 {
406         gossip_debug(GOSSIP_DCACHE_DEBUG,
407                      "%s: root handle: %pU, this handle: %pU:\n",
408                      __func__,
409                      &ORANGEFS_SB(inode->i_sb)->root_khandle,
410                      get_khandle_from_ino(inode));
411 
412         if (ORANGEFS_khandle_cmp(&(ORANGEFS_SB(inode->i_sb)->root_khandle),
413                              get_khandle_from_ino(inode)))
414                 return 0;
415         else
416                 return 1;
417 }
418 
419 static inline int match_handle(struct orangefs_khandle resp_handle,
420                                struct inode *inode)
421 {
422         gossip_debug(GOSSIP_DCACHE_DEBUG,
423                      "%s: one handle: %pU, another handle:%pU:\n",
424                      __func__,
425                      &resp_handle,
426                      get_khandle_from_ino(inode));
427 
428         if (ORANGEFS_khandle_cmp(&resp_handle, get_khandle_from_ino(inode)))
429                 return 0;
430         else
431                 return 1;
432 }
433 
434 /*
435  * defined in orangefs-cache.c
436  */
437 int op_cache_initialize(void);
438 int op_cache_finalize(void);
439 struct orangefs_kernel_op_s *op_alloc(__s32 type);
440 void orangefs_new_tag(struct orangefs_kernel_op_s *op);
441 char *get_opname_string(struct orangefs_kernel_op_s *new_op);
442 
443 int orangefs_inode_cache_initialize(void);
444 int orangefs_inode_cache_finalize(void);
445 
446 /*
447  * defined in orangefs-mod.c
448  */
449 void purge_inprogress_ops(void);
450 
451 /*
452  * defined in waitqueue.c
453  */
454 void purge_waiting_ops(void);
455 
456 /*
457  * defined in super.c
458  */
459 struct dentry *orangefs_mount(struct file_system_type *fst,
460                            int flags,
461                            const char *devname,
462                            void *data);
463 
464 void orangefs_kill_sb(struct super_block *sb);
465 int orangefs_remount(struct orangefs_sb_info_s *);
466 
467 int fsid_key_table_initialize(void);
468 void fsid_key_table_finalize(void);
469 
470 /*
471  * defined in inode.c
472  */
473 __u32 convert_to_orangefs_mask(unsigned long lite_mask);
474 struct inode *orangefs_new_inode(struct super_block *sb,
475                               struct inode *dir,
476                               int mode,
477                               dev_t dev,
478                               struct orangefs_object_kref *ref);
479 
480 int orangefs_setattr(struct dentry *dentry, struct iattr *iattr);
481 
482 int orangefs_getattr(struct vfsmount *mnt,
483                   struct dentry *dentry,
484                   struct kstat *kstat);
485 
486 int orangefs_permission(struct inode *inode, int mask);
487 
488 /*
489  * defined in xattr.c
490  */
491 int orangefs_setxattr(struct dentry *dentry,
492                    const char *name,
493                    const void *value,
494                    size_t size,
495                    int flags);
496 
497 ssize_t orangefs_getxattr(struct dentry *dentry,
498                        const char *name,
499                        void *buffer,
500                        size_t size);
501 
502 ssize_t orangefs_listxattr(struct dentry *dentry, char *buffer, size_t size);
503 
504 /*
505  * defined in namei.c
506  */
507 struct inode *orangefs_iget(struct super_block *sb,
508                          struct orangefs_object_kref *ref);
509 
510 ssize_t orangefs_inode_read(struct inode *inode,
511                             struct iov_iter *iter,
512                             loff_t *offset,
513                             loff_t readahead_size);
514 
515 /*
516  * defined in devorangefs-req.c
517  */
518 int orangefs_dev_init(void);
519 void orangefs_dev_cleanup(void);
520 int is_daemon_in_service(void);
521 bool __is_daemon_in_service(void);
522 
523 /*
524  * defined in orangefs-utils.c
525  */
526 __s32 fsid_of_op(struct orangefs_kernel_op_s *op);
527 
528 int orangefs_flush_inode(struct inode *inode);
529 
530 ssize_t orangefs_inode_getxattr(struct inode *inode,
531                              const char *prefix,
532                              const char *name,
533                              void *buffer,
534                              size_t size);
535 
536 int orangefs_inode_setxattr(struct inode *inode,
537                          const char *prefix,
538                          const char *name,
539                          const void *value,
540                          size_t size,
541                          int flags);
542 
543 int orangefs_inode_getattr(struct inode *inode, int new, int size);
544 
545 int orangefs_inode_check_changed(struct inode *inode);
546 
547 int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr);
548 
549 void orangefs_make_bad_inode(struct inode *inode);
550 
551 int orangefs_unmount_sb(struct super_block *sb);
552 
553 bool orangefs_cancel_op_in_progress(struct orangefs_kernel_op_s *op);
554 
555 int orangefs_normalize_to_errno(__s32 error_code);
556 
557 extern struct mutex devreq_mutex;
558 extern struct mutex request_mutex;
559 extern int debug;
560 extern int op_timeout_secs;
561 extern int slot_timeout_secs;
562 extern struct list_head orangefs_superblocks;
563 extern spinlock_t orangefs_superblocks_lock;
564 extern struct list_head orangefs_request_list;
565 extern spinlock_t orangefs_request_list_lock;
566 extern wait_queue_head_t orangefs_request_list_waitq;
567 extern struct list_head *htable_ops_in_progress;
568 extern spinlock_t htable_ops_in_progress_lock;
569 extern int hash_table_size;
570 
571 extern const struct address_space_operations orangefs_address_operations;
572 extern struct backing_dev_info orangefs_backing_dev_info;
573 extern struct inode_operations orangefs_file_inode_operations;
574 extern const struct file_operations orangefs_file_operations;
575 extern struct inode_operations orangefs_symlink_inode_operations;
576 extern struct inode_operations orangefs_dir_inode_operations;
577 extern const struct file_operations orangefs_dir_operations;
578 extern const struct dentry_operations orangefs_dentry_operations;
579 extern const struct file_operations orangefs_devreq_file_operations;
580 
581 extern wait_queue_head_t orangefs_bufmap_init_waitq;
582 
583 /*
584  * misc convenience macros
585  */
586 
587 #define ORANGEFS_OP_INTERRUPTIBLE 1   /* service_operation() is interruptible */
588 #define ORANGEFS_OP_PRIORITY      2   /* service_operation() is high priority */
589 #define ORANGEFS_OP_CANCELLATION  4   /* this is a cancellation */
590 #define ORANGEFS_OP_NO_MUTEX      8   /* don't acquire request_mutex */
591 #define ORANGEFS_OP_ASYNC         16  /* Queue it, but don't wait */
592 
593 int service_operation(struct orangefs_kernel_op_s *op,
594                       const char *op_name,
595                       int flags);
596 
597 #define get_interruptible_flag(inode) \
598         ((ORANGEFS_SB(inode->i_sb)->flags & ORANGEFS_OPT_INTR) ? \
599                 ORANGEFS_OP_INTERRUPTIBLE : 0)
600 
601 #define fill_default_sys_attrs(sys_attr, type, mode)                    \
602 do {                                                                    \
603         sys_attr.owner = from_kuid(current_user_ns(), current_fsuid()); \
604         sys_attr.group = from_kgid(current_user_ns(), current_fsgid()); \
605         sys_attr.perms = ORANGEFS_util_translate_mode(mode);            \
606         sys_attr.mtime = 0;                                             \
607         sys_attr.atime = 0;                                             \
608         sys_attr.ctime = 0;                                             \
609         sys_attr.mask = ORANGEFS_ATTR_SYS_ALL_SETABLE;                  \
610 } while (0)
611 
612 static inline void orangefs_i_size_write(struct inode *inode, loff_t i_size)
613 {
614 #if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
615         mutex_lock(&inode->i_mutex);
616 #endif
617         i_size_write(inode, i_size);
618 #if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
619         mutex_unlock(&inode->i_mutex);
620 #endif
621 }
622 
623 #endif /* __ORANGEFSKERNEL_H */
624 

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