include/linux/watch_queue.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* User-mappable watch queue
   3  *
   4  * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  *
   7  * See Documentation/watch_queue.rst
   8  */
   9
  10 #ifndef _LINUX_WATCH_QUEUE_H
  11 #define _LINUX_WATCH_QUEUE_H
  12
  13 #include <uapi/linux/watch_queue.h>
  14 #include <linux/kref.h>
  15 #include <linux/rcupdate.h>
  16
  17 #ifdef CONFIG_WATCH_QUEUE
  18
  19 struct cred;
  20
  21 struct watch_type_filter {
  22         enum watch_notification_type type;
  23         __u32           subtype_filter[1];      /* Bitmask of subtypes to filter on */
  24         __u32           info_filter;            /* Filter on watch_notification::info */
  25         __u32           info_mask;              /* Mask of relevant bits in info_filter */
  26 };
  27
  28 struct watch_filter {
  29         union {
  30                 struct rcu_head rcu;
  31                 unsigned long   type_filter[2]; /* Bitmask of accepted types */
  32         };
  33         u32                     nr_filters;     /* Number of filters */
  34         struct watch_type_filter filters[];
  35 };
  36
  37 struct watch_queue {
  38         struct rcu_head         rcu;
  39         struct watch_filter __rcu *filter;
  40         struct pipe_inode_info  *pipe;          /* The pipe we're using as a buffer */
  41         struct hlist_head       watches;        /* Contributory watches */
  42         struct page             **notes;        /* Preallocated notifications */
  43         unsigned long           *notes_bitmap;  /* Allocation bitmap for notes */
  44         struct kref             usage;          /* Object usage count */
  45         spinlock_t              lock;
  46         unsigned int            nr_notes;       /* Number of notes */
  47         unsigned int            nr_pages;       /* Number of pages in notes[] */
  48         bool                    defunct;        /* T when queues closed */
  49 };
  50
  51 /*
  52  * Representation of a watch on an object.
  53  */
  54 struct watch {
  55         union {
  56                 struct rcu_head rcu;
  57                 u32             info_id;        /* ID to be OR'd in to info field */
  58         };
  59         struct watch_queue __rcu *queue;        /* Queue to post events to */
  60         struct hlist_node       queue_node;     /* Link in queue->watches */
  61         struct watch_list __rcu *watch_list;
  62         struct hlist_node       list_node;      /* Link in watch_list->watchers */
  63         const struct cred       *cred;          /* Creds of the owner of the watch */
  64         void                    *private;       /* Private data for the watched object */
  65         u64                     id;             /* Internal identifier */
  66         struct kref             usage;          /* Object usage count */
  67 };
  68
  69 /*
  70  * List of watches on an object.
  71  */
  72 struct watch_list {
  73         struct rcu_head         rcu;
  74         struct hlist_head       watchers;
  75         void (*release_watch)(struct watch *);
  76         spinlock_t              lock;
  77 };
  78
  79 extern void __post_watch_notification(struct watch_list *,
  80                                       struct watch_notification *,
  81                                       const struct cred *,
  82                                       u64);
  83 extern struct watch_queue *get_watch_queue(int);
  84 extern void put_watch_queue(struct watch_queue *);
  85 extern void init_watch(struct watch *, struct watch_queue *);
  86 extern int add_watch_to_object(struct watch *, struct watch_list *);
  87 extern int remove_watch_from_object(struct watch_list *, struct watch_queue *, u64, bool);
  88 extern long watch_queue_set_size(struct pipe_inode_info *, unsigned int);
  89 extern long watch_queue_set_filter(struct pipe_inode_info *,
  90                                    struct watch_notification_filter __user *);
  91 extern int watch_queue_init(struct pipe_inode_info *);
  92 extern void watch_queue_clear(struct watch_queue *);
  93
  94 static inline void init_watch_list(struct watch_list *wlist,
  95                                    void (*release_watch)(struct watch *))
  96 {
  97         INIT_HLIST_HEAD(&wlist->watchers);
  98         spin_lock_init(&wlist->lock);
  99         wlist->release_watch = release_watch;
 100 }
 101
 102 static inline void post_watch_notification(struct watch_list *wlist,
 103                                            struct watch_notification *n,
 104                                            const struct cred *cred,
 105                                            u64 id)
 106 {
 107         if (unlikely(wlist))
 108                 __post_watch_notification(wlist, n, cred, id);
 109 }
 110
 111 static inline void remove_watch_list(struct watch_list *wlist, u64 id)
 112 {
 113         if (wlist) {
 114                 remove_watch_from_object(wlist, NULL, id, true);
 115                 kfree_rcu(wlist, rcu);
 116         }
 117 }
 118
 119 /**
 120  * watch_sizeof - Calculate the information part of the size of a watch record,
 121  * given the structure size.
 122  */
 123 #define watch_sizeof(STRUCT) (sizeof(STRUCT) << WATCH_INFO_LENGTH__SHIFT)
 124
 125 #else
 126 static inline int watch_queue_init(struct pipe_inode_info *pipe)
 127 {
 128         return -ENOPKG;
 129 }
 130
 131 #endif
 132
 133 #endif /* _LINUX_WATCH_QUEUE_H */