Add sample notification program

The sample program is run like:

	./samples/watch_queue/watch_test

and watches "/" for mount changes and the current session keyring for key
changes:

	# keyctl add user a a @s
	1035096409
	# keyctl unlink 1035096409 @s

producing:

	# ./watch_test
	read() = 16
	NOTIFY[000]: ty=000001 sy=02 i=00000110
	KEY 2ffc2e5d change=2[linked] aux=1035096409
	read() = 16
	NOTIFY[000]: ty=000001 sy=02 i=00000110
	KEY 2ffc2e5d change=3[unlinked] aux=1035096409

Other events may be produced, such as with a failing disk:

	read() = 22
	NOTIFY[000]: ty=000003 sy=02 i=00000416
	USB 3-7.7 dev-reset e=0 r=0
	read() = 24
	NOTIFY[000]: ty=000002 sy=06 i=00000418
	BLOCK 00800050 e=6[critical medium] s=64000ef8

This corresponds to:

	blk_update_request: critical medium error, dev sdf, sector 1677725432 op 0x0:(READ) flags 0x0 phys_seg 1 prio class 0

in dmesg.

Signed-off-by: David Howells <dhowells@redhat.com>

diff --git a/samples/Kconfig b/samples/Kconfig
index 9d236c346de506dfcf65cba58dbec3507659bc18..5c31971a5745c8339fd4bd925232918f1ba087bf 100644 (file)
--- a/samples/Kconfig
+++ b/samples/Kconfig
@@ -190,5 +190,11 @@ config SAMPLE_INTEL_MEI
        help
          Build a sample program to work with mei device.
 
+config SAMPLE_WATCH_QUEUE
+       bool "Build example /dev/watch_queue notification consumer"
+       depends on HEADERS_INSTALL
+       help
+         Build example userspace program to use the new mount_notify(),
+         sb_notify() syscalls and the KEYCTL_WATCH_KEY keyctl() function.
 
 endif # SAMPLES

diff --git a/samples/Makefile b/samples/Makefile
index f8f847b4f61f55d482b46cac2c1cebf3bc79f978..8617edf7f19a30e3d0f60e703da38bc392dfbc1d 100644 (file)
--- a/samples/Makefile
+++ b/samples/Makefile
@@ -24,3 +24,4 @@ obj-$(CONFIG_VIDEO_PCI_SKELETON)      += v4l/
 obj-y                                  += vfio-mdev/
 subdir-$(CONFIG_SAMPLE_VFS)            += vfs
 obj-$(CONFIG_SAMPLE_INTEL_MEI)         += mei/
+subdir-$(CONFIG_SAMPLE_WATCH_QUEUE)    += watch_queue

diff --git a/samples/watch_queue/Makefile b/samples/watch_queue/Makefile
new file mode 100644 (file)
index 0000000..8511fb6
--- /dev/null
+++ b/samples/watch_queue/Makefile
@@ -0,0 +1,7 @@
+# List of programs to build
+hostprogs := watch_test
+
+# Tell kbuild to always build the programs
+always-y := $(hostprogs)
+
+HOSTCFLAGS_watch_test.o += -I$(objtree)/usr/include

