Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * Filesystem access notification for Linux
       4                 :            :  *
       5                 :            :  *  Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
       6                 :            :  */
       7                 :            : 
       8                 :            : #ifndef __LINUX_FSNOTIFY_BACKEND_H
       9                 :            : #define __LINUX_FSNOTIFY_BACKEND_H
      10                 :            : 
      11                 :            : #ifdef __KERNEL__
      12                 :            : 
      13                 :            : #include <linux/idr.h> /* inotify uses this */
      14                 :            : #include <linux/fs.h> /* struct inode */
      15                 :            : #include <linux/list.h>
      16                 :            : #include <linux/path.h> /* struct path */
      17                 :            : #include <linux/spinlock.h>
      18                 :            : #include <linux/types.h>
      19                 :            : #include <linux/atomic.h>
      20                 :            : #include <linux/user_namespace.h>
      21                 :            : #include <linux/refcount.h>
      22                 :            : 
      23                 :            : /*
      24                 :            :  * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
      25                 :            :  * convert between them.  dnotify only needs conversion at watch creation
      26                 :            :  * so no perf loss there.  fanotify isn't defined yet, so it can use the
      27                 :            :  * wholes if it needs more events.
      28                 :            :  */
      29                 :            : #define FS_ACCESS               0x00000001      /* File was accessed */
      30                 :            : #define FS_MODIFY               0x00000002      /* File was modified */
      31                 :            : #define FS_ATTRIB               0x00000004      /* Metadata changed */
      32                 :            : #define FS_CLOSE_WRITE          0x00000008      /* Writtable file was closed */
      33                 :            : #define FS_CLOSE_NOWRITE        0x00000010      /* Unwrittable file closed */
      34                 :            : #define FS_OPEN                 0x00000020      /* File was opened */
      35                 :            : #define FS_MOVED_FROM           0x00000040      /* File was moved from X */
      36                 :            : #define FS_MOVED_TO             0x00000080      /* File was moved to Y */
      37                 :            : #define FS_CREATE               0x00000100      /* Subfile was created */
      38                 :            : #define FS_DELETE               0x00000200      /* Subfile was deleted */
      39                 :            : #define FS_DELETE_SELF          0x00000400      /* Self was deleted */
      40                 :            : #define FS_MOVE_SELF            0x00000800      /* Self was moved */
      41                 :            : #define FS_OPEN_EXEC            0x00001000      /* File was opened for exec */
      42                 :            : 
      43                 :            : #define FS_UNMOUNT              0x00002000      /* inode on umount fs */
      44                 :            : #define FS_Q_OVERFLOW           0x00004000      /* Event queued overflowed */
      45                 :            : #define FS_IN_IGNORED           0x00008000      /* last inotify event here */
      46                 :            : 
      47                 :            : #define FS_OPEN_PERM            0x00010000      /* open event in an permission hook */
      48                 :            : #define FS_ACCESS_PERM          0x00020000      /* access event in a permissions hook */
      49                 :            : #define FS_OPEN_EXEC_PERM       0x00040000      /* open/exec event in a permission hook */
      50                 :            : 
      51                 :            : #define FS_EXCL_UNLINK          0x04000000      /* do not send events if object is unlinked */
      52                 :            : #define FS_ISDIR                0x40000000      /* event occurred against dir */
      53                 :            : #define FS_IN_ONESHOT           0x80000000      /* only send event once */
      54                 :            : 
      55                 :            : #define FS_DN_RENAME            0x10000000      /* file renamed */
      56                 :            : #define FS_DN_MULTISHOT         0x20000000      /* dnotify multishot */
      57                 :            : 
      58                 :            : /* This inode cares about things that happen to its children.  Always set for
      59                 :            :  * dnotify and inotify. */
      60                 :            : #define FS_EVENT_ON_CHILD       0x08000000
      61                 :            : 
      62                 :            : #define FS_MOVE                 (FS_MOVED_FROM | FS_MOVED_TO)
      63                 :            : 
      64                 :            : /*
      65                 :            :  * Directory entry modification events - reported only to directory
      66                 :            :  * where entry is modified and not to a watching parent.
      67                 :            :  * The watching parent may get an FS_ATTRIB|FS_EVENT_ON_CHILD event
      68                 :            :  * when a directory entry inside a child subdir changes.
      69                 :            :  */
      70                 :            : #define ALL_FSNOTIFY_DIRENT_EVENTS      (FS_CREATE | FS_DELETE | FS_MOVE)
      71                 :            : 
      72                 :            : #define ALL_FSNOTIFY_PERM_EVENTS (FS_OPEN_PERM | FS_ACCESS_PERM | \
      73                 :            :                                   FS_OPEN_EXEC_PERM)
      74                 :            : 
      75                 :            : /*
      76                 :            :  * This is a list of all events that may get sent to a parent based on fs event
      77                 :            :  * happening to inodes inside that directory.
      78                 :            :  */
      79                 :            : #define FS_EVENTS_POSS_ON_CHILD   (ALL_FSNOTIFY_PERM_EVENTS | \
      80                 :            :                                    FS_ACCESS | FS_MODIFY | FS_ATTRIB | \
      81                 :            :                                    FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | \
      82                 :            :                                    FS_OPEN | FS_OPEN_EXEC)
      83                 :            : 
      84                 :            : /* Events that can be reported to backends */
      85                 :            : #define ALL_FSNOTIFY_EVENTS (ALL_FSNOTIFY_DIRENT_EVENTS | \
      86                 :            :                              FS_EVENTS_POSS_ON_CHILD | \
      87                 :            :                              FS_DELETE_SELF | FS_MOVE_SELF | FS_DN_RENAME | \
      88                 :            :                              FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED)
      89                 :            : 
      90                 :            : /* Extra flags that may be reported with event or control handling of events */
      91                 :            : #define ALL_FSNOTIFY_FLAGS  (FS_EXCL_UNLINK | FS_ISDIR | FS_IN_ONESHOT | \
      92                 :            :                              FS_DN_MULTISHOT | FS_EVENT_ON_CHILD)
      93                 :            : 
      94                 :            : #define ALL_FSNOTIFY_BITS   (ALL_FSNOTIFY_EVENTS | ALL_FSNOTIFY_FLAGS)
      95                 :            : 
      96                 :            : struct fsnotify_group;
      97                 :            : struct fsnotify_event;
      98                 :            : struct fsnotify_mark;
      99                 :            : struct fsnotify_event_private_data;
     100                 :            : struct fsnotify_fname;
     101                 :            : struct fsnotify_iter_info;
     102                 :            : 
     103                 :            : struct mem_cgroup;
     104                 :            : 
     105                 :            : /*
     106                 :            :  * Each group much define these ops.  The fsnotify infrastructure will call
     107                 :            :  * these operations for each relevant group.
     108                 :            :  *
     109                 :            :  * handle_event - main call for a group to handle an fs event
     110                 :            :  * free_group_priv - called when a group refcnt hits 0 to clean up the private union
     111                 :            :  * freeing_mark - called when a mark is being destroyed for some reason.  The group
     112                 :            :  *              MUST be holding a reference on each mark and that reference must be
     113                 :            :  *              dropped in this function.  inotify uses this function to send
     114                 :            :  *              userspace messages that marks have been removed.
     115                 :            :  */
     116                 :            : struct fsnotify_ops {
     117                 :            :         int (*handle_event)(struct fsnotify_group *group,
     118                 :            :                             struct inode *inode,
     119                 :            :                             u32 mask, const void *data, int data_type,
     120                 :            :                             const struct qstr *file_name, u32 cookie,
     121                 :            :                             struct fsnotify_iter_info *iter_info);
     122                 :            :         void (*free_group_priv)(struct fsnotify_group *group);
     123                 :            :         void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group);
     124                 :            :         void (*free_event)(struct fsnotify_event *event);
     125                 :            :         /* called on final put+free to free memory */
     126                 :            :         void (*free_mark)(struct fsnotify_mark *mark);
     127                 :            : };
     128                 :            : 
     129                 :            : /*
     130                 :            :  * all of the information about the original object we want to now send to
     131                 :            :  * a group.  If you want to carry more info from the accessing task to the
     132                 :            :  * listener this structure is where you need to be adding fields.
     133                 :            :  */
     134                 :            : struct fsnotify_event {
     135                 :            :         struct list_head list;
     136                 :            :         unsigned long objectid; /* identifier for queue merges */
     137                 :            : };
     138                 :            : 
     139                 :            : /*
     140                 :            :  * A group is a "thing" that wants to receive notification about filesystem
     141                 :            :  * events.  The mask holds the subset of event types this group cares about.
     142                 :            :  * refcnt on a group is up to the implementor and at any moment if it goes 0
     143                 :            :  * everything will be cleaned up.
     144                 :            :  */
     145                 :            : struct fsnotify_group {
     146                 :            :         const struct fsnotify_ops *ops; /* how this group handles things */
     147                 :            : 
     148                 :            :         /*
     149                 :            :          * How the refcnt is used is up to each group.  When the refcnt hits 0
     150                 :            :          * fsnotify will clean up all of the resources associated with this group.
     151                 :            :          * As an example, the dnotify group will always have a refcnt=1 and that
     152                 :            :          * will never change.  Inotify, on the other hand, has a group per
     153                 :            :          * inotify_init() and the refcnt will hit 0 only when that fd has been
     154                 :            :          * closed.
     155                 :            :          */
     156                 :            :         refcount_t refcnt;              /* things with interest in this group */
     157                 :            : 
     158                 :            :         /* needed to send notification to userspace */
     159                 :            :         spinlock_t notification_lock;           /* protect the notification_list */
     160                 :            :         struct list_head notification_list;     /* list of event_holder this group needs to send to userspace */
     161                 :            :         wait_queue_head_t notification_waitq;   /* read() on the notification file blocks on this waitq */
     162                 :            :         unsigned int q_len;                     /* events on the queue */
     163                 :            :         unsigned int max_events;                /* maximum events allowed on the list */
     164                 :            :         /*
     165                 :            :          * Valid fsnotify group priorities.  Events are send in order from highest
     166                 :            :          * priority to lowest priority.  We default to the lowest priority.
     167                 :            :          */
     168                 :            :         #define FS_PRIO_0       0 /* normal notifiers, no permissions */
     169                 :            :         #define FS_PRIO_1       1 /* fanotify content based access control */
     170                 :            :         #define FS_PRIO_2       2 /* fanotify pre-content access */
     171                 :            :         unsigned int priority;
     172                 :            :         bool shutdown;          /* group is being shut down, don't queue more events */
     173                 :            : 
     174                 :            :         /* stores all fastpath marks assoc with this group so they can be cleaned on unregister */
     175                 :            :         struct mutex mark_mutex;        /* protect marks_list */
     176                 :            :         atomic_t num_marks;             /* 1 for each mark and 1 for not being
     177                 :            :                                          * past the point of no return when freeing
     178                 :            :                                          * a group */
     179                 :            :         atomic_t user_waits;            /* Number of tasks waiting for user
     180                 :            :                                          * response */
     181                 :            :         struct list_head marks_list;    /* all inode marks for this group */
     182                 :            : 
     183                 :            :         struct fasync_struct *fsn_fa;    /* async notification */
     184                 :            : 
     185                 :            :         struct fsnotify_event *overflow_event;  /* Event we queue when the
     186                 :            :                                                  * notification list is too
     187                 :            :                                                  * full */
     188                 :            : 
     189                 :            :         struct mem_cgroup *memcg;       /* memcg to charge allocations */
     190                 :            : 
     191                 :            :         /* groups can define private fields here or use the void *private */
     192                 :            :         union {
     193                 :            :                 void *private;
     194                 :            : #ifdef CONFIG_INOTIFY_USER
     195                 :            :                 struct inotify_group_private_data {
     196                 :            :                         spinlock_t      idr_lock;
     197                 :            :                         struct idr      idr;
     198                 :            :                         struct ucounts *ucounts;
     199                 :            :                 } inotify_data;
     200                 :            : #endif
     201                 :            : #ifdef CONFIG_FANOTIFY
     202                 :            :                 struct fanotify_group_private_data {
     203                 :            :                         /* allows a group to block waiting for a userspace response */
     204                 :            :                         struct list_head access_list;
     205                 :            :                         wait_queue_head_t access_waitq;
     206                 :            :                         int flags;           /* flags from fanotify_init() */
     207                 :            :                         int f_flags; /* event_f_flags from fanotify_init() */
     208                 :            :                         unsigned int max_marks;
     209                 :            :                         struct user_struct *user;
     210                 :            :                 } fanotify_data;
     211                 :            : #endif /* CONFIG_FANOTIFY */
     212                 :            :         };
     213                 :            : };
     214                 :            : 
     215                 :            : /* when calling fsnotify tell it if the data is a path or inode */
     216                 :            : #define FSNOTIFY_EVENT_NONE     0
     217                 :            : #define FSNOTIFY_EVENT_PATH     1
     218                 :            : #define FSNOTIFY_EVENT_INODE    2
     219                 :            : 
     220                 :            : enum fsnotify_obj_type {
     221                 :            :         FSNOTIFY_OBJ_TYPE_INODE,
     222                 :            :         FSNOTIFY_OBJ_TYPE_VFSMOUNT,
     223                 :            :         FSNOTIFY_OBJ_TYPE_SB,
     224                 :            :         FSNOTIFY_OBJ_TYPE_COUNT,
     225                 :            :         FSNOTIFY_OBJ_TYPE_DETACHED = FSNOTIFY_OBJ_TYPE_COUNT
     226                 :            : };
     227                 :            : 
     228                 :            : #define FSNOTIFY_OBJ_TYPE_INODE_FL      (1U << FSNOTIFY_OBJ_TYPE_INODE)
     229                 :            : #define FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL   (1U << FSNOTIFY_OBJ_TYPE_VFSMOUNT)
     230                 :            : #define FSNOTIFY_OBJ_TYPE_SB_FL         (1U << FSNOTIFY_OBJ_TYPE_SB)
     231                 :            : #define FSNOTIFY_OBJ_ALL_TYPES_MASK     ((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1)
     232                 :            : 
     233                 :            : static inline bool fsnotify_valid_obj_type(unsigned int type)
     234                 :            : {
     235                 :            :         return (type < FSNOTIFY_OBJ_TYPE_COUNT);
     236                 :            : }
     237                 :            : 
     238                 :            : struct fsnotify_iter_info {
     239                 :            :         struct fsnotify_mark *marks[FSNOTIFY_OBJ_TYPE_COUNT];
     240                 :            :         unsigned int report_mask;
     241                 :            :         int srcu_idx;
     242                 :            : };
     243                 :            : 
     244                 :            : static inline bool fsnotify_iter_should_report_type(
     245                 :            :                 struct fsnotify_iter_info *iter_info, int type)
     246                 :            : {
     247                 :          3 :         return (iter_info->report_mask & (1U << type));
     248                 :            : }
     249                 :            : 
     250                 :            : static inline void fsnotify_iter_set_report_type(
     251                 :            :                 struct fsnotify_iter_info *iter_info, int type)
     252                 :            : {
     253                 :          3 :         iter_info->report_mask |= (1U << type);
     254                 :            : }
     255                 :            : 
     256                 :            : static inline void fsnotify_iter_set_report_type_mark(
     257                 :            :                 struct fsnotify_iter_info *iter_info, int type,
     258                 :            :                 struct fsnotify_mark *mark)
     259                 :            : {
     260                 :          3 :         iter_info->marks[type] = mark;
     261                 :          3 :         iter_info->report_mask |= (1U << type);
     262                 :            : }
     263                 :            : 
     264                 :            : #define FSNOTIFY_ITER_FUNCS(name, NAME) \
     265                 :            : static inline struct fsnotify_mark *fsnotify_iter_##name##_mark( \
     266                 :            :                 struct fsnotify_iter_info *iter_info) \
     267                 :            : { \
     268                 :            :         return (iter_info->report_mask & FSNOTIFY_OBJ_TYPE_##NAME##_FL) ? \
     269                 :            :                 iter_info->marks[FSNOTIFY_OBJ_TYPE_##NAME] : NULL; \
     270                 :            : }
     271                 :            : 
     272                 :          3 : FSNOTIFY_ITER_FUNCS(inode, INODE)
     273                 :          3 : FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
     274                 :            : FSNOTIFY_ITER_FUNCS(sb, SB)
     275                 :            : 
     276                 :            : #define fsnotify_foreach_obj_type(type) \
     277                 :            :         for (type = 0; type < FSNOTIFY_OBJ_TYPE_COUNT; type++)
     278                 :            : 
     279                 :            : /*
     280                 :            :  * fsnotify_connp_t is what we embed in objects which connector can be attached
     281                 :            :  * to. fsnotify_connp_t * is how we refer from connector back to object.
     282                 :            :  */
     283                 :            : struct fsnotify_mark_connector;
     284                 :            : typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;
     285                 :            : 
     286                 :            : /*
     287                 :            :  * Inode/vfsmount/sb point to this structure which tracks all marks attached to
     288                 :            :  * the inode/vfsmount/sb. The reference to inode/vfsmount/sb is held by this
     289                 :            :  * structure. We destroy this structure when there are no more marks attached
     290                 :            :  * to it. The structure is protected by fsnotify_mark_srcu.
     291                 :            :  */
     292                 :            : struct fsnotify_mark_connector {
     293                 :            :         spinlock_t lock;
     294                 :            :         unsigned short type;    /* Type of object [lock] */
     295                 :            : #define FSNOTIFY_CONN_FLAG_HAS_FSID     0x01
     296                 :            :         unsigned short flags;   /* flags [lock] */
     297                 :            :         __kernel_fsid_t fsid;   /* fsid of filesystem containing object */
     298                 :            :         union {
     299                 :            :                 /* Object pointer [lock] */
     300                 :            :                 fsnotify_connp_t *obj;
     301                 :            :                 /* Used listing heads to free after srcu period expires */
     302                 :            :                 struct fsnotify_mark_connector *destroy_next;
     303                 :            :         };
     304                 :            :         struct hlist_head list;
     305                 :            : };
     306                 :            : 
     307                 :            : /*
     308                 :            :  * A mark is simply an object attached to an in core inode which allows an
     309                 :            :  * fsnotify listener to indicate they are either no longer interested in events
     310                 :            :  * of a type matching mask or only interested in those events.
     311                 :            :  *
     312                 :            :  * These are flushed when an inode is evicted from core and may be flushed
     313                 :            :  * when the inode is modified (as seen by fsnotify_access).  Some fsnotify
     314                 :            :  * users (such as dnotify) will flush these when the open fd is closed and not
     315                 :            :  * at inode eviction or modification.
     316                 :            :  *
     317                 :            :  * Text in brackets is showing the lock(s) protecting modifications of a
     318                 :            :  * particular entry. obj_lock means either inode->i_lock or
     319                 :            :  * mnt->mnt_root->d_lock depending on the mark type.
     320                 :            :  */
     321                 :            : struct fsnotify_mark {
     322                 :            :         /* Mask this mark is for [mark->lock, group->mark_mutex] */
     323                 :            :         __u32 mask;
     324                 :            :         /* We hold one for presence in g_list. Also one ref for each 'thing'
     325                 :            :          * in kernel that found and may be using this mark. */
     326                 :            :         refcount_t refcnt;
     327                 :            :         /* Group this mark is for. Set on mark creation, stable until last ref
     328                 :            :          * is dropped */
     329                 :            :         struct fsnotify_group *group;
     330                 :            :         /* List of marks by group->marks_list. Also reused for queueing
     331                 :            :          * mark into destroy_list when it's waiting for the end of SRCU period
     332                 :            :          * before it can be freed. [group->mark_mutex] */
     333                 :            :         struct list_head g_list;
     334                 :            :         /* Protects inode / mnt pointers, flags, masks */
     335                 :            :         spinlock_t lock;
     336                 :            :         /* List of marks for inode / vfsmount [connector->lock, mark ref] */
     337                 :            :         struct hlist_node obj_list;
     338                 :            :         /* Head of list of marks for an object [mark ref] */
     339                 :            :         struct fsnotify_mark_connector *connector;
     340                 :            :         /* Events types to ignore [mark->lock, group->mark_mutex] */
     341                 :            :         __u32 ignored_mask;
     342                 :            : #define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY  0x01
     343                 :            : #define FSNOTIFY_MARK_FLAG_ALIVE                0x02
     344                 :            : #define FSNOTIFY_MARK_FLAG_ATTACHED             0x04
     345                 :            :         unsigned int flags;             /* flags [mark->lock] */
     346                 :            : };
     347                 :            : 
     348                 :            : #ifdef CONFIG_FSNOTIFY
     349                 :            : 
     350                 :            : /* called from the vfs helpers */
     351                 :            : 
     352                 :            : /* main fsnotify call to send events */
     353                 :            : extern int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
     354                 :            :                     const struct qstr *name, u32 cookie);
     355                 :            : extern int __fsnotify_parent(const struct path *path, struct dentry *dentry, __u32 mask);
     356                 :            : extern void __fsnotify_inode_delete(struct inode *inode);
     357                 :            : extern void __fsnotify_vfsmount_delete(struct vfsmount *mnt);
     358                 :            : extern void fsnotify_sb_delete(struct super_block *sb);
     359                 :            : extern u32 fsnotify_get_cookie(void);
     360                 :            : 
     361                 :            : static inline int fsnotify_inode_watches_children(struct inode *inode)
     362                 :            : {
     363                 :            :         /* FS_EVENT_ON_CHILD is set if the inode may care */
     364                 :          3 :         if (!(inode->i_fsnotify_mask & FS_EVENT_ON_CHILD))
     365                 :            :                 return 0;
     366                 :            :         /* this inode might care about child events, does it care about the
     367                 :            :          * specific set of events that can happen on a child? */
     368                 :          3 :         return inode->i_fsnotify_mask & FS_EVENTS_POSS_ON_CHILD;
     369                 :            : }
     370                 :            : 
     371                 :            : /*
     372                 :            :  * Update the dentry with a flag indicating the interest of its parent to receive
     373                 :            :  * filesystem events when those events happens to this dentry->d_inode.
     374                 :            :  */
     375                 :          3 : static inline void fsnotify_update_flags(struct dentry *dentry)
     376                 :            : {
     377                 :          3 :         assert_spin_locked(&dentry->d_lock);
     378                 :            : 
     379                 :            :         /*
     380                 :            :          * Serialisation of setting PARENT_WATCHED on the dentries is provided
     381                 :            :          * by d_lock. If inotify_inode_watched changes after we have taken
     382                 :            :          * d_lock, the following __fsnotify_update_child_dentry_flags call will
     383                 :            :          * find our entry, so it will spin until we complete here, and update
     384                 :            :          * us with the new state.
     385                 :            :          */
     386                 :          3 :         if (fsnotify_inode_watches_children(dentry->d_parent->d_inode))
     387                 :          3 :                 dentry->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
     388                 :            :         else
     389                 :          3 :                 dentry->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
     390                 :          3 : }
     391                 :            : 
     392                 :            : /* called from fsnotify listeners, such as fanotify or dnotify */
     393                 :            : 
     394                 :            : /* create a new group */
     395                 :            : extern struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops);
     396                 :            : /* get reference to a group */
     397                 :            : extern void fsnotify_get_group(struct fsnotify_group *group);
     398                 :            : /* drop reference on a group from fsnotify_alloc_group */
     399                 :            : extern void fsnotify_put_group(struct fsnotify_group *group);
     400                 :            : /* group destruction begins, stop queuing new events */
     401                 :            : extern void fsnotify_group_stop_queueing(struct fsnotify_group *group);
     402                 :            : /* destroy group */
     403                 :            : extern void fsnotify_destroy_group(struct fsnotify_group *group);
     404                 :            : /* fasync handler function */
     405                 :            : extern int fsnotify_fasync(int fd, struct file *file, int on);
     406                 :            : /* Free event from memory */
     407                 :            : extern void fsnotify_destroy_event(struct fsnotify_group *group,
     408                 :            :                                    struct fsnotify_event *event);
     409                 :            : /* attach the event to the group notification queue */
     410                 :            : extern int fsnotify_add_event(struct fsnotify_group *group,
     411                 :            :                               struct fsnotify_event *event,
     412                 :            :                               int (*merge)(struct list_head *,
     413                 :            :                                            struct fsnotify_event *));
     414                 :            : /* Queue overflow event to a notification group */
     415                 :            : static inline void fsnotify_queue_overflow(struct fsnotify_group *group)
     416                 :            : {
     417                 :          0 :         fsnotify_add_event(group, group->overflow_event, NULL);
     418                 :            : }
     419                 :            : 
     420                 :            : /* true if the group notification queue is empty */
     421                 :            : extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group);
     422                 :            : /* return, but do not dequeue the first event on the notification queue */
     423                 :            : extern struct fsnotify_event *fsnotify_peek_first_event(struct fsnotify_group *group);
     424                 :            : /* return AND dequeue the first event on the notification queue */
     425                 :            : extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group *group);
     426                 :            : /* Remove event queued in the notification list */
     427                 :            : extern void fsnotify_remove_queued_event(struct fsnotify_group *group,
     428                 :            :                                          struct fsnotify_event *event);
     429                 :            : 
     430                 :            : /* functions used to manipulate the marks attached to inodes */
     431                 :            : 
     432                 :            : /* Get mask of events for a list of marks */
     433                 :            : extern __u32 fsnotify_conn_mask(struct fsnotify_mark_connector *conn);
     434                 :            : /* Calculate mask of events for a list of marks */
     435                 :            : extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
     436                 :            : extern void fsnotify_init_mark(struct fsnotify_mark *mark,
     437                 :            :                                struct fsnotify_group *group);
     438                 :            : /* Find mark belonging to given group in the list of marks */
     439                 :            : extern struct fsnotify_mark *fsnotify_find_mark(fsnotify_connp_t *connp,
     440                 :            :                                                 struct fsnotify_group *group);
     441                 :            : /* Get cached fsid of filesystem containing object */
     442                 :            : extern int fsnotify_get_conn_fsid(const struct fsnotify_mark_connector *conn,
     443                 :            :                                   __kernel_fsid_t *fsid);
     444                 :            : /* attach the mark to the object */
     445                 :            : extern int fsnotify_add_mark(struct fsnotify_mark *mark,
     446                 :            :                              fsnotify_connp_t *connp, unsigned int type,
     447                 :            :                              int allow_dups, __kernel_fsid_t *fsid);
     448                 :            : extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
     449                 :            :                                     fsnotify_connp_t *connp,
     450                 :            :                                     unsigned int type, int allow_dups,
     451                 :            :                                     __kernel_fsid_t *fsid);
     452                 :            : 
     453                 :            : /* attach the mark to the inode */
     454                 :            : static inline int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
     455                 :            :                                           struct inode *inode,
     456                 :            :                                           int allow_dups)
     457                 :            : {
     458                 :          0 :         return fsnotify_add_mark(mark, &inode->i_fsnotify_marks,
     459                 :            :                                  FSNOTIFY_OBJ_TYPE_INODE, allow_dups, NULL);
     460                 :            : }
     461                 :            : static inline int fsnotify_add_inode_mark_locked(struct fsnotify_mark *mark,
     462                 :            :                                                  struct inode *inode,
     463                 :            :                                                  int allow_dups)
     464                 :            : {
     465                 :          3 :         return fsnotify_add_mark_locked(mark, &inode->i_fsnotify_marks,
     466                 :            :                                         FSNOTIFY_OBJ_TYPE_INODE, allow_dups,
     467                 :            :                                         NULL);
     468                 :            : }
     469                 :            : 
     470                 :            : /* given a group and a mark, flag mark to be freed when all references are dropped */
     471                 :            : extern void fsnotify_destroy_mark(struct fsnotify_mark *mark,
     472                 :            :                                   struct fsnotify_group *group);
     473                 :            : /* detach mark from inode / mount list, group list, drop inode reference */
     474                 :            : extern void fsnotify_detach_mark(struct fsnotify_mark *mark);
     475                 :            : /* free mark */
     476                 :            : extern void fsnotify_free_mark(struct fsnotify_mark *mark);
     477                 :            : /* Wait until all marks queued for destruction are destroyed */
     478                 :            : extern void fsnotify_wait_marks_destroyed(void);
     479                 :            : /* run all the marks in a group, and clear all of the marks attached to given object type */
     480                 :            : extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group, unsigned int type);
     481                 :            : /* run all the marks in a group, and clear all of the vfsmount marks */
     482                 :            : static inline void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
     483                 :            : {
     484                 :          0 :         fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL);
     485                 :            : }
     486                 :            : /* run all the marks in a group, and clear all of the inode marks */
     487                 :            : static inline void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
     488                 :            : {
     489                 :          0 :         fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_INODE_FL);
     490                 :            : }
     491                 :            : /* run all the marks in a group, and clear all of the sn marks */
     492                 :            : static inline void fsnotify_clear_sb_marks_by_group(struct fsnotify_group *group)
     493                 :            : {
     494                 :          0 :         fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_SB_FL);
     495                 :            : }
     496                 :            : extern void fsnotify_get_mark(struct fsnotify_mark *mark);
     497                 :            : extern void fsnotify_put_mark(struct fsnotify_mark *mark);
     498                 :            : extern void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info);
     499                 :            : extern bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info);
     500                 :            : 
     501                 :            : static inline void fsnotify_init_event(struct fsnotify_event *event,
     502                 :            :                                        unsigned long objectid)
     503                 :            : {
     504                 :          3 :         INIT_LIST_HEAD(&event->list);
     505                 :          3 :         event->objectid = objectid;
     506                 :            : }
     507                 :            : 
     508                 :            : #else
     509                 :            : 
     510                 :            : static inline int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int data_is,
     511                 :            :                            const struct qstr *name, u32 cookie)
     512                 :            : {
     513                 :            :         return 0;
     514                 :            : }
     515                 :            : 
     516                 :            : static inline int __fsnotify_parent(const struct path *path, struct dentry *dentry, __u32 mask)
     517                 :            : {
     518                 :            :         return 0;
     519                 :            : }
     520                 :            : 
     521                 :            : static inline void __fsnotify_inode_delete(struct inode *inode)
     522                 :            : {}
     523                 :            : 
     524                 :            : static inline void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
     525                 :            : {}
     526                 :            : 
     527                 :            : static inline void fsnotify_sb_delete(struct super_block *sb)
     528                 :            : {}
     529                 :            : 
     530                 :            : static inline void fsnotify_update_flags(struct dentry *dentry)
     531                 :            : {}
     532                 :            : 
     533                 :            : static inline u32 fsnotify_get_cookie(void)
     534                 :            : {
     535                 :            :         return 0;
     536                 :            : }
     537                 :            : 
     538                 :            : static inline void fsnotify_unmount_inodes(struct super_block *sb)
     539                 :            : {}
     540                 :            : 
     541                 :            : #endif  /* CONFIG_FSNOTIFY */
     542                 :            : 
     543                 :            : #endif  /* __KERNEL __ */
     544                 :            : 
     545                 :            : #endif  /* __LINUX_FSNOTIFY_BACKEND_H */