Merge tag 'printk-for-5.13' of git://git.kernel.org/pub/scm/linux/kernel/git/printk...
[platform/kernel/linux-rpi.git] / samples / watch_queue / watch_test.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Use watch_queue API to watch for notifications.
3  *
4  * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7
8 #define _GNU_SOURCE
9 #include <stdbool.h>
10 #include <stdarg.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <signal.h>
15 #include <unistd.h>
16 #include <errno.h>
17 #include <sys/ioctl.h>
18 #include <limits.h>
19 #include <linux/watch_queue.h>
20 #include <linux/unistd.h>
21 #include <linux/keyctl.h>
22
23 #ifndef KEYCTL_WATCH_KEY
24 #define KEYCTL_WATCH_KEY -1
25 #endif
26 #ifndef __NR_keyctl
27 #define __NR_keyctl -1
28 #endif
29
30 #define BUF_SIZE 256
31
32 static long keyctl_watch_key(int key, int watch_fd, int watch_id)
33 {
34         return syscall(__NR_keyctl, KEYCTL_WATCH_KEY, key, watch_fd, watch_id);
35 }
36
37 static const char *key_subtypes[256] = {
38         [NOTIFY_KEY_INSTANTIATED]       = "instantiated",
39         [NOTIFY_KEY_UPDATED]            = "updated",
40         [NOTIFY_KEY_LINKED]             = "linked",
41         [NOTIFY_KEY_UNLINKED]           = "unlinked",
42         [NOTIFY_KEY_CLEARED]            = "cleared",
43         [NOTIFY_KEY_REVOKED]            = "revoked",
44         [NOTIFY_KEY_INVALIDATED]        = "invalidated",
45         [NOTIFY_KEY_SETATTR]            = "setattr",
46 };
47
48 static void saw_key_change(struct watch_notification *n, size_t len)
49 {
50         struct key_notification *k = (struct key_notification *)n;
51
52         if (len != sizeof(struct key_notification)) {
53                 fprintf(stderr, "Incorrect key message length\n");
54                 return;
55         }
56
57         printf("KEY %08x change=%u[%s] aux=%u\n",
58                k->key_id, n->subtype, key_subtypes[n->subtype], k->aux);
59 }
60
61 /*
62  * Consume and display events.
63  */
64 static void consumer(int fd)
65 {
66         unsigned char buffer[433], *p, *end;
67         union {
68                 struct watch_notification n;
69                 unsigned char buf1[128];
70         } n;
71         ssize_t buf_len;
72
73         for (;;) {
74                 buf_len = read(fd, buffer, sizeof(buffer));
75                 if (buf_len == -1) {
76                         perror("read");
77                         exit(1);
78                 }
79
80                 if (buf_len == 0) {
81                         printf("-- END --\n");
82                         return;
83                 }
84
85                 if (buf_len > sizeof(buffer)) {
86                         fprintf(stderr, "Read buffer overrun: %zd\n", buf_len);
87                         return;
88                 }
89
90                 printf("read() = %zd\n", buf_len);
91
92                 p = buffer;
93                 end = buffer + buf_len;
94                 while (p < end) {
95                         size_t largest, len;
96
97                         largest = end - p;
98                         if (largest > 128)
99                                 largest = 128;
100                         if (largest < sizeof(struct watch_notification)) {
101                                 fprintf(stderr, "Short message header: %zu\n", largest);
102                                 return;
103                         }
104                         memcpy(&n, p, largest);
105
106                         printf("NOTIFY[%03zx]: ty=%06x sy=%02x i=%08x\n",
107                                p - buffer, n.n.type, n.n.subtype, n.n.info);
108
109                         len = n.n.info & WATCH_INFO_LENGTH;
110                         if (len < sizeof(n.n) || len > largest) {
111                                 fprintf(stderr, "Bad message length: %zu/%zu\n", len, largest);
112                                 exit(1);
113                         }
114
115                         switch (n.n.type) {
116                         case WATCH_TYPE_META:
117                                 switch (n.n.subtype) {
118                                 case WATCH_META_REMOVAL_NOTIFICATION:
119                                         printf("REMOVAL of watchpoint %08x\n",
120                                                (n.n.info & WATCH_INFO_ID) >>
121                                                WATCH_INFO_ID__SHIFT);
122                                         break;
123                                 case WATCH_META_LOSS_NOTIFICATION:
124                                         printf("-- LOSS --\n");
125                                         break;
126                                 default:
127                                         printf("other meta record\n");
128                                         break;
129                                 }
130                                 break;
131                         case WATCH_TYPE_KEY_NOTIFY:
132                                 saw_key_change(&n.n, len);
133                                 break;
134                         default:
135                                 printf("other type\n");
136                                 break;
137                         }
138
139                         p += len;
140                 }
141         }
142 }
143
144 static struct watch_notification_filter filter = {
145         .nr_filters     = 1,
146         .filters = {
147                 [0]     = {
148                         .type                   = WATCH_TYPE_KEY_NOTIFY,
149                         .subtype_filter[0]      = UINT_MAX,
150                 },
151         },
152 };
153
154 int main(int argc, char **argv)
155 {
156         int pipefd[2], fd;
157
158         if (pipe2(pipefd, O_NOTIFICATION_PIPE) == -1) {
159                 perror("pipe2");
160                 exit(1);
161         }
162         fd = pipefd[0];
163
164         if (ioctl(fd, IOC_WATCH_QUEUE_SET_SIZE, BUF_SIZE) == -1) {
165                 perror("watch_queue(size)");
166                 exit(1);
167         }
168
169         if (ioctl(fd, IOC_WATCH_QUEUE_SET_FILTER, &filter) == -1) {
170                 perror("watch_queue(filter)");
171                 exit(1);
172         }
173
174         if (keyctl_watch_key(KEY_SPEC_SESSION_KEYRING, fd, 0x01) == -1) {
175                 perror("keyctl");
176                 exit(1);
177         }
178
179         if (keyctl_watch_key(KEY_SPEC_USER_KEYRING, fd, 0x02) == -1) {
180                 perror("keyctl");
181                 exit(1);
182         }
183
184         consumer(fd);
185         exit(0);
186 }