diff --git a/samples/watch_queue/watch_test.c b/samples/watch_queue/watch_test.c
new file mode 100644 (file)
index 0000000..4a31179
--- /dev/null
+++ b/samples/watch_queue/watch_test.c
@@ -0,0 +1,183 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Use /dev/watch_queue to watch for notifications.
+ *
+ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#define _GNU_SOURCE
+#include <stdbool.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <limits.h>
+#include <linux/watch_queue.h>
+#include <linux/unistd.h>
+#include <linux/keyctl.h>
+
+#ifndef KEYCTL_WATCH_KEY
+#define KEYCTL_WATCH_KEY -1
+#endif
+#ifndef __NR_keyctl
+#define __NR_keyctl -1
+#endif
+
+#define BUF_SIZE 256
+
+static long keyctl_watch_key(int key, int watch_fd, int watch_id)
+{
+       return syscall(__NR_keyctl, KEYCTL_WATCH_KEY, key, watch_fd, watch_id);
+}
+
+static const char *key_subtypes[256] = {
+       [NOTIFY_KEY_INSTANTIATED]       = "instantiated",
+       [NOTIFY_KEY_UPDATED]            = "updated",
+       [NOTIFY_KEY_LINKED]             = "linked",
+       [NOTIFY_KEY_UNLINKED]           = "unlinked",
+       [NOTIFY_KEY_CLEARED]            = "cleared",
+       [NOTIFY_KEY_REVOKED]            = "revoked",
+       [NOTIFY_KEY_INVALIDATED]        = "invalidated",
+       [NOTIFY_KEY_SETATTR]            = "setattr",
+};
+
+static void saw_key_change(struct watch_notification *n, size_t len)
+{
+       struct key_notification *k = (struct key_notification *)n;
+
+       if (len != sizeof(struct key_notification)) {
+               fprintf(stderr, "Incorrect key message length\n");
+               return;
+       }
+
+       printf("KEY %08x change=%u[%s] aux=%u\n",
+              k->key_id, n->subtype, key_subtypes[n->subtype], k->aux);
+}
+
+/*
+ * Consume and display events.
+ */
+static void consumer(int fd)
+{
+       unsigned char buffer[4096], *p, *end;
+       union {
+               struct watch_notification n;
+               unsigned char buf1[128];
+       } n;
+       ssize_t buf_len;
+
+       for (;;) {
+               buf_len = read(fd, buffer, sizeof(buffer));
+               if (buf_len == -1) {
+                       perror("read");
+                       exit(1);
+               }
+
+               if (buf_len == 0) {
+                       printf("-- END --\n");
+                       return;
+               }
+
+               if (buf_len > sizeof(buffer)) {
+                       fprintf(stderr, "Read buffer overrun: %zd\n", buf_len);
+                       return;
+               }
+
+               printf("read() = %zd\n", buf_len);
+
+               p = buffer;
+               end = buffer + buf_len;
+               while (p < end) {
+                       size_t largest, len;
+
+                       largest = end - p;
+                       if (largest > 128)
+                               largest = 128;
+                       if (largest < sizeof(struct watch_notification)) {
+                               fprintf(stderr, "Short message header: %zu\n", largest);
+                               return;
+                       }
+                       memcpy(&n, p, largest);
+
+                       printf("NOTIFY[%03zx]: ty=%06x sy=%02x i=%08x\n",
+                              p - buffer, n.n.type, n.n.subtype, n.n.info);
+
+                       len = n.n.info & WATCH_INFO_LENGTH;
+                       if (len < sizeof(n.n) || len > largest) {
+                               fprintf(stderr, "Bad message length: %zu/%zu\n", len, largest);
+                               exit(1);
+                       }
+
+                       switch (n.n.type) {
+                       case WATCH_TYPE_META:
+                               switch (n.n.subtype) {
+                               case WATCH_META_REMOVAL_NOTIFICATION:
+                                       printf("REMOVAL of watchpoint %08x\n",
+                                              (n.n.info & WATCH_INFO_ID) >>
+                                              WATCH_INFO_ID__SHIFT);
+                                       break;
+                               default:
+                                       printf("other meta record\n");
+                                       break;
+                               }
+                               break;
+                       case WATCH_TYPE_KEY_NOTIFY:
+                               saw_key_change(&n.n, len);
+                               break;
+                       default:
+                               printf("other type\n");
+                               break;
+                       }
+
+                       p += len;
+               }
+       }
+}
+
+static struct watch_notification_filter filter = {
+       .nr_filters     = 1,
+       .filters = {
+               [0]     = {
+                       .type                   = WATCH_TYPE_KEY_NOTIFY,
+                       .subtype_filter[0]      = UINT_MAX,
+               },
+       },
+};
+
+int main(int argc, char **argv)
+{
+       int pipefd[2], fd;
+
+       if (pipe2(pipefd, O_NOTIFICATION_PIPE) == -1) {
+               perror("pipe2");
+               exit(1);
+       }
+       fd = pipefd[0];
+
+       if (ioctl(fd, IOC_WATCH_QUEUE_SET_SIZE, BUF_SIZE) == -1) {
+               perror("watch_queue(size)");
+               exit(1);
+       }
+
+       if (ioctl(fd, IOC_WATCH_QUEUE_SET_FILTER, &filter) == -1) {
+               perror("watch_queue(filter)");
+               exit(1);
+       }
+
+       if (keyctl_watch_key(KEY_SPEC_SESSION_KEYRING, fd, 0x01) == -1) {
+               perror("keyctl");
+               exit(1);
+       }
+
+       if (keyctl_watch_key(KEY_SPEC_USER_KEYRING, fd, 0x02) == -1) {
+               perror("keyctl");
+               exit(1);
+       }
+
+       consumer(fd);
+       exit(0);
+}