kernel/trace/trace_events_user.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2021, Microsoft Corporation.
   4  *
   5  * Authors:
   6  *   Beau Belgrave <beaub@linux.microsoft.com>
   7  */
   8
   9 #include <linux/bitmap.h>
  10 #include <linux/cdev.h>
  11 #include <linux/hashtable.h>
  12 #include <linux/list.h>
  13 #include <linux/io.h>
  14 #include <linux/uio.h>
  15 #include <linux/ioctl.h>
  16 #include <linux/jhash.h>
  17 #include <linux/refcount.h>
  18 #include <linux/trace_events.h>
  19 #include <linux/tracefs.h>
  20 #include <linux/types.h>
  21 #include <linux/uaccess.h>
  22 #include <linux/highmem.h>
  23 #include <linux/init.h>
  24 #include <linux/user_events.h>
  25 #include "trace_dynevent.h"
  26 #include "trace_output.h"
  27 #include "trace.h"
  28
  29 #define USER_EVENTS_PREFIX_LEN (sizeof(USER_EVENTS_PREFIX)-1)
  30
  31 #define FIELD_DEPTH_TYPE 0
  32 #define FIELD_DEPTH_NAME 1
  33 #define FIELD_DEPTH_SIZE 2
  34
  35 /* Limit how long of an event name plus args within the subsystem. */
  36 #define MAX_EVENT_DESC 512
  37 #define EVENT_NAME(user_event) ((user_event)->tracepoint.name)
  38 #define MAX_FIELD_ARRAY_SIZE 1024
  39
  40 /*
  41  * Internal bits (kernel side only) to keep track of connected probes:
  42  * These are used when status is requested in text form about an event. These
  43  * bits are compared against an internal byte on the event to determine which
  44  * probes to print out to the user.
  45  *
  46  * These do not reflect the mapped bytes between the user and kernel space.
  47  */
  48 #define EVENT_STATUS_FTRACE BIT(0)
  49 #define EVENT_STATUS_PERF BIT(1)
  50 #define EVENT_STATUS_OTHER BIT(7)
  51
  52 /*
  53  * Stores the system name, tables, and locks for a group of events. This
  54  * allows isolation for events by various means.
  55  */
  56 struct user_event_group {
  57         char            *system_name;
  58         struct          hlist_node node;
  59         struct          mutex reg_mutex;
  60         DECLARE_HASHTABLE(register_table, 8);
  61 };
  62
  63 /* Group for init_user_ns mapping, top-most group */
  64 static struct user_event_group *init_group;
  65
  66 /* Max allowed events for the whole system */
  67 static unsigned int max_user_events = 32768;
  68
  69 /* Current number of events on the whole system */
  70 static unsigned int current_user_events;
  71
  72 /*
  73  * Stores per-event properties, as users register events
  74  * within a file a user_event might be created if it does not
  75  * already exist. These are globally used and their lifetime
  76  * is tied to the refcnt member. These cannot go away until the
  77  * refcnt reaches one.
  78  */
  79 struct user_event {
  80         struct user_event_group         *group;
  81         struct tracepoint               tracepoint;
  82         struct trace_event_call         call;
  83         struct trace_event_class        class;
  84         struct dyn_event                devent;
  85         struct hlist_node               node;
  86         struct list_head                fields;
  87         struct list_head                validators;
  88         refcount_t                      refcnt;
  89         int                             min_size;
  90         char                            status;
  91 };
  92
  93 /*
  94  * Stores per-mm/event properties that enable an address to be
  95  * updated properly for each task. As tasks are forked, we use
  96  * these to track enablement sites that are tied to an event.
  97  */
  98 struct user_event_enabler {
  99         struct list_head        link;
 100         struct user_event       *event;
 101         unsigned long           addr;
 102
 103         /* Track enable bit, flags, etc. Aligned for bitops. */
 104         unsigned long           values;
 105 };
 106
 107 /* Bits 0-5 are for the bit to update upon enable/disable (0-63 allowed) */
 108 #define ENABLE_VAL_BIT_MASK 0x3F
 109
 110 /* Bit 6 is for faulting status of enablement */
 111 #define ENABLE_VAL_FAULTING_BIT 6
 112
 113 /* Bit 7 is for freeing status of enablement */
 114 #define ENABLE_VAL_FREEING_BIT 7
 115
 116 /* Only duplicate the bit value */
 117 #define ENABLE_VAL_DUP_MASK ENABLE_VAL_BIT_MASK
 118
 119 #define ENABLE_BITOPS(e) (&(e)->values)
 120
 121 #define ENABLE_BIT(e) ((int)((e)->values & ENABLE_VAL_BIT_MASK))
 122
 123 /* Used for asynchronous faulting in of pages */
 124 struct user_event_enabler_fault {
 125         struct work_struct              work;
 126         struct user_event_mm            *mm;
 127         struct user_event_enabler       *enabler;
 128         int                             attempt;
 129 };
 130
 131 static struct kmem_cache *fault_cache;
 132
 133 /* Global list of memory descriptors using user_events */
 134 static LIST_HEAD(user_event_mms);
 135 static DEFINE_SPINLOCK(user_event_mms_lock);
 136
 137 /*
 138  * Stores per-file events references, as users register events
 139  * within a file this structure is modified and freed via RCU.
 140  * The lifetime of this struct is tied to the lifetime of the file.
 141  * These are not shared and only accessible by the file that created it.
 142  */
 143 struct user_event_refs {
 144         struct rcu_head         rcu;
 145         int                     count;
 146         struct user_event       *events[];
 147 };
 148
 149 struct user_event_file_info {
 150         struct user_event_group *group;
 151         struct user_event_refs  *refs;
 152 };
 153
 154 #define VALIDATOR_ENSURE_NULL (1 << 0)
 155 #define VALIDATOR_REL (1 << 1)
 156
 157 struct user_event_validator {
 158         struct list_head        link;
 159         int                     offset;
 160         int                     flags;
 161 };
 162
 163 typedef void (*user_event_func_t) (struct user_event *user, struct iov_iter *i,
 164                                    void *tpdata, bool *faulted);
 165
 166 static int user_event_parse(struct user_event_group *group, char *name,
 167                             char *args, char *flags,
 168                             struct user_event **newuser);
 169
 170 static struct user_event_mm *user_event_mm_get(struct user_event_mm *mm);
 171 static struct user_event_mm *user_event_mm_get_all(struct user_event *user);
 172 static void user_event_mm_put(struct user_event_mm *mm);
 173
 174 static u32 user_event_key(char *name)
 175 {
 176         return jhash(name, strlen(name), 0);
 177 }
 178
 179 static void user_event_group_destroy(struct user_event_group *group)
 180 {
 181         kfree(group->system_name);
 182         kfree(group);
 183 }
 184
 185 static char *user_event_group_system_name(struct user_namespace *user_ns)
 186 {
 187         char *system_name;
 188         int len = sizeof(USER_EVENTS_SYSTEM) + 1;
 189
 190         if (user_ns != &init_user_ns) {
 191                 /*
 192                  * Unexpected at this point:
 193                  * We only currently support init_user_ns.
 194                  * When we enable more, this will trigger a failure so log.
 195                  */
 196                 pr_warn("user_events: Namespace other than init_user_ns!\n");
 197                 return NULL;
 198         }
 199
 200         system_name = kmalloc(len, GFP_KERNEL);
 201
 202         if (!system_name)
 203                 return NULL;
 204
 205         snprintf(system_name, len, "%s", USER_EVENTS_SYSTEM);
 206
 207         return system_name;
 208 }
 209
 210 static inline struct user_event_group
 211 *user_event_group_from_user_ns(struct user_namespace *user_ns)
 212 {
 213         if (user_ns == &init_user_ns)
 214                 return init_group;
 215
 216         return NULL;
 217 }
 218
 219 static struct user_event_group *current_user_event_group(void)
 220 {
 221         struct user_namespace *user_ns = current_user_ns();
 222         struct user_event_group *group = NULL;
 223
 224         while (user_ns) {
 225                 group = user_event_group_from_user_ns(user_ns);
 226
 227                 if (group)
 228                         break;
 229
 230                 user_ns = user_ns->parent;
 231         }
 232
 233         return group;
 234 }
 235
 236 static struct user_event_group
 237 *user_event_group_create(struct user_namespace *user_ns)
 238 {
 239         struct user_event_group *group;
 240
 241         group = kzalloc(sizeof(*group), GFP_KERNEL);
 242
 243         if (!group)
 244                 return NULL;
 245
 246         group->system_name = user_event_group_system_name(user_ns);
 247
 248         if (!group->system_name)
 249                 goto error;
 250
 251         mutex_init(&group->reg_mutex);
 252         hash_init(group->register_table);
 253
 254         return group;
 255 error:
 256         if (group)
 257                 user_event_group_destroy(group);
 258
 259         return NULL;
 260 };
 261
 262 static void user_event_enabler_destroy(struct user_event_enabler *enabler)
 263 {
 264         list_del_rcu(&enabler->link);
 265
 266         /* No longer tracking the event via the enabler */
 267         refcount_dec(&enabler->event->refcnt);
 268
 269         kfree(enabler);
 270 }
 271
 272 static int user_event_mm_fault_in(struct user_event_mm *mm, unsigned long uaddr,
 273                                   int attempt)
 274 {
 275         bool unlocked;
 276         int ret;
 277
 278         /*
 279          * Normally this is low, ensure that it cannot be taken advantage of by
 280          * bad user processes to cause excessive looping.
 281          */
 282         if (attempt > 10)
 283                 return -EFAULT;
 284
 285         mmap_read_lock(mm->mm);
 286
 287         /* Ensure MM has tasks, cannot use after exit_mm() */
 288         if (refcount_read(&mm->tasks) == 0) {
 289                 ret = -ENOENT;
 290                 goto out;
 291         }
 292
 293         ret = fixup_user_fault(mm->mm, uaddr, FAULT_FLAG_WRITE | FAULT_FLAG_REMOTE,
 294                                &unlocked);
 295 out:
 296         mmap_read_unlock(mm->mm);
 297
 298         return ret;
 299 }
 300
 301 static int user_event_enabler_write(struct user_event_mm *mm,
 302                                     struct user_event_enabler *enabler,
 303                                     bool fixup_fault, int *attempt);
 304
 305 static void user_event_enabler_fault_fixup(struct work_struct *work)
 306 {
 307         struct user_event_enabler_fault *fault = container_of(
 308                 work, struct user_event_enabler_fault, work);
 309         struct user_event_enabler *enabler = fault->enabler;
 310         struct user_event_mm *mm = fault->mm;
 311         unsigned long uaddr = enabler->addr;
 312         int attempt = fault->attempt;
 313         int ret;
 314
 315         ret = user_event_mm_fault_in(mm, uaddr, attempt);
 316
 317         if (ret && ret != -ENOENT) {
 318                 struct user_event *user = enabler->event;
 319
 320                 pr_warn("user_events: Fault for mm: 0x%pK @ 0x%llx event: %s\n",
 321                         mm->mm, (unsigned long long)uaddr, EVENT_NAME(user));
 322         }
 323
 324         /* Prevent state changes from racing */
 325         mutex_lock(&event_mutex);
 326
 327         /* User asked for enabler to be removed during fault */
 328         if (test_bit(ENABLE_VAL_FREEING_BIT, ENABLE_BITOPS(enabler))) {
 329                 user_event_enabler_destroy(enabler);
 330                 goto out;
 331         }
 332
 333         /*
 334          * If we managed to get the page, re-issue the write. We do not
 335          * want to get into a possible infinite loop, which is why we only
 336          * attempt again directly if the page came in. If we couldn't get
 337          * the page here, then we will try again the next time the event is
 338          * enabled/disabled.
 339          */
 340         clear_bit(ENABLE_VAL_FAULTING_BIT, ENABLE_BITOPS(enabler));
 341
 342         if (!ret) {
 343                 mmap_read_lock(mm->mm);
 344                 user_event_enabler_write(mm, enabler, true, &attempt);
 345                 mmap_read_unlock(mm->mm);
 346         }
 347 out:
 348         mutex_unlock(&event_mutex);
 349
 350         /* In all cases we no longer need the mm or fault */
 351         user_event_mm_put(mm);
 352         kmem_cache_free(fault_cache, fault);
 353 }
 354
 355 static bool user_event_enabler_queue_fault(struct user_event_mm *mm,
 356                                            struct user_event_enabler *enabler,
 357                                            int attempt)
 358 {
 359         struct user_event_enabler_fault *fault;
 360
 361         fault = kmem_cache_zalloc(fault_cache, GFP_NOWAIT | __GFP_NOWARN);
 362
 363         if (!fault)
 364                 return false;
 365
 366         INIT_WORK(&fault->work, user_event_enabler_fault_fixup);
 367         fault->mm = user_event_mm_get(mm);
 368         fault->enabler = enabler;
 369         fault->attempt = attempt;
 370
 371         /* Don't try to queue in again while we have a pending fault */
 372         set_bit(ENABLE_VAL_FAULTING_BIT, ENABLE_BITOPS(enabler));
 373
 374         if (!schedule_work(&fault->work)) {
 375                 /* Allow another attempt later */
 376                 clear_bit(ENABLE_VAL_FAULTING_BIT, ENABLE_BITOPS(enabler));
 377
 378                 user_event_mm_put(mm);
 379                 kmem_cache_free(fault_cache, fault);
 380
 381                 return false;
 382         }
 383
 384         return true;
 385 }
 386
 387 static int user_event_enabler_write(struct user_event_mm *mm,
 388                                     struct user_event_enabler *enabler,
 389                                     bool fixup_fault, int *attempt)
 390 {
 391         unsigned long uaddr = enabler->addr;
 392         unsigned long *ptr;
 393         struct page *page;
 394         void *kaddr;
 395         int ret;
 396
 397         lockdep_assert_held(&event_mutex);
 398         mmap_assert_locked(mm->mm);
 399
 400         *attempt += 1;
 401
 402         /* Ensure MM has tasks, cannot use after exit_mm() */
 403         if (refcount_read(&mm->tasks) == 0)
 404                 return -ENOENT;
 405
 406         if (unlikely(test_bit(ENABLE_VAL_FAULTING_BIT, ENABLE_BITOPS(enabler)) ||
 407                      test_bit(ENABLE_VAL_FREEING_BIT, ENABLE_BITOPS(enabler))))
 408                 return -EBUSY;
 409
 410         ret = pin_user_pages_remote(mm->mm, uaddr, 1, FOLL_WRITE | FOLL_NOFAULT,
 411                                     &page, NULL, NULL);
 412
 413         if (unlikely(ret <= 0)) {
 414                 if (!fixup_fault)
 415                         return -EFAULT;
 416
 417                 if (!user_event_enabler_queue_fault(mm, enabler, *attempt))
 418                         pr_warn("user_events: Unable to queue fault handler\n");
 419
 420                 return -EFAULT;
 421         }
 422
 423         kaddr = kmap_local_page(page);
 424         ptr = kaddr + (uaddr & ~PAGE_MASK);
 425
 426         /* Update bit atomically, user tracers must be atomic as well */
 427         if (enabler->event && enabler->event->status)
 428                 set_bit(ENABLE_BIT(enabler), ptr);
 429         else
 430                 clear_bit(ENABLE_BIT(enabler), ptr);
 431
 432         kunmap_local(kaddr);
 433         unpin_user_pages_dirty_lock(&page, 1, true);
 434
 435         return 0;
 436 }
 437
 438 static bool user_event_enabler_exists(struct user_event_mm *mm,
 439                                       unsigned long uaddr, unsigned char bit)
 440 {
 441         struct user_event_enabler *enabler;
 442         struct user_event_enabler *next;
 443
 444         list_for_each_entry_safe(enabler, next, &mm->enablers, link) {
 445                 if (enabler->addr == uaddr && ENABLE_BIT(enabler) == bit)
 446                         return true;
 447         }
 448
 449         return false;
 450 }
 451
 452 static void user_event_enabler_update(struct user_event *user)
 453 {
 454         struct user_event_enabler *enabler;
 455         struct user_event_mm *mm = user_event_mm_get_all(user);
 456         struct user_event_mm *next;
 457         int attempt;
 458
 459         while (mm) {
 460                 next = mm->next;
 461                 mmap_read_lock(mm->mm);
 462                 rcu_read_lock();
 463
 464                 list_for_each_entry_rcu(enabler, &mm->enablers, link) {
 465                         if (enabler->event == user) {
 466                                 attempt = 0;
 467                                 user_event_enabler_write(mm, enabler, true, &attempt);
 468                         }
 469                 }
 470
 471                 rcu_read_unlock();
 472                 mmap_read_unlock(mm->mm);
 473                 user_event_mm_put(mm);
 474                 mm = next;
 475         }
 476 }
 477
 478 static bool user_event_enabler_dup(struct user_event_enabler *orig,
 479                                    struct user_event_mm *mm)
 480 {
 481         struct user_event_enabler *enabler;
 482
 483         /* Skip pending frees */
 484         if (unlikely(test_bit(ENABLE_VAL_FREEING_BIT, ENABLE_BITOPS(orig))))
 485                 return true;
 486
 487         enabler = kzalloc(sizeof(*enabler), GFP_NOWAIT | __GFP_ACCOUNT);
 488
 489         if (!enabler)
 490                 return false;
 491
 492         enabler->event = orig->event;
 493         enabler->addr = orig->addr;
 494
 495         /* Only dup part of value (ignore future flags, etc) */
 496         enabler->values = orig->values & ENABLE_VAL_DUP_MASK;
 497
 498         refcount_inc(&enabler->event->refcnt);
 499         list_add_rcu(&enabler->link, &mm->enablers);
 500
 501         return true;
 502 }
 503
 504 static struct user_event_mm *user_event_mm_get(struct user_event_mm *mm)
 505 {
 506         refcount_inc(&mm->refcnt);
 507
 508         return mm;
 509 }
 510
 511 static struct user_event_mm *user_event_mm_get_all(struct user_event *user)
 512 {
 513         struct user_event_mm *found = NULL;
 514         struct user_event_enabler *enabler;
 515         struct user_event_mm *mm;
 516
 517         /*
 518          * We do not want to block fork/exec while enablements are being
 519          * updated, so we use RCU to walk the current tasks that have used
 520          * user_events ABI for 1 or more events. Each enabler found in each
 521          * task that matches the event being updated has a write to reflect
 522          * the kernel state back into the process. Waits/faults must not occur
 523          * during this. So we scan the list under RCU for all the mm that have
 524          * the event within it. This is needed because mm_read_lock() can wait.
 525          * Each user mm returned has a ref inc to handle remove RCU races.
 526          */
 527         rcu_read_lock();
 528
 529         list_for_each_entry_rcu(mm, &user_event_mms, link)
 530                 list_for_each_entry_rcu(enabler, &mm->enablers, link)
 531                         if (enabler->event == user) {
 532                                 mm->next = found;
 533                                 found = user_event_mm_get(mm);
 534                                 break;
 535                         }
 536
 537         rcu_read_unlock();
 538
 539         return found;
 540 }
 541
 542 static struct user_event_mm *user_event_mm_create(struct task_struct *t)
 543 {
 544         struct user_event_mm *user_mm;
 545         unsigned long flags;
 546
 547         user_mm = kzalloc(sizeof(*user_mm), GFP_KERNEL_ACCOUNT);
 548
 549         if (!user_mm)
 550                 return NULL;
 551
 552         user_mm->mm = t->mm;
 553         INIT_LIST_HEAD(&user_mm->enablers);
 554         refcount_set(&user_mm->refcnt, 1);
 555         refcount_set(&user_mm->tasks, 1);
 556
 557         spin_lock_irqsave(&user_event_mms_lock, flags);
 558         list_add_rcu(&user_mm->link, &user_event_mms);
 559         spin_unlock_irqrestore(&user_event_mms_lock, flags);
 560
 561         t->user_event_mm = user_mm;
 562
 563         /*
 564          * The lifetime of the memory descriptor can slightly outlast
 565          * the task lifetime if a ref to the user_event_mm is taken
 566          * between list_del_rcu() and call_rcu(). Therefore we need
 567          * to take a reference to it to ensure it can live this long
 568          * under this corner case. This can also occur in clones that
 569          * outlast the parent.
 570          */
 571         mmgrab(user_mm->mm);
 572
 573         return user_mm;
 574 }
 575
 576 static struct user_event_mm *current_user_event_mm(void)
 577 {
 578         struct user_event_mm *user_mm = current->user_event_mm;
 579
 580         if (user_mm)
 581                 goto inc;
 582
 583         user_mm = user_event_mm_create(current);
 584
 585         if (!user_mm)
 586                 goto error;
 587 inc:
 588         refcount_inc(&user_mm->refcnt);
 589 error:
 590         return user_mm;
 591 }
 592
 593 static void user_event_mm_destroy(struct user_event_mm *mm)
 594 {
 595         struct user_event_enabler *enabler, *next;
 596
 597         list_for_each_entry_safe(enabler, next, &mm->enablers, link)
 598                 user_event_enabler_destroy(enabler);
 599
 600         mmdrop(mm->mm);
 601         kfree(mm);
 602 }
 603
 604 static void user_event_mm_put(struct user_event_mm *mm)
 605 {
 606         if (mm && refcount_dec_and_test(&mm->refcnt))
 607                 user_event_mm_destroy(mm);
 608 }
 609
 610 static void delayed_user_event_mm_put(struct work_struct *work)
 611 {
 612         struct user_event_mm *mm;
 613
 614         mm = container_of(to_rcu_work(work), struct user_event_mm, put_rwork);
 615         user_event_mm_put(mm);
 616 }
 617
 618 void user_event_mm_remove(struct task_struct *t)
 619 {
 620         struct user_event_mm *mm;
 621         unsigned long flags;
 622
 623         might_sleep();
 624
 625         mm = t->user_event_mm;
 626         t->user_event_mm = NULL;
 627
 628         /* Clone will increment the tasks, only remove if last clone */
 629         if (!refcount_dec_and_test(&mm->tasks))
 630                 return;
 631
 632         /* Remove the mm from the list, so it can no longer be enabled */
 633         spin_lock_irqsave(&user_event_mms_lock, flags);
 634         list_del_rcu(&mm->link);
 635         spin_unlock_irqrestore(&user_event_mms_lock, flags);
 636
 637         /*
 638          * We need to wait for currently occurring writes to stop within
 639          * the mm. This is required since exit_mm() snaps the current rss
 640          * stats and clears them. On the final mmdrop(), check_mm() will
 641          * report a bug if these increment.
 642          *
 643          * All writes/pins are done under mmap_read lock, take the write
 644          * lock to ensure in-progress faults have completed. Faults that
 645          * are pending but yet to run will check the task count and skip
 646          * the fault since the mm is going away.
 647          */
 648         mmap_write_lock(mm->mm);
 649         mmap_write_unlock(mm->mm);
 650
 651         /*
 652          * Put for mm must be done after RCU delay to handle new refs in
 653          * between the list_del_rcu() and now. This ensures any get refs
 654          * during rcu_read_lock() are accounted for during list removal.
 655          *
 656          * CPU A                        |       CPU B
 657          * ---------------------------------------------------------------
 658          * user_event_mm_remove()       |       rcu_read_lock();
 659          * list_del_rcu()               |       list_for_each_entry_rcu();
 660          * call_rcu()                   |       refcount_inc();
 661          * .                            |       rcu_read_unlock();
 662          * schedule_work()              |       .
 663          * user_event_mm_put()          |       .
 664          *
 665          * mmdrop() cannot be called in the softirq context of call_rcu()
 666          * so we use a work queue after call_rcu() to run within.
 667          */
 668         INIT_RCU_WORK(&mm->put_rwork, delayed_user_event_mm_put);
 669         queue_rcu_work(system_wq, &mm->put_rwork);
 670 }
 671
 672 void user_event_mm_dup(struct task_struct *t, struct user_event_mm *old_mm)
 673 {
 674         struct user_event_mm *mm = user_event_mm_create(t);
 675         struct user_event_enabler *enabler;
 676
 677         if (!mm)
 678                 return;
 679
 680         rcu_read_lock();
 681
 682         list_for_each_entry_rcu(enabler, &old_mm->enablers, link)
 683                 if (!user_event_enabler_dup(enabler, mm))
 684                         goto error;
 685
 686         rcu_read_unlock();
 687
 688         return;
 689 error:
 690         rcu_read_unlock();
 691         user_event_mm_remove(t);
 692 }
 693
 694 static bool current_user_event_enabler_exists(unsigned long uaddr,
 695                                               unsigned char bit)
 696 {
 697         struct user_event_mm *user_mm = current_user_event_mm();
 698         bool exists;
 699
 700         if (!user_mm)
 701                 return false;
 702
 703         exists = user_event_enabler_exists(user_mm, uaddr, bit);
 704
 705         user_event_mm_put(user_mm);
 706
 707         return exists;
 708 }
 709
 710 static struct user_event_enabler
 711 *user_event_enabler_create(struct user_reg *reg, struct user_event *user,
 712                            int *write_result)
 713 {
 714         struct user_event_enabler *enabler;
 715         struct user_event_mm *user_mm;
 716         unsigned long uaddr = (unsigned long)reg->enable_addr;
 717         int attempt = 0;
 718
 719         user_mm = current_user_event_mm();
 720
 721         if (!user_mm)
 722                 return NULL;
 723
 724         enabler = kzalloc(sizeof(*enabler), GFP_KERNEL_ACCOUNT);
 725
 726         if (!enabler)
 727                 goto out;
 728
 729         enabler->event = user;
 730         enabler->addr = uaddr;
 731         enabler->values = reg->enable_bit;
 732 retry:
 733         /* Prevents state changes from racing with new enablers */
 734         mutex_lock(&event_mutex);
 735
 736         /* Attempt to reflect the current state within the process */
 737         mmap_read_lock(user_mm->mm);
 738         *write_result = user_event_enabler_write(user_mm, enabler, false,
 739                                                  &attempt);
 740         mmap_read_unlock(user_mm->mm);
 741
 742         /*
 743          * If the write works, then we will track the enabler. A ref to the
 744          * underlying user_event is held by the enabler to prevent it going
 745          * away while the enabler is still in use by a process. The ref is
 746          * removed when the enabler is destroyed. This means a event cannot
 747          * be forcefully deleted from the system until all tasks using it
 748          * exit or run exec(), which includes forks and clones.
 749          */
 750         if (!*write_result) {
 751                 refcount_inc(&enabler->event->refcnt);
 752                 list_add_rcu(&enabler->link, &user_mm->enablers);
 753         }
 754
 755         mutex_unlock(&event_mutex);
 756
 757         if (*write_result) {
 758                 /* Attempt to fault-in and retry if it worked */
 759                 if (!user_event_mm_fault_in(user_mm, uaddr, attempt))
 760                         goto retry;
 761
 762                 kfree(enabler);
 763                 enabler = NULL;
 764         }
 765 out:
 766         user_event_mm_put(user_mm);
 767
 768         return enabler;
 769 }
 770
 771 static __always_inline __must_check
 772 bool user_event_last_ref(struct user_event *user)
 773 {
 774         return refcount_read(&user->refcnt) == 1;
 775 }
 776
 777 static __always_inline __must_check
 778 size_t copy_nofault(void *addr, size_t bytes, struct iov_iter *i)
 779 {
 780         size_t ret;
 781
 782         pagefault_disable();
 783
 784         ret = copy_from_iter_nocache(addr, bytes, i);
 785
 786         pagefault_enable();
 787
 788         return ret;
 789 }
 790
 791 static struct list_head *user_event_get_fields(struct trace_event_call *call)
 792 {
 793         struct user_event *user = (struct user_event *)call->data;
 794
 795         return &user->fields;
 796 }
 797
 798 /*
 799  * Parses a register command for user_events
 800  * Format: event_name[:FLAG1[,FLAG2...]] [field1[;field2...]]
 801  *
 802  * Example event named 'test' with a 20 char 'msg' field with an unsigned int
 803  * 'id' field after:
 804  * test char[20] msg;unsigned int id
 805  *
 806  * NOTE: Offsets are from the user data perspective, they are not from the
 807  * trace_entry/buffer perspective. We automatically add the common properties
 808  * sizes to the offset for the user.
 809  *
 810  * Upon success user_event has its ref count increased by 1.
 811  */
 812 static int user_event_parse_cmd(struct user_event_group *group,
 813                                 char *raw_command, struct user_event **newuser)
 814 {
 815         char *name = raw_command;
 816         char *args = strpbrk(name, " ");
 817         char *flags;
 818
 819         if (args)
 820                 *args++ = '\0';
 821
 822         flags = strpbrk(name, ":");
 823
 824         if (flags)
 825                 *flags++ = '\0';
 826
 827         return user_event_parse(group, name, args, flags, newuser);
 828 }
 829
 830 static int user_field_array_size(const char *type)
 831 {
 832         const char *start = strchr(type, '[');
 833         char val[8];
 834         char *bracket;
 835         int size = 0;
 836
 837         if (start == NULL)
 838                 return -EINVAL;
 839
 840         if (strscpy(val, start + 1, sizeof(val)) <= 0)
 841                 return -EINVAL;
 842
 843         bracket = strchr(val, ']');
 844
 845         if (!bracket)
 846                 return -EINVAL;
 847
 848         *bracket = '\0';
 849
 850         if (kstrtouint(val, 0, &size))
 851                 return -EINVAL;
 852
 853         if (size > MAX_FIELD_ARRAY_SIZE)
 854                 return -EINVAL;
 855
 856         return size;
 857 }
 858
 859 static int user_field_size(const char *type)
 860 {
 861         /* long is not allowed from a user, since it's ambigious in size */
 862         if (strcmp(type, "s64") == 0)
 863                 return sizeof(s64);
 864         if (strcmp(type, "u64") == 0)
 865                 return sizeof(u64);
 866         if (strcmp(type, "s32") == 0)
 867                 return sizeof(s32);
 868         if (strcmp(type, "u32") == 0)
 869                 return sizeof(u32);
 870         if (strcmp(type, "int") == 0)
 871                 return sizeof(int);
 872         if (strcmp(type, "unsigned int") == 0)
 873                 return sizeof(unsigned int);
 874         if (strcmp(type, "s16") == 0)
 875                 return sizeof(s16);
 876         if (strcmp(type, "u16") == 0)
 877                 return sizeof(u16);
 878         if (strcmp(type, "short") == 0)
 879                 return sizeof(short);
 880         if (strcmp(type, "unsigned short") == 0)
 881                 return sizeof(unsigned short);
 882         if (strcmp(type, "s8") == 0)
 883                 return sizeof(s8);
 884         if (strcmp(type, "u8") == 0)
 885                 return sizeof(u8);
 886         if (strcmp(type, "char") == 0)
 887                 return sizeof(char);
 888         if (strcmp(type, "unsigned char") == 0)
 889                 return sizeof(unsigned char);
 890         if (str_has_prefix(type, "char["))
 891                 return user_field_array_size(type);
 892         if (str_has_prefix(type, "unsigned char["))
 893                 return user_field_array_size(type);
 894         if (str_has_prefix(type, "__data_loc "))
 895                 return sizeof(u32);
 896         if (str_has_prefix(type, "__rel_loc "))
 897                 return sizeof(u32);
 898
 899         /* Uknown basic type, error */
 900         return -EINVAL;
 901 }
 902
 903 static void user_event_destroy_validators(struct user_event *user)
 904 {
 905         struct user_event_validator *validator, *next;
 906         struct list_head *head = &user->validators;
 907
 908         list_for_each_entry_safe(validator, next, head, link) {
 909                 list_del(&validator->link);
 910                 kfree(validator);
 911         }
 912 }
 913
 914 static void user_event_destroy_fields(struct user_event *user)
 915 {
 916         struct ftrace_event_field *field, *next;
 917         struct list_head *head = &user->fields;
 918
 919         list_for_each_entry_safe(field, next, head, link) {
 920                 list_del(&field->link);
 921                 kfree(field);
 922         }
 923 }
 924
 925 static int user_event_add_field(struct user_event *user, const char *type,
 926                                 const char *name, int offset, int size,
 927                                 int is_signed, int filter_type)
 928 {
 929         struct user_event_validator *validator;
 930         struct ftrace_event_field *field;
 931         int validator_flags = 0;
 932
 933         field = kmalloc(sizeof(*field), GFP_KERNEL_ACCOUNT);
 934
 935         if (!field)
 936                 return -ENOMEM;
 937
 938         if (str_has_prefix(type, "__data_loc "))
 939                 goto add_validator;
 940
 941         if (str_has_prefix(type, "__rel_loc ")) {
 942                 validator_flags |= VALIDATOR_REL;
 943                 goto add_validator;
 944         }
 945
 946         goto add_field;
 947
 948 add_validator:
 949         if (strstr(type, "char") != NULL)
 950                 validator_flags |= VALIDATOR_ENSURE_NULL;
 951
 952         validator = kmalloc(sizeof(*validator), GFP_KERNEL_ACCOUNT);
 953
 954         if (!validator) {
 955                 kfree(field);
 956                 return -ENOMEM;
 957         }
 958
 959         validator->flags = validator_flags;
 960         validator->offset = offset;
 961
 962         /* Want sequential access when validating */
 963         list_add_tail(&validator->link, &user->validators);
 964
 965 add_field:
 966         field->type = type;
 967         field->name = name;
 968         field->offset = offset;
 969         field->size = size;
 970         field->is_signed = is_signed;
 971         field->filter_type = filter_type;
 972
 973         if (filter_type == FILTER_OTHER)
 974                 field->filter_type = filter_assign_type(type);
 975
 976         list_add(&field->link, &user->fields);
 977
 978         /*
 979          * Min size from user writes that are required, this does not include
 980          * the size of trace_entry (common fields).
 981          */
 982         user->min_size = (offset + size) - sizeof(struct trace_entry);
 983
 984         return 0;
 985 }
 986
 987 /*
 988  * Parses the values of a field within the description
 989  * Format: type name [size]
 990  */
 991 static int user_event_parse_field(char *field, struct user_event *user,
 992                                   u32 *offset)
 993 {
 994         char *part, *type, *name;
 995         u32 depth = 0, saved_offset = *offset;
 996         int len, size = -EINVAL;
 997         bool is_struct = false;
 998
 999         field = skip_spaces(field);
1000
1001         if (*field == '\0')
1002                 return 0;
1003
1004         /* Handle types that have a space within */
1005         len = str_has_prefix(field, "unsigned ");
1006         if (len)
1007                 goto skip_next;
1008
1009         len = str_has_prefix(field, "struct ");
1010         if (len) {
1011                 is_struct = true;
1012                 goto skip_next;
1013         }
1014
1015         len = str_has_prefix(field, "__data_loc unsigned ");
1016         if (len)
1017                 goto skip_next;
1018
1019         len = str_has_prefix(field, "__data_loc ");
1020         if (len)
1021                 goto skip_next;
1022
1023         len = str_has_prefix(field, "__rel_loc unsigned ");
1024         if (len)
1025                 goto skip_next;
1026
1027         len = str_has_prefix(field, "__rel_loc ");
1028         if (len)
1029                 goto skip_next;
1030
1031         goto parse;
1032 skip_next:
1033         type = field;
1034         field = strpbrk(field + len, " ");
1035
1036         if (field == NULL)
1037                 return -EINVAL;
1038
1039         *field++ = '\0';
1040         depth++;
1041 parse:
1042         name = NULL;
1043
1044         while ((part = strsep(&field, " ")) != NULL) {
1045                 switch (depth++) {
1046                 case FIELD_DEPTH_TYPE:
1047                         type = part;
1048                         break;
1049                 case FIELD_DEPTH_NAME:
1050                         name = part;
1051                         break;
1052                 case FIELD_DEPTH_SIZE:
1053                         if (!is_struct)
1054                                 return -EINVAL;
1055
1056                         if (kstrtou32(part, 10, &size))
1057                                 return -EINVAL;
1058                         break;
1059                 default:
1060                         return -EINVAL;
1061                 }
1062         }
1063
1064         if (depth < FIELD_DEPTH_SIZE || !name)
1065                 return -EINVAL;
1066
1067         if (depth == FIELD_DEPTH_SIZE)
1068                 size = user_field_size(type);
1069
1070         if (size == 0)
1071                 return -EINVAL;
1072
1073         if (size < 0)
1074                 return size;
1075
1076         *offset = saved_offset + size;
1077
1078         return user_event_add_field(user, type, name, saved_offset, size,
1079                                     type[0] != 'u', FILTER_OTHER);
1080 }
1081
1082 static int user_event_parse_fields(struct user_event *user, char *args)
1083 {
1084         char *field;
1085         u32 offset = sizeof(struct trace_entry);
1086         int ret = -EINVAL;
1087
1088         if (args == NULL)
1089                 return 0;
1090
1091         while ((field = strsep(&args, ";")) != NULL) {
1092                 ret = user_event_parse_field(field, user, &offset);
1093
1094                 if (ret)
1095                         break;
1096         }
1097
1098         return ret;
1099 }
1100
1101 static struct trace_event_fields user_event_fields_array[1];
1102
1103 static const char *user_field_format(const char *type)
1104 {
1105         if (strcmp(type, "s64") == 0)
1106                 return "%lld";
1107         if (strcmp(type, "u64") == 0)
1108                 return "%llu";
1109         if (strcmp(type, "s32") == 0)
1110                 return "%d";
1111         if (strcmp(type, "u32") == 0)
1112                 return "%u";
1113         if (strcmp(type, "int") == 0)
1114                 return "%d";
1115         if (strcmp(type, "unsigned int") == 0)
1116                 return "%u";
1117         if (strcmp(type, "s16") == 0)
1118                 return "%d";
1119         if (strcmp(type, "u16") == 0)
1120                 return "%u";
1121         if (strcmp(type, "short") == 0)
1122                 return "%d";
1123         if (strcmp(type, "unsigned short") == 0)
1124                 return "%u";
1125         if (strcmp(type, "s8") == 0)
1126                 return "%d";
1127         if (strcmp(type, "u8") == 0)
1128                 return "%u";
1129         if (strcmp(type, "char") == 0)
1130                 return "%d";
1131         if (strcmp(type, "unsigned char") == 0)
1132                 return "%u";
1133         if (strstr(type, "char[") != NULL)
1134                 return "%s";
1135
1136         /* Unknown, likely struct, allowed treat as 64-bit */
1137         return "%llu";
1138 }
1139
1140 static bool user_field_is_dyn_string(const char *type, const char **str_func)
1141 {
1142         if (str_has_prefix(type, "__data_loc ")) {
1143                 *str_func = "__get_str";
1144                 goto check;
1145         }
1146
1147         if (str_has_prefix(type, "__rel_loc ")) {
1148                 *str_func = "__get_rel_str";
1149                 goto check;
1150         }
1151
1152         return false;
1153 check:
1154         return strstr(type, "char") != NULL;
1155 }
1156
1157 #define LEN_OR_ZERO (len ? len - pos : 0)
1158 static int user_dyn_field_set_string(int argc, const char **argv, int *iout,
1159                                      char *buf, int len, bool *colon)
1160 {
1161         int pos = 0, i = *iout;
1162
1163         *colon = false;
1164
1165         for (; i < argc; ++i) {
1166                 if (i != *iout)
1167                         pos += snprintf(buf + pos, LEN_OR_ZERO, " ");
1168
1169                 pos += snprintf(buf + pos, LEN_OR_ZERO, "%s", argv[i]);
1170
1171                 if (strchr(argv[i], ';')) {
1172                         ++i;
1173                         *colon = true;
1174                         break;
1175                 }
1176         }
1177
1178         /* Actual set, advance i */
1179         if (len != 0)
1180                 *iout = i;
1181
1182         return pos + 1;
1183 }
1184
1185 static int user_field_set_string(struct ftrace_event_field *field,
1186                                  char *buf, int len, bool colon)
1187 {
1188         int pos = 0;
1189
1190         pos += snprintf(buf + pos, LEN_OR_ZERO, "%s", field->type);
1191         pos += snprintf(buf + pos, LEN_OR_ZERO, " ");
1192         pos += snprintf(buf + pos, LEN_OR_ZERO, "%s", field->name);
1193
1194         if (colon)
1195                 pos += snprintf(buf + pos, LEN_OR_ZERO, ";");
1196
1197         return pos + 1;
1198 }
1199
1200 static int user_event_set_print_fmt(struct user_event *user, char *buf, int len)
1201 {
1202         struct ftrace_event_field *field, *next;
1203         struct list_head *head = &user->fields;
1204         int pos = 0, depth = 0;
1205         const char *str_func;
1206
1207         pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
1208
1209         list_for_each_entry_safe_reverse(field, next, head, link) {
1210                 if (depth != 0)
1211                         pos += snprintf(buf + pos, LEN_OR_ZERO, " ");
1212
1213                 pos += snprintf(buf + pos, LEN_OR_ZERO, "%s=%s",
1214                                 field->name, user_field_format(field->type));
1215
1216                 depth++;
1217         }
1218
1219         pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
1220
1221         list_for_each_entry_safe_reverse(field, next, head, link) {
1222                 if (user_field_is_dyn_string(field->type, &str_func))
1223                         pos += snprintf(buf + pos, LEN_OR_ZERO,
1224                                         ", %s(%s)", str_func, field->name);
1225                 else
1226                         pos += snprintf(buf + pos, LEN_OR_ZERO,
1227                                         ", REC->%s", field->name);
1228         }
1229
1230         return pos + 1;
1231 }
1232 #undef LEN_OR_ZERO
1233
1234 static int user_event_create_print_fmt(struct user_event *user)
1235 {
1236         char *print_fmt;
1237         int len;
1238
1239         len = user_event_set_print_fmt(user, NULL, 0);
1240
1241         print_fmt = kmalloc(len, GFP_KERNEL_ACCOUNT);
1242
1243         if (!print_fmt)
1244                 return -ENOMEM;
1245
1246         user_event_set_print_fmt(user, print_fmt, len);
1247
1248         user->call.print_fmt = print_fmt;
1249
1250         return 0;
1251 }
1252
1253 static enum print_line_t user_event_print_trace(struct trace_iterator *iter,
1254                                                 int flags,
1255                                                 struct trace_event *event)
1256 {
1257         return print_event_fields(iter, event);
1258 }
1259
1260 static struct trace_event_functions user_event_funcs = {
1261         .trace = user_event_print_trace,
1262 };
1263
1264 static int user_event_set_call_visible(struct user_event *user, bool visible)
1265 {
1266         int ret;
1267         const struct cred *old_cred;
1268         struct cred *cred;
1269
1270         cred = prepare_creds();
1271
1272         if (!cred)
1273                 return -ENOMEM;
1274
1275         /*
1276          * While by default tracefs is locked down, systems can be configured
1277          * to allow user_event files to be less locked down. The extreme case
1278          * being "other" has read/write access to user_events_data/status.
1279          *
1280          * When not locked down, processes may not have permissions to
1281          * add/remove calls themselves to tracefs. We need to temporarily
1282          * switch to root file permission to allow for this scenario.
1283          */
1284         cred->fsuid = GLOBAL_ROOT_UID;
1285
1286         old_cred = override_creds(cred);
1287
1288         if (visible)
1289                 ret = trace_add_event_call(&user->call);
1290         else
1291                 ret = trace_remove_event_call(&user->call);
1292
1293         revert_creds(old_cred);
1294         put_cred(cred);
1295
1296         return ret;
1297 }
1298
1299 static int destroy_user_event(struct user_event *user)
1300 {
1301         int ret = 0;
1302
1303         lockdep_assert_held(&event_mutex);
1304
1305         /* Must destroy fields before call removal */
1306         user_event_destroy_fields(user);
1307
1308         ret = user_event_set_call_visible(user, false);
1309
1310         if (ret)
1311                 return ret;
1312
1313         dyn_event_remove(&user->devent);
1314         hash_del(&user->node);
1315
1316         user_event_destroy_validators(user);
1317         kfree(user->call.print_fmt);
1318         kfree(EVENT_NAME(user));
1319         kfree(user);
1320
1321         if (current_user_events > 0)
1322                 current_user_events--;
1323         else
1324                 pr_alert("BUG: Bad current_user_events\n");
1325
1326         return ret;
1327 }
1328
1329 static struct user_event *find_user_event(struct user_event_group *group,
1330                                           char *name, u32 *outkey)
1331 {
1332         struct user_event *user;
1333         u32 key = user_event_key(name);
1334
1335         *outkey = key;
1336
1337         hash_for_each_possible(group->register_table, user, node, key)
1338                 if (!strcmp(EVENT_NAME(user), name)) {
1339                         refcount_inc(&user->refcnt);
1340                         return user;
1341                 }
1342
1343         return NULL;
1344 }
1345
1346 static int user_event_validate(struct user_event *user, void *data, int len)
1347 {
1348         struct list_head *head = &user->validators;
1349         struct user_event_validator *validator;
1350         void *pos, *end = data + len;
1351         u32 loc, offset, size;
1352
1353         list_for_each_entry(validator, head, link) {
1354                 pos = data + validator->offset;
1355
1356                 /* Already done min_size check, no bounds check here */
1357                 loc = *(u32 *)pos;
1358                 offset = loc & 0xffff;
1359                 size = loc >> 16;
1360
1361                 if (likely(validator->flags & VALIDATOR_REL))
1362                         pos += offset + sizeof(loc);
1363                 else
1364                         pos = data + offset;
1365
1366                 pos += size;
1367
1368                 if (unlikely(pos > end))
1369                         return -EFAULT;
1370
1371                 if (likely(validator->flags & VALIDATOR_ENSURE_NULL))
1372                         if (unlikely(*(char *)(pos - 1) != '\0'))
1373                                 return -EFAULT;
1374         }
1375
1376         return 0;
1377 }
1378
1379 /*
1380  * Writes the user supplied payload out to a trace file.
1381  */
1382 static void user_event_ftrace(struct user_event *user, struct iov_iter *i,
1383                               void *tpdata, bool *faulted)
1384 {
1385         struct trace_event_file *file;
1386         struct trace_entry *entry;
1387         struct trace_event_buffer event_buffer;
1388         size_t size = sizeof(*entry) + i->count;
1389
1390         file = (struct trace_event_file *)tpdata;
1391
1392         if (!file ||
1393             !(file->flags & EVENT_FILE_FL_ENABLED) ||
1394             trace_trigger_soft_disabled(file))
1395                 return;
1396
1397         /* Allocates and fills trace_entry, + 1 of this is data payload */
1398         entry = trace_event_buffer_reserve(&event_buffer, file, size);
1399
1400         if (unlikely(!entry))
1401                 return;
1402
1403         if (unlikely(!copy_nofault(entry + 1, i->count, i)))
1404                 goto discard;
1405
1406         if (!list_empty(&user->validators) &&
1407             unlikely(user_event_validate(user, entry, size)))
1408                 goto discard;
1409
1410         trace_event_buffer_commit(&event_buffer);
1411
1412         return;
1413 discard:
1414         *faulted = true;
1415         __trace_event_discard_commit(event_buffer.buffer,
1416                                      event_buffer.event);
1417 }
1418
1419 #ifdef CONFIG_PERF_EVENTS
1420 /*
1421  * Writes the user supplied payload out to perf ring buffer.
1422  */
1423 static void user_event_perf(struct user_event *user, struct iov_iter *i,
1424                             void *tpdata, bool *faulted)
1425 {
1426         struct hlist_head *perf_head;
1427
1428         perf_head = this_cpu_ptr(user->call.perf_events);
1429
1430         if (perf_head && !hlist_empty(perf_head)) {
1431                 struct trace_entry *perf_entry;
1432                 struct pt_regs *regs;
1433                 size_t size = sizeof(*perf_entry) + i->count;
1434                 int context;
1435
1436                 perf_entry = perf_trace_buf_alloc(ALIGN(size, 8),
1437                                                   &regs, &context);
1438
1439                 if (unlikely(!perf_entry))
1440                         return;
1441
1442                 perf_fetch_caller_regs(regs);
1443
1444                 if (unlikely(!copy_nofault(perf_entry + 1, i->count, i)))
1445                         goto discard;
1446
1447                 if (!list_empty(&user->validators) &&
1448                     unlikely(user_event_validate(user, perf_entry, size)))
1449                         goto discard;
1450
1451                 perf_trace_buf_submit(perf_entry, size, context,
1452                                       user->call.event.type, 1, regs,
1453                                       perf_head, NULL);
1454
1455                 return;
1456 discard:
1457                 *faulted = true;
1458                 perf_swevent_put_recursion_context(context);
1459         }
1460 }
1461 #endif
1462
1463 /*
1464  * Update the enabled bit among all user processes.
1465  */
1466 static void update_enable_bit_for(struct user_event *user)
1467 {
1468         struct tracepoint *tp = &user->tracepoint;
1469         char status = 0;
1470
1471         if (atomic_read(&tp->key.enabled) > 0) {
1472                 struct tracepoint_func *probe_func_ptr;
1473                 user_event_func_t probe_func;
1474
1475                 rcu_read_lock_sched();
1476
1477                 probe_func_ptr = rcu_dereference_sched(tp->funcs);
1478
1479                 if (probe_func_ptr) {
1480                         do {
1481                                 probe_func = probe_func_ptr->func;
1482
1483                                 if (probe_func == user_event_ftrace)
1484                                         status |= EVENT_STATUS_FTRACE;
1485 #ifdef CONFIG_PERF_EVENTS
1486                                 else if (probe_func == user_event_perf)
1487                                         status |= EVENT_STATUS_PERF;
1488 #endif
1489                                 else
1490                                         status |= EVENT_STATUS_OTHER;
1491                         } while ((++probe_func_ptr)->func);
1492                 }
1493
1494                 rcu_read_unlock_sched();
1495         }
1496
1497         user->status = status;
1498
1499         user_event_enabler_update(user);
1500 }
1501
1502 /*
1503  * Register callback for our events from tracing sub-systems.
1504  */
1505 static int user_event_reg(struct trace_event_call *call,
1506                           enum trace_reg type,
1507                           void *data)
1508 {
1509         struct user_event *user = (struct user_event *)call->data;
1510         int ret = 0;
1511
1512         if (!user)
1513                 return -ENOENT;
1514
1515         switch (type) {
1516         case TRACE_REG_REGISTER:
1517                 ret = tracepoint_probe_register(call->tp,
1518                                                 call->class->probe,
1519                                                 data);
1520                 if (!ret)
1521                         goto inc;
1522                 break;
1523
1524         case TRACE_REG_UNREGISTER:
1525                 tracepoint_probe_unregister(call->tp,
1526                                             call->class->probe,
1527                                             data);
1528                 goto dec;
1529
1530 #ifdef CONFIG_PERF_EVENTS
1531         case TRACE_REG_PERF_REGISTER:
1532                 ret = tracepoint_probe_register(call->tp,
1533                                                 call->class->perf_probe,
1534                                                 data);
1535                 if (!ret)
1536                         goto inc;
1537                 break;
1538
1539         case TRACE_REG_PERF_UNREGISTER:
1540                 tracepoint_probe_unregister(call->tp,
1541                                             call->class->perf_probe,
1542                                             data);
1543                 goto dec;
1544
1545         case TRACE_REG_PERF_OPEN:
1546         case TRACE_REG_PERF_CLOSE:
1547         case TRACE_REG_PERF_ADD:
1548         case TRACE_REG_PERF_DEL:
1549                 break;
1550 #endif
1551         }
1552
1553         return ret;
1554 inc:
1555         refcount_inc(&user->refcnt);
1556         update_enable_bit_for(user);
1557         return 0;
1558 dec:
1559         update_enable_bit_for(user);
1560         refcount_dec(&user->refcnt);
1561         return 0;
1562 }
1563
1564 static int user_event_create(const char *raw_command)
1565 {
1566         struct user_event_group *group;
1567         struct user_event *user;
1568         char *name;
1569         int ret;
1570
1571         if (!str_has_prefix(raw_command, USER_EVENTS_PREFIX))
1572                 return -ECANCELED;
1573
1574         raw_command += USER_EVENTS_PREFIX_LEN;
1575         raw_command = skip_spaces(raw_command);
1576
1577         name = kstrdup(raw_command, GFP_KERNEL_ACCOUNT);
1578
1579         if (!name)
1580                 return -ENOMEM;
1581
1582         group = current_user_event_group();
1583
1584         if (!group) {
1585                 kfree(name);
1586                 return -ENOENT;
1587         }
1588
1589         mutex_lock(&group->reg_mutex);
1590
1591         ret = user_event_parse_cmd(group, name, &user);
1592
1593         if (!ret)
1594                 refcount_dec(&user->refcnt);
1595
1596         mutex_unlock(&group->reg_mutex);
1597
1598         if (ret)
1599                 kfree(name);
1600
1601         return ret;
1602 }
1603
1604 static int user_event_show(struct seq_file *m, struct dyn_event *ev)
1605 {
1606         struct user_event *user = container_of(ev, struct user_event, devent);
1607         struct ftrace_event_field *field, *next;
1608         struct list_head *head;
1609         int depth = 0;
1610
1611         seq_printf(m, "%s%s", USER_EVENTS_PREFIX, EVENT_NAME(user));
1612
1613         head = trace_get_fields(&user->call);
1614
1615         list_for_each_entry_safe_reverse(field, next, head, link) {
1616                 if (depth == 0)
1617                         seq_puts(m, " ");
1618                 else
1619                         seq_puts(m, "; ");
1620
1621                 seq_printf(m, "%s %s", field->type, field->name);
1622
1623                 if (str_has_prefix(field->type, "struct "))
1624                         seq_printf(m, " %d", field->size);
1625
1626                 depth++;
1627         }
1628
1629         seq_puts(m, "\n");
1630
1631         return 0;
1632 }
1633
1634 static bool user_event_is_busy(struct dyn_event *ev)
1635 {
1636         struct user_event *user = container_of(ev, struct user_event, devent);
1637
1638         return !user_event_last_ref(user);
1639 }
1640
1641 static int user_event_free(struct dyn_event *ev)
1642 {
1643         struct user_event *user = container_of(ev, struct user_event, devent);
1644
1645         if (!user_event_last_ref(user))
1646                 return -EBUSY;
1647
1648         return destroy_user_event(user);
1649 }
1650
1651 static bool user_field_match(struct ftrace_event_field *field, int argc,
1652                              const char **argv, int *iout)
1653 {
1654         char *field_name = NULL, *dyn_field_name = NULL;
1655         bool colon = false, match = false;
1656         int dyn_len, len;
1657
1658         if (*iout >= argc)
1659                 return false;
1660
1661         dyn_len = user_dyn_field_set_string(argc, argv, iout, dyn_field_name,
1662                                             0, &colon);
1663
1664         len = user_field_set_string(field, field_name, 0, colon);
1665
1666         if (dyn_len != len)
1667                 return false;
1668
1669         dyn_field_name = kmalloc(dyn_len, GFP_KERNEL);
1670         field_name = kmalloc(len, GFP_KERNEL);
1671
1672         if (!dyn_field_name || !field_name)
1673                 goto out;
1674
1675         user_dyn_field_set_string(argc, argv, iout, dyn_field_name,
1676                                   dyn_len, &colon);
1677
1678         user_field_set_string(field, field_name, len, colon);
1679
1680         match = strcmp(dyn_field_name, field_name) == 0;
1681 out:
1682         kfree(dyn_field_name);
1683         kfree(field_name);
1684
1685         return match;
1686 }
1687
1688 static bool user_fields_match(struct user_event *user, int argc,
1689                               const char **argv)
1690 {
1691         struct ftrace_event_field *field, *next;
1692         struct list_head *head = &user->fields;
1693         int i = 0;
1694
1695         list_for_each_entry_safe_reverse(field, next, head, link)
1696                 if (!user_field_match(field, argc, argv, &i))
1697                         return false;
1698
1699         if (i != argc)
1700                 return false;
1701
1702         return true;
1703 }
1704
1705 static bool user_event_match(const char *system, const char *event,
1706                              int argc, const char **argv, struct dyn_event *ev)
1707 {
1708         struct user_event *user = container_of(ev, struct user_event, devent);
1709         bool match;
1710
1711         match = strcmp(EVENT_NAME(user), event) == 0 &&
1712                 (!system || strcmp(system, USER_EVENTS_SYSTEM) == 0);
1713
1714         if (match && argc > 0)
1715                 match = user_fields_match(user, argc, argv);
1716
1717         return match;
1718 }
1719
1720 static struct dyn_event_operations user_event_dops = {
1721         .create = user_event_create,
1722         .show = user_event_show,
1723         .is_busy = user_event_is_busy,
1724         .free = user_event_free,
1725         .match = user_event_match,
1726 };
1727
1728 static int user_event_trace_register(struct user_event *user)
1729 {
1730         int ret;
1731
1732         ret = register_trace_event(&user->call.event);
1733
1734         if (!ret)
1735                 return -ENODEV;
1736
1737         ret = user_event_set_call_visible(user, true);
1738
1739         if (ret)
1740                 unregister_trace_event(&user->call.event);
1741
1742         return ret;
1743 }
1744
1745 /*
1746  * Parses the event name, arguments and flags then registers if successful.
1747  * The name buffer lifetime is owned by this method for success cases only.
1748  * Upon success the returned user_event has its ref count increased by 1.
1749  */
1750 static int user_event_parse(struct user_event_group *group, char *name,
1751                             char *args, char *flags,
1752                             struct user_event **newuser)
1753 {
1754         int ret;
1755         u32 key;
1756         struct user_event *user;
1757
1758         /* Prevent dyn_event from racing */
1759         mutex_lock(&event_mutex);
1760         user = find_user_event(group, name, &key);
1761         mutex_unlock(&event_mutex);
1762
1763         if (user) {
1764                 *newuser = user;
1765                 /*
1766                  * Name is allocated by caller, free it since it already exists.
1767                  * Caller only worries about failure cases for freeing.
1768                  */
1769                 kfree(name);
1770                 return 0;
1771         }
1772
1773         user = kzalloc(sizeof(*user), GFP_KERNEL_ACCOUNT);
1774
1775         if (!user)
1776                 return -ENOMEM;
1777
1778         INIT_LIST_HEAD(&user->class.fields);
1779         INIT_LIST_HEAD(&user->fields);
1780         INIT_LIST_HEAD(&user->validators);
1781
1782         user->group = group;
1783         user->tracepoint.name = name;
1784
1785         ret = user_event_parse_fields(user, args);
1786
1787         if (ret)
1788                 goto put_user;
1789
1790         ret = user_event_create_print_fmt(user);
1791
1792         if (ret)
1793                 goto put_user;
1794
1795         user->call.data = user;
1796         user->call.class = &user->class;
1797         user->call.name = name;
1798         user->call.flags = TRACE_EVENT_FL_TRACEPOINT;
1799         user->call.tp = &user->tracepoint;
1800         user->call.event.funcs = &user_event_funcs;
1801         user->class.system = group->system_name;
1802
1803         user->class.fields_array = user_event_fields_array;
1804         user->class.get_fields = user_event_get_fields;
1805         user->class.reg = user_event_reg;
1806         user->class.probe = user_event_ftrace;
1807 #ifdef CONFIG_PERF_EVENTS
1808         user->class.perf_probe = user_event_perf;
1809 #endif
1810
1811         mutex_lock(&event_mutex);
1812
1813         if (current_user_events >= max_user_events) {
1814                 ret = -EMFILE;
1815                 goto put_user_lock;
1816         }
1817
1818         ret = user_event_trace_register(user);
1819
1820         if (ret)
1821                 goto put_user_lock;
1822
1823         /* Ensure we track self ref and caller ref (2) */
1824         refcount_set(&user->refcnt, 2);
1825
1826         dyn_event_init(&user->devent, &user_event_dops);
1827         dyn_event_add(&user->devent, &user->call);
1828         hash_add(group->register_table, &user->node, key);
1829         current_user_events++;
1830
1831         mutex_unlock(&event_mutex);
1832
1833         *newuser = user;
1834         return 0;
1835 put_user_lock:
1836         mutex_unlock(&event_mutex);
1837 put_user:
1838         user_event_destroy_fields(user);
1839         user_event_destroy_validators(user);
1840         kfree(user->call.print_fmt);
1841         kfree(user);
1842         return ret;
1843 }
1844
1845 /*
1846  * Deletes a previously created event if it is no longer being used.
1847  */
1848 static int delete_user_event(struct user_event_group *group, char *name)
1849 {
1850         u32 key;
1851         struct user_event *user = find_user_event(group, name, &key);
1852
1853         if (!user)
1854                 return -ENOENT;
1855
1856         refcount_dec(&user->refcnt);
1857
1858         if (!user_event_last_ref(user))
1859                 return -EBUSY;
1860
1861         return destroy_user_event(user);
1862 }
1863
1864 /*
1865  * Validates the user payload and writes via iterator.
1866  */
1867 static ssize_t user_events_write_core(struct file *file, struct iov_iter *i)
1868 {
1869         struct user_event_file_info *info = file->private_data;
1870         struct user_event_refs *refs;
1871         struct user_event *user = NULL;
1872         struct tracepoint *tp;
1873         ssize_t ret = i->count;
1874         int idx;
1875
1876         if (unlikely(copy_from_iter(&idx, sizeof(idx), i) != sizeof(idx)))
1877                 return -EFAULT;
1878
1879         if (idx < 0)
1880                 return -EINVAL;
1881
1882         rcu_read_lock_sched();
1883
1884         refs = rcu_dereference_sched(info->refs);
1885
1886         /*
1887          * The refs->events array is protected by RCU, and new items may be
1888          * added. But the user retrieved from indexing into the events array
1889          * shall be immutable while the file is opened.
1890          */
1891         if (likely(refs && idx < refs->count))
1892                 user = refs->events[idx];
1893
1894         rcu_read_unlock_sched();
1895
1896         if (unlikely(user == NULL))
1897                 return -ENOENT;
1898
1899         if (unlikely(i->count < user->min_size))
1900                 return -EINVAL;
1901
1902         tp = &user->tracepoint;
1903
1904         /*
1905          * It's possible key.enabled disables after this check, however
1906          * we don't mind if a few events are included in this condition.
1907          */
1908         if (likely(atomic_read(&tp->key.enabled) > 0)) {
1909                 struct tracepoint_func *probe_func_ptr;
1910                 user_event_func_t probe_func;
1911                 struct iov_iter copy;
1912                 void *tpdata;
1913                 bool faulted;
1914
1915                 if (unlikely(fault_in_iov_iter_readable(i, i->count)))
1916                         return -EFAULT;
1917
1918                 faulted = false;
1919
1920                 rcu_read_lock_sched();
1921
1922                 probe_func_ptr = rcu_dereference_sched(tp->funcs);
1923
1924                 if (probe_func_ptr) {
1925                         do {
1926                                 copy = *i;
1927                                 probe_func = probe_func_ptr->func;
1928                                 tpdata = probe_func_ptr->data;
1929                                 probe_func(user, &copy, tpdata, &faulted);
1930                         } while ((++probe_func_ptr)->func);
1931                 }
1932
1933                 rcu_read_unlock_sched();
1934
1935                 if (unlikely(faulted))
1936                         return -EFAULT;
1937         }
1938
1939         return ret;
1940 }
1941
1942 static int user_events_open(struct inode *node, struct file *file)
1943 {
1944         struct user_event_group *group;
1945         struct user_event_file_info *info;
1946
1947         group = current_user_event_group();
1948
1949         if (!group)
1950                 return -ENOENT;
1951
1952         info = kzalloc(sizeof(*info), GFP_KERNEL_ACCOUNT);
1953
1954         if (!info)
1955                 return -ENOMEM;
1956
1957         info->group = group;
1958
1959         file->private_data = info;
1960
1961         return 0;
1962 }
1963
1964 static ssize_t user_events_write(struct file *file, const char __user *ubuf,
1965                                  size_t count, loff_t *ppos)
1966 {
1967         struct iovec iov;
1968         struct iov_iter i;
1969
1970         if (unlikely(*ppos != 0))
1971                 return -EFAULT;
1972
1973         if (unlikely(import_single_range(ITER_SOURCE, (char __user *)ubuf,
1974                                          count, &iov, &i)))
1975                 return -EFAULT;
1976
1977         return user_events_write_core(file, &i);
1978 }
1979
1980 static ssize_t user_events_write_iter(struct kiocb *kp, struct iov_iter *i)
1981 {
1982         return user_events_write_core(kp->ki_filp, i);
1983 }
1984
1985 static int user_events_ref_add(struct user_event_file_info *info,
1986                                struct user_event *user)
1987 {
1988         struct user_event_group *group = info->group;
1989         struct user_event_refs *refs, *new_refs;
1990         int i, size, count = 0;
1991
1992         refs = rcu_dereference_protected(info->refs,
1993                                          lockdep_is_held(&group->reg_mutex));
1994
1995         if (refs) {
1996                 count = refs->count;
1997
1998                 for (i = 0; i < count; ++i)
1999                         if (refs->events[i] == user)
2000                                 return i;
2001         }
2002
2003         size = struct_size(refs, events, count + 1);
2004
2005         new_refs = kzalloc(size, GFP_KERNEL_ACCOUNT);
2006
2007         if (!new_refs)
2008                 return -ENOMEM;
2009
2010         new_refs->count = count + 1;
2011
2012         for (i = 0; i < count; ++i)
2013                 new_refs->events[i] = refs->events[i];
2014
2015         new_refs->events[i] = user;
2016
2017         refcount_inc(&user->refcnt);
2018
2019         rcu_assign_pointer(info->refs, new_refs);
2020
2021         if (refs)
2022                 kfree_rcu(refs, rcu);
2023
2024         return i;
2025 }
2026
2027 static long user_reg_get(struct user_reg __user *ureg, struct user_reg *kreg)
2028 {
2029         u32 size;
2030         long ret;
2031
2032         ret = get_user(size, &ureg->size);
2033
2034         if (ret)
2035                 return ret;
2036
2037         if (size > PAGE_SIZE)
2038                 return -E2BIG;
2039
2040         if (size < offsetofend(struct user_reg, write_index))
2041                 return -EINVAL;
2042
2043         ret = copy_struct_from_user(kreg, sizeof(*kreg), ureg, size);
2044
2045         if (ret)
2046                 return ret;
2047
2048         /* Ensure no flags, since we don't support any yet */
2049         if (kreg->flags != 0)
2050                 return -EINVAL;
2051
2052         /* Ensure supported size */
2053         switch (kreg->enable_size) {
2054         case 4:
2055                 /* 32-bit */
2056                 break;
2057 #if BITS_PER_LONG >= 64
2058         case 8:
2059                 /* 64-bit */
2060                 break;
2061 #endif
2062         default:
2063                 return -EINVAL;
2064         }
2065
2066         /* Ensure natural alignment */
2067         if (kreg->enable_addr % kreg->enable_size)
2068                 return -EINVAL;
2069
2070         /* Ensure bit range for size */
2071         if (kreg->enable_bit > (kreg->enable_size * BITS_PER_BYTE) - 1)
2072                 return -EINVAL;
2073
2074         /* Ensure accessible */
2075         if (!access_ok((const void __user *)(uintptr_t)kreg->enable_addr,
2076                        kreg->enable_size))
2077                 return -EFAULT;
2078
2079         kreg->size = size;
2080
2081         return 0;
2082 }
2083
2084 /*
2085  * Registers a user_event on behalf of a user process.
2086  */
2087 static long user_events_ioctl_reg(struct user_event_file_info *info,
2088                                   unsigned long uarg)
2089 {
2090         struct user_reg __user *ureg = (struct user_reg __user *)uarg;
2091         struct user_reg reg;
2092         struct user_event *user;
2093         struct user_event_enabler *enabler;
2094         char *name;
2095         long ret;
2096         int write_result;
2097
2098         ret = user_reg_get(ureg, &reg);
2099
2100         if (ret)
2101                 return ret;
2102
2103         /*
2104          * Prevent users from using the same address and bit multiple times
2105          * within the same mm address space. This can cause unexpected behavior
2106          * for user processes that is far easier to debug if this is explictly
2107          * an error upon registering.
2108          */
2109         if (current_user_event_enabler_exists((unsigned long)reg.enable_addr,
2110                                               reg.enable_bit))
2111                 return -EADDRINUSE;
2112
2113         name = strndup_user((const char __user *)(uintptr_t)reg.name_args,
2114                             MAX_EVENT_DESC);
2115
2116         if (IS_ERR(name)) {
2117                 ret = PTR_ERR(name);
2118                 return ret;
2119         }
2120
2121         ret = user_event_parse_cmd(info->group, name, &user);
2122
2123         if (ret) {
2124                 kfree(name);
2125                 return ret;
2126         }
2127
2128         ret = user_events_ref_add(info, user);
2129
2130         /* No longer need parse ref, ref_add either worked or not */
2131         refcount_dec(&user->refcnt);
2132
2133         /* Positive number is index and valid */
2134         if (ret < 0)
2135                 return ret;
2136
2137         /*
2138          * user_events_ref_add succeeded:
2139          * At this point we have a user_event, it's lifetime is bound by the
2140          * reference count, not this file. If anything fails, the user_event
2141          * still has a reference until the file is released. During release
2142          * any remaining references (from user_events_ref_add) are decremented.
2143          *
2144          * Attempt to create an enabler, which too has a lifetime tied in the
2145          * same way for the event. Once the task that caused the enabler to be
2146          * created exits or issues exec() then the enablers it has created
2147          * will be destroyed and the ref to the event will be decremented.
2148          */
2149         enabler = user_event_enabler_create(&reg, user, &write_result);
2150
2151         if (!enabler)
2152                 return -ENOMEM;
2153
2154         /* Write failed/faulted, give error back to caller */
2155         if (write_result)
2156                 return write_result;
2157
2158         put_user((u32)ret, &ureg->write_index);
2159
2160         return 0;
2161 }
2162
2163 /*
2164  * Deletes a user_event on behalf of a user process.
2165  */
2166 static long user_events_ioctl_del(struct user_event_file_info *info,
2167                                   unsigned long uarg)
2168 {
2169         void __user *ubuf = (void __user *)uarg;
2170         char *name;
2171         long ret;
2172
2173         name = strndup_user(ubuf, MAX_EVENT_DESC);
2174
2175         if (IS_ERR(name))
2176                 return PTR_ERR(name);
2177
2178         /* event_mutex prevents dyn_event from racing */
2179         mutex_lock(&event_mutex);
2180         ret = delete_user_event(info->group, name);
2181         mutex_unlock(&event_mutex);
2182
2183         kfree(name);
2184
2185         return ret;
2186 }
2187
2188 static long user_unreg_get(struct user_unreg __user *ureg,
2189                            struct user_unreg *kreg)
2190 {
2191         u32 size;
2192         long ret;
2193
2194         ret = get_user(size, &ureg->size);
2195
2196         if (ret)
2197                 return ret;
2198
2199         if (size > PAGE_SIZE)
2200                 return -E2BIG;
2201
2202         if (size < offsetofend(struct user_unreg, disable_addr))
2203                 return -EINVAL;
2204
2205         ret = copy_struct_from_user(kreg, sizeof(*kreg), ureg, size);
2206
2207         /* Ensure no reserved values, since we don't support any yet */
2208         if (kreg->__reserved || kreg->__reserved2)
2209                 return -EINVAL;
2210
2211         return ret;
2212 }
2213
2214 static int user_event_mm_clear_bit(struct user_event_mm *user_mm,
2215                                    unsigned long uaddr, unsigned char bit)
2216 {
2217         struct user_event_enabler enabler;
2218         int result;
2219         int attempt = 0;
2220
2221         memset(&enabler, 0, sizeof(enabler));
2222         enabler.addr = uaddr;
2223         enabler.values = bit;
2224 retry:
2225         /* Prevents state changes from racing with new enablers */
2226         mutex_lock(&event_mutex);
2227
2228         /* Force the bit to be cleared, since no event is attached */
2229         mmap_read_lock(user_mm->mm);
2230         result = user_event_enabler_write(user_mm, &enabler, false, &attempt);
2231         mmap_read_unlock(user_mm->mm);
2232
2233         mutex_unlock(&event_mutex);
2234
2235         if (result) {
2236                 /* Attempt to fault-in and retry if it worked */
2237                 if (!user_event_mm_fault_in(user_mm, uaddr, attempt))
2238                         goto retry;
2239         }
2240
2241         return result;
2242 }
2243
2244 /*
2245  * Unregisters an enablement address/bit within a task/user mm.
2246  */
2247 static long user_events_ioctl_unreg(unsigned long uarg)
2248 {
2249         struct user_unreg __user *ureg = (struct user_unreg __user *)uarg;
2250         struct user_event_mm *mm = current->user_event_mm;
2251         struct user_event_enabler *enabler, *next;
2252         struct user_unreg reg;
2253         long ret;
2254
2255         ret = user_unreg_get(ureg, &reg);
2256
2257         if (ret)
2258                 return ret;
2259
2260         if (!mm)
2261                 return -ENOENT;
2262
2263         ret = -ENOENT;
2264
2265         /*
2266          * Flags freeing and faulting are used to indicate if the enabler is in
2267          * use at all. When faulting is set a page-fault is occurring asyncly.
2268          * During async fault if freeing is set, the enabler will be destroyed.
2269          * If no async fault is happening, we can destroy it now since we hold
2270          * the event_mutex during these checks.
2271          */
2272         mutex_lock(&event_mutex);
2273
2274         list_for_each_entry_safe(enabler, next, &mm->enablers, link)
2275                 if (enabler->addr == reg.disable_addr &&
2276                     ENABLE_BIT(enabler) == reg.disable_bit) {
2277                         set_bit(ENABLE_VAL_FREEING_BIT, ENABLE_BITOPS(enabler));
2278
2279                         if (!test_bit(ENABLE_VAL_FAULTING_BIT, ENABLE_BITOPS(enabler)))
2280                                 user_event_enabler_destroy(enabler);
2281
2282                         /* Removed at least one */
2283                         ret = 0;
2284                 }
2285
2286         mutex_unlock(&event_mutex);
2287
2288         /* Ensure bit is now cleared for user, regardless of event status */
2289         if (!ret)
2290                 ret = user_event_mm_clear_bit(mm, reg.disable_addr,
2291                                               reg.disable_bit);
2292
2293         return ret;
2294 }
2295
2296 /*
2297  * Handles the ioctl from user mode to register or alter operations.
2298  */
2299 static long user_events_ioctl(struct file *file, unsigned int cmd,
2300                               unsigned long uarg)
2301 {
2302         struct user_event_file_info *info = file->private_data;
2303         struct user_event_group *group = info->group;
2304         long ret = -ENOTTY;
2305
2306         switch (cmd) {
2307         case DIAG_IOCSREG:
2308                 mutex_lock(&group->reg_mutex);
2309                 ret = user_events_ioctl_reg(info, uarg);
2310                 mutex_unlock(&group->reg_mutex);
2311                 break;
2312
2313         case DIAG_IOCSDEL:
2314                 mutex_lock(&group->reg_mutex);
2315                 ret = user_events_ioctl_del(info, uarg);
2316                 mutex_unlock(&group->reg_mutex);
2317                 break;
2318
2319         case DIAG_IOCSUNREG:
2320                 mutex_lock(&group->reg_mutex);
2321                 ret = user_events_ioctl_unreg(uarg);
2322                 mutex_unlock(&group->reg_mutex);
2323                 break;
2324         }
2325
2326         return ret;
2327 }
2328
2329 /*
2330  * Handles the final close of the file from user mode.
2331  */
2332 static int user_events_release(struct inode *node, struct file *file)
2333 {
2334         struct user_event_file_info *info = file->private_data;
2335         struct user_event_group *group;
2336         struct user_event_refs *refs;
2337         struct user_event *user;
2338         int i;
2339
2340         if (!info)
2341                 return -EINVAL;
2342
2343         group = info->group;
2344
2345         /*
2346          * Ensure refs cannot change under any situation by taking the
2347          * register mutex during the final freeing of the references.
2348          */
2349         mutex_lock(&group->reg_mutex);
2350
2351         refs = info->refs;
2352
2353         if (!refs)
2354                 goto out;
2355
2356         /*
2357          * The lifetime of refs has reached an end, it's tied to this file.
2358          * The underlying user_events are ref counted, and cannot be freed.
2359          * After this decrement, the user_events may be freed elsewhere.
2360          */
2361         for (i = 0; i < refs->count; ++i) {
2362                 user = refs->events[i];
2363
2364                 if (user)
2365                         refcount_dec(&user->refcnt);
2366         }
2367 out:
2368         file->private_data = NULL;
2369
2370         mutex_unlock(&group->reg_mutex);
2371
2372         kfree(refs);
2373         kfree(info);
2374
2375         return 0;
2376 }
2377
2378 static const struct file_operations user_data_fops = {
2379         .open           = user_events_open,
2380         .write          = user_events_write,
2381         .write_iter     = user_events_write_iter,
2382         .unlocked_ioctl = user_events_ioctl,
2383         .release        = user_events_release,
2384 };
2385
2386 static void *user_seq_start(struct seq_file *m, loff_t *pos)
2387 {
2388         if (*pos)
2389                 return NULL;
2390
2391         return (void *)1;
2392 }
2393
2394 static void *user_seq_next(struct seq_file *m, void *p, loff_t *pos)
2395 {
2396         ++*pos;
2397         return NULL;
2398 }
2399
2400 static void user_seq_stop(struct seq_file *m, void *p)
2401 {
2402 }
2403
2404 static int user_seq_show(struct seq_file *m, void *p)
2405 {
2406         struct user_event_group *group = m->private;
2407         struct user_event *user;
2408         char status;
2409         int i, active = 0, busy = 0;
2410
2411         if (!group)
2412                 return -EINVAL;
2413
2414         mutex_lock(&group->reg_mutex);
2415
2416         hash_for_each(group->register_table, i, user, node) {
2417                 status = user->status;
2418
2419                 seq_printf(m, "%s", EVENT_NAME(user));
2420
2421                 if (status != 0)
2422                         seq_puts(m, " #");
2423
2424                 if (status != 0) {
2425                         seq_puts(m, " Used by");
2426                         if (status & EVENT_STATUS_FTRACE)
2427                                 seq_puts(m, " ftrace");
2428                         if (status & EVENT_STATUS_PERF)
2429                                 seq_puts(m, " perf");
2430                         if (status & EVENT_STATUS_OTHER)
2431                                 seq_puts(m, " other");
2432                         busy++;
2433                 }
2434
2435                 seq_puts(m, "\n");
2436                 active++;
2437         }
2438
2439         mutex_unlock(&group->reg_mutex);
2440
2441         seq_puts(m, "\n");
2442         seq_printf(m, "Active: %d\n", active);
2443         seq_printf(m, "Busy: %d\n", busy);
2444
2445         return 0;
2446 }
2447
2448 static const struct seq_operations user_seq_ops = {
2449         .start  = user_seq_start,
2450         .next   = user_seq_next,
2451         .stop   = user_seq_stop,
2452         .show   = user_seq_show,
2453 };
2454
2455 static int user_status_open(struct inode *node, struct file *file)
2456 {
2457         struct user_event_group *group;
2458         int ret;
2459
2460         group = current_user_event_group();
2461
2462         if (!group)
2463                 return -ENOENT;
2464
2465         ret = seq_open(file, &user_seq_ops);
2466
2467         if (!ret) {
2468                 /* Chain group to seq_file */
2469                 struct seq_file *m = file->private_data;
2470
2471                 m->private = group;
2472         }
2473
2474         return ret;
2475 }
2476
2477 static const struct file_operations user_status_fops = {
2478         .open           = user_status_open,
2479         .read           = seq_read,
2480         .llseek         = seq_lseek,
2481         .release        = seq_release,
2482 };
2483
2484 /*
2485  * Creates a set of tracefs files to allow user mode interactions.
2486  */
2487 static int create_user_tracefs(void)
2488 {
2489         struct dentry *edata, *emmap;
2490
2491         edata = tracefs_create_file("user_events_data", TRACE_MODE_WRITE,
2492                                     NULL, NULL, &user_data_fops);
2493
2494         if (!edata) {
2495                 pr_warn("Could not create tracefs 'user_events_data' entry\n");
2496                 goto err;
2497         }
2498
2499         emmap = tracefs_create_file("user_events_status", TRACE_MODE_READ,
2500                                     NULL, NULL, &user_status_fops);
2501
2502         if (!emmap) {
2503                 tracefs_remove(edata);
2504                 pr_warn("Could not create tracefs 'user_events_mmap' entry\n");
2505                 goto err;
2506         }
2507
2508         return 0;
2509 err:
2510         return -ENODEV;
2511 }
2512
2513 static int set_max_user_events_sysctl(struct ctl_table *table, int write,
2514                                       void *buffer, size_t *lenp, loff_t *ppos)
2515 {
2516         int ret;
2517
2518         mutex_lock(&event_mutex);
2519
2520         ret = proc_douintvec(table, write, buffer, lenp, ppos);
2521
2522         mutex_unlock(&event_mutex);
2523
2524         return ret;
2525 }
2526
2527 static struct ctl_table user_event_sysctls[] = {
2528         {
2529                 .procname       = "user_events_max",
2530                 .data           = &max_user_events,
2531                 .maxlen         = sizeof(unsigned int),
2532                 .mode           = 0644,
2533                 .proc_handler   = set_max_user_events_sysctl,
2534         },
2535         {}
2536 };
2537
2538 static int __init trace_events_user_init(void)
2539 {
2540         int ret;
2541
2542         fault_cache = KMEM_CACHE(user_event_enabler_fault, 0);
2543
2544         if (!fault_cache)
2545                 return -ENOMEM;
2546
2547         init_group = user_event_group_create(&init_user_ns);
2548
2549         if (!init_group) {
2550                 kmem_cache_destroy(fault_cache);
2551                 return -ENOMEM;
2552         }
2553
2554         ret = create_user_tracefs();
2555
2556         if (ret) {
2557                 pr_warn("user_events could not register with tracefs\n");
2558                 user_event_group_destroy(init_group);
2559                 kmem_cache_destroy(fault_cache);
2560                 init_group = NULL;
2561                 return ret;
2562         }
2563
2564         if (dyn_event_register(&user_event_dops))
2565                 pr_warn("user_events could not register with dyn_events\n");
2566
2567         register_sysctl_init("kernel", user_event_sysctls);
2568
2569         return 0;
2570 }
2571
2572 fs_initcall(trace_events_user_init);