inotify.h 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227
  1. /*
  2. * Inode based directory notification for Linux
  3. *
  4. * Copyright (C) 2005 John McCutchan
  5. */
  6. #ifndef _LINUX_INOTIFY_H
  7. #define _LINUX_INOTIFY_H
  8. #include <linux/types.h>
  9. /*
  10. * struct inotify_event - structure read from the inotify device for each event
  11. *
  12. * When you are watching a directory, you will receive the filename for events
  13. * such as IN_CREATE, IN_DELETE, IN_OPEN, IN_CLOSE, ..., relative to the wd.
  14. */
  15. struct inotify_event {
  16. __s32 wd; /* watch descriptor */
  17. __u32 mask; /* watch mask */
  18. __u32 cookie; /* cookie to synchronize two events */
  19. __u32 len; /* length (including nulls) of name */
  20. char name[0]; /* stub for possible name */
  21. };
  22. /* the following are legal, implemented events that user-space can watch for */
  23. #define IN_ACCESS 0x00000001 /* File was accessed */
  24. #define IN_MODIFY 0x00000002 /* File was modified */
  25. #define IN_ATTRIB 0x00000004 /* Metadata changed */
  26. #define IN_CLOSE_WRITE 0x00000008 /* Writtable file was closed */
  27. #define IN_CLOSE_NOWRITE 0x00000010 /* Unwrittable file closed */
  28. #define IN_OPEN 0x00000020 /* File was opened */
  29. #define IN_MOVED_FROM 0x00000040 /* File was moved from X */
  30. #define IN_MOVED_TO 0x00000080 /* File was moved to Y */
  31. #define IN_CREATE 0x00000100 /* Subfile was created */
  32. #define IN_DELETE 0x00000200 /* Subfile was deleted */
  33. #define IN_DELETE_SELF 0x00000400 /* Self was deleted */
  34. #define IN_MOVE_SELF 0x00000800 /* Self was moved */
  35. /* the following are legal events. they are sent as needed to any watch */
  36. #define IN_UNMOUNT 0x00002000 /* Backing fs was unmounted */
  37. #define IN_Q_OVERFLOW 0x00004000 /* Event queued overflowed */
  38. #define IN_IGNORED 0x00008000 /* File was ignored */
  39. /* helper events */
  40. #define IN_CLOSE (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* close */
  41. #define IN_MOVE (IN_MOVED_FROM | IN_MOVED_TO) /* moves */
  42. /* special flags */
  43. #define IN_ONLYDIR 0x01000000 /* only watch the path if it is a directory */
  44. #define IN_DONT_FOLLOW 0x02000000 /* don't follow a sym link */
  45. #define IN_MASK_ADD 0x20000000 /* add to the mask of an already existing watch */
  46. #define IN_ISDIR 0x40000000 /* event occurred against dir */
  47. #define IN_ONESHOT 0x80000000 /* only send event once */
  48. /*
  49. * All of the events - we build the list by hand so that we can add flags in
  50. * the future and not break backward compatibility. Apps will get only the
  51. * events that they originally wanted. Be sure to add new events here!
  52. */
  53. #define IN_ALL_EVENTS (IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE | \
  54. IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM | \
  55. IN_MOVED_TO | IN_DELETE | IN_CREATE | IN_DELETE_SELF | \
  56. IN_MOVE_SELF)
  57. #ifdef __KERNEL__
  58. #include <linux/dcache.h>
  59. #include <linux/fs.h>
  60. /*
  61. * struct inotify_watch - represents a watch request on a specific inode
  62. *
  63. * h_list is protected by ih->mutex of the associated inotify_handle.
  64. * i_list, mask are protected by inode->inotify_mutex of the associated inode.
  65. * ih, inode, and wd are never written to once the watch is created.
  66. *
  67. * Callers must use the established inotify interfaces to access inotify_watch
  68. * contents. The content of this structure is private to the inotify
  69. * implementation.
  70. */
  71. struct inotify_watch {
  72. struct list_head h_list; /* entry in inotify_handle's list */
  73. struct list_head i_list; /* entry in inode's list */
  74. atomic_t count; /* reference count */
  75. struct inotify_handle *ih; /* associated inotify handle */
  76. struct inode *inode; /* associated inode */
  77. __s32 wd; /* watch descriptor */
  78. __u32 mask; /* event mask for this watch */
  79. };
  80. struct inotify_operations {
  81. void (*handle_event)(struct inotify_watch *, u32, u32, u32,
  82. const char *, struct inode *);
  83. void (*destroy_watch)(struct inotify_watch *);
  84. };
  85. #ifdef CONFIG_INOTIFY
  86. /* Kernel API for producing events */
  87. extern void inotify_d_instantiate(struct dentry *, struct inode *);
  88. extern void inotify_d_move(struct dentry *);
  89. extern void inotify_inode_queue_event(struct inode *, __u32, __u32,
  90. const char *, struct inode *);
  91. extern void inotify_dentry_parent_queue_event(struct dentry *, __u32, __u32,
  92. const char *);
  93. extern void inotify_unmount_inodes(struct list_head *);
  94. extern void inotify_inode_is_dead(struct inode *);
  95. extern u32 inotify_get_cookie(void);
  96. /* Kernel Consumer API */
  97. extern struct inotify_handle *inotify_init(const struct inotify_operations *);
  98. extern void inotify_init_watch(struct inotify_watch *);
  99. extern void inotify_destroy(struct inotify_handle *);
  100. extern __s32 inotify_find_watch(struct inotify_handle *, struct inode *,
  101. struct inotify_watch **);
  102. extern __s32 inotify_find_update_watch(struct inotify_handle *, struct inode *,
  103. u32);
  104. extern __s32 inotify_add_watch(struct inotify_handle *, struct inotify_watch *,
  105. struct inode *, __u32);
  106. extern int inotify_rm_watch(struct inotify_handle *, struct inotify_watch *);
  107. extern int inotify_rm_wd(struct inotify_handle *, __u32);
  108. extern void inotify_remove_watch_locked(struct inotify_handle *,
  109. struct inotify_watch *);
  110. extern void get_inotify_watch(struct inotify_watch *);
  111. extern void put_inotify_watch(struct inotify_watch *);
  112. #else
  113. static inline void inotify_d_instantiate(struct dentry *dentry,
  114. struct inode *inode)
  115. {
  116. }
  117. static inline void inotify_d_move(struct dentry *dentry)
  118. {
  119. }
  120. static inline void inotify_inode_queue_event(struct inode *inode,
  121. __u32 mask, __u32 cookie,
  122. const char *filename,
  123. struct inode *n_inode)
  124. {
  125. }
  126. static inline void inotify_dentry_parent_queue_event(struct dentry *dentry,
  127. __u32 mask, __u32 cookie,
  128. const char *filename)
  129. {
  130. }
  131. static inline void inotify_unmount_inodes(struct list_head *list)
  132. {
  133. }
  134. static inline void inotify_inode_is_dead(struct inode *inode)
  135. {
  136. }
  137. static inline u32 inotify_get_cookie(void)
  138. {
  139. return 0;
  140. }
  141. static inline struct inotify_handle *inotify_init(const struct inotify_operations *ops)
  142. {
  143. return ERR_PTR(-EOPNOTSUPP);
  144. }
  145. static inline void inotify_init_watch(struct inotify_watch *watch)
  146. {
  147. }
  148. static inline void inotify_destroy(struct inotify_handle *ih)
  149. {
  150. }
  151. static inline __s32 inotify_find_watch(struct inotify_handle *ih, struct inode *inode,
  152. struct inotify_watch **watchp)
  153. {
  154. return -EOPNOTSUPP;
  155. }
  156. static inline __s32 inotify_find_update_watch(struct inotify_handle *ih,
  157. struct inode *inode, u32 mask)
  158. {
  159. return -EOPNOTSUPP;
  160. }
  161. static inline __s32 inotify_add_watch(struct inotify_handle *ih,
  162. struct inotify_watch *watch,
  163. struct inode *inode, __u32 mask)
  164. {
  165. return -EOPNOTSUPP;
  166. }
  167. static inline int inotify_rm_watch(struct inotify_handle *ih,
  168. struct inotify_watch *watch)
  169. {
  170. return -EOPNOTSUPP;
  171. }
  172. static inline int inotify_rm_wd(struct inotify_handle *ih, __u32 wd)
  173. {
  174. return -EOPNOTSUPP;
  175. }
  176. static inline void inotify_remove_watch_locked(struct inotify_handle *ih,
  177. struct inotify_watch *watch)
  178. {
  179. }
  180. static inline void get_inotify_watch(struct inotify_watch *watch)
  181. {
  182. }
  183. static inline void put_inotify_watch(struct inotify_watch *watch)
  184. {
  185. }
  186. #endif /* CONFIG_INOTIFY */
  187. #endif /* __KERNEL __ */
  188. #endif /* _LINUX_INOTIFY_H */