lustre/ofd/ofd_access_log.c

   1 #include <linux/cdev.h>
   2 #include <linux/circ_buf.h>
   3 #include <linux/device.h>
   4 #include <linux/fs.h>
   5 #include <linux/kernel.h>
   6 #include <linux/miscdevice.h>
   7 #include <linux/module.h>
   8 #include <linux/poll.h>
   9 #include <linux/slab.h>
  10 #include <linux/types.h>
  11 #include <linux/uaccess.h>
  12 #include <uapi/linux/lustre/lustre_idl.h>
  13 #include <uapi/linux/lustre/lustre_access_log.h>
  14 #include "ofd_internal.h"
  15
  16 /* OFD access logs: OST (OFD) RPC handlers log accesses by FID and
  17  * PFID which are read from userspace through character device files
  18  * (/dev/lustre-access-log/scratch-OST0000). Accesses are described by
  19  * struct ofd_access_entry_v1. The char device implements read()
  20  * (blocking and nonblocking) and poll(), along with an ioctl that
  21  * returns diagnostic information on an oal device.
  22  *
  23  * A control device (/dev/lustre-access-log/control) supports an ioctl()
  24  * plus poll() method to for oal discovery. See uses of
  25  * oal_control_event_count and oal_control_wait_queue for details.
  26  *
  27  * oal log size and entry size are restricted to powers of 2 to
  28  * support circ_buf methods. See Documentation/core-api/circular-buffers.rst
  29  * in the linux tree for more information.
  30  *
  31  * The associated struct device (*oal_device) owns the oal. The
  32  * release() method of oal_device frees the oal and releases its
  33  * minor. This may seem slightly more complicated than necessary but
  34  * it allows the OST to be unmounted while the oal still has open file
  35  * descriptors.
  36  */
  37
  38 enum {
  39         OAL_DEV_COUNT = 1 << MINORBITS,
  40 };
  41
  42 struct ofd_access_log {
  43         char oal_name[128]; /* lustre-OST0000 */
  44         struct device oal_device;
  45         struct cdev oal_cdev;
  46         struct circ_buf oal_circ;
  47         wait_queue_head_t oal_read_wait_queue;
  48         spinlock_t oal_read_lock;
  49         spinlock_t oal_write_lock;
  50         unsigned int oal_drop_count;
  51         unsigned int oal_is_closed;
  52         unsigned int oal_log_size;
  53         unsigned int oal_entry_size;
  54 };
  55
  56 static atomic_t oal_control_event_count = ATOMIC_INIT(0);
  57 static DECLARE_WAIT_QUEUE_HEAD(oal_control_wait_queue);
  58
  59 static struct class *oal_log_class;
  60 static unsigned int oal_log_major;
  61 static DEFINE_IDR(oal_log_minor_idr); /* TODO Use ida instead. */
  62 static DEFINE_SPINLOCK(oal_log_minor_lock);
  63
  64 bool ofd_access_log_size_is_valid(unsigned int size)
  65 {
  66         const unsigned int size_min = 2 * sizeof(struct ofd_access_entry_v1);
  67         const unsigned int size_max = 1U << 30;
  68
  69         if (size == 0)
  70                 return true;
  71
  72         return is_power_of_2(size) && size_min <= size && size <= size_max;
  73 }
  74
  75 static void oal_control_event_inc(void)
  76 {
  77         atomic_inc(&oal_control_event_count);
  78         wake_up(&oal_control_wait_queue);
  79 }
  80
  81 static int oal_log_minor_alloc(int *pminor)
  82 {
  83         void *OAL_LOG_MINOR_ALLOCED = (void *)-1;
  84         int minor;
  85
  86         idr_preload(GFP_KERNEL);
  87         spin_lock(&oal_log_minor_lock);
  88         minor = idr_alloc(&oal_log_minor_idr, OAL_LOG_MINOR_ALLOCED, 0,
  89                         OAL_DEV_COUNT, GFP_NOWAIT);
  90         spin_unlock(&oal_log_minor_lock);
  91         idr_preload_end();
  92
  93         if (minor < 0)
  94                 return minor;
  95
  96         *pminor = minor;
  97
  98         return 0;
  99 }
 100
 101 static void oal_log_minor_free(int minor)
 102 {
 103         spin_lock(&oal_log_minor_lock);
 104         idr_remove(&oal_log_minor_idr, minor);
 105         spin_unlock(&oal_log_minor_lock);
 106 }
 107
 108 static bool oal_is_empty(struct ofd_access_log *oal)
 109 {
 110         return CIRC_CNT(oal->oal_circ.head,
 111                         oal->oal_circ.tail,
 112                         oal->oal_log_size) < oal->oal_entry_size;
 113 }
 114
 115 static ssize_t oal_write_entry(struct ofd_access_log *oal,
 116                         const void *entry, size_t entry_size)
 117 {
 118         struct circ_buf *circ = &oal->oal_circ;
 119         unsigned int head;
 120         unsigned int tail;
 121         ssize_t rc;
 122
 123         if (entry_size != oal->oal_entry_size)
 124                 return -EINVAL;
 125
 126         spin_lock(&oal->oal_write_lock);
 127         head = circ->head;
 128         tail = READ_ONCE(circ->tail);
 129
 130         /* CIRC_SPACE() return space available, 0..oal_log_size -
 131          * 1. It always leaves one free char, since a completely full
 132          * buffer would have head == tail, which is the same as empty. */
 133         if (CIRC_SPACE(head, tail, oal->oal_log_size) < oal->oal_entry_size) {
 134                 oal->oal_drop_count++;
 135                 rc = -EAGAIN;
 136                 goto out_write_lock;
 137         }
 138
 139         memcpy(&circ->buf[head], entry, entry_size);
 140         rc = entry_size;
 141
 142         /* Ensure the entry is stored before we update the head. */
 143         smp_store_release(&circ->head,
 144                         (head + oal->oal_entry_size) & (oal->oal_log_size - 1));
 145
 146         wake_up(&oal->oal_read_wait_queue);
 147 out_write_lock:
 148         spin_unlock(&oal->oal_write_lock);
 149
 150         return rc;
 151 }
 152
 153 /* Read one entry from the log and return its size. Non-blocking.
 154  * When the log is empty we return -EAGAIN if the OST is still mounted
 155  * and 0 otherwise.
 156  */
 157 static ssize_t oal_read_entry(struct ofd_access_log *oal,
 158                         void *entry_buf, size_t entry_buf_size)
 159 {
 160         struct circ_buf *circ = &oal->oal_circ;
 161         unsigned int head;
 162         unsigned int tail;
 163         ssize_t rc;
 164
 165         /* XXX This method may silently truncate entries when
 166          * entry_buf_size is less than oal_entry_size. But that's OK
 167          * because you know what you are doing. */
 168         spin_lock(&oal->oal_read_lock);
 169
 170         /* Memory barrier usage follows circular-buffers.txt. */
 171         head = smp_load_acquire(&circ->head);
 172         tail = circ->tail;
 173
 174         if (!CIRC_CNT(head, tail, oal->oal_log_size)) {
 175                 rc = oal->oal_is_closed ? 0 : -EAGAIN;
 176                 goto out_read_lock;
 177         }
 178
 179         BUG_ON(CIRC_CNT(head, tail, oal->oal_log_size) < oal->oal_entry_size);
 180
 181         /* Read index before reading contents at that index. */
 182         smp_read_barrier_depends();
 183
 184         /* Extract one entry from the buffer. */
 185         rc = min_t(size_t, oal->oal_entry_size, entry_buf_size);
 186         memcpy(entry_buf, &circ->buf[tail], rc);
 187
 188         /* Memory barrier usage follows circular-buffers.txt. */
 189         smp_store_release(&circ->tail,
 190                         (tail + oal->oal_entry_size) & (oal->oal_log_size - 1));
 191
 192 out_read_lock:
 193         spin_unlock(&oal->oal_read_lock);
 194
 195         return rc;
 196 }
 197
 198 static int oal_file_open(struct inode *inode, struct file *filp)
 199 {
 200         filp->private_data = container_of(inode->i_cdev,
 201                                         struct ofd_access_log, oal_cdev);
 202
 203         return nonseekable_open(inode, filp);
 204 }
 205
 206 /* User buffer size must be a multiple of ofd access entry size. */
 207 static ssize_t oal_file_read(struct file *filp, char __user *buf, size_t count,
 208                         loff_t *ppos)
 209 {
 210         struct ofd_access_log *oal = filp->private_data;
 211         void *entry;
 212         size_t size = 0;
 213         int rc = 0;
 214
 215         if (!count)
 216                 return 0;
 217
 218         if (count & (oal->oal_entry_size - 1))
 219                 return -EINVAL;
 220
 221         entry = kzalloc(oal->oal_entry_size, GFP_KERNEL);
 222         if (!entry)
 223                 return -ENOMEM;
 224
 225         while (size < count) {
 226                 rc = oal_read_entry(oal, entry, oal->oal_entry_size);
 227                 if (rc == -EAGAIN) {
 228                         if (filp->f_flags & O_NONBLOCK)
 229                                 break;
 230
 231                         rc = wait_event_interruptible(oal->oal_read_wait_queue,
 232                                 !oal_is_empty(oal) || oal->oal_is_closed);
 233                         if (rc)
 234                                 break;
 235                 } else if (rc <= 0) {
 236                         break; /* cloed or error */
 237                 } else {
 238                         if (copy_to_user(buf, entry, oal->oal_entry_size)) {
 239                                 rc = -EFAULT;
 240                                 break;
 241                         }
 242
 243                         buf += oal->oal_entry_size;
 244                         size += oal->oal_entry_size;
 245                 }
 246         }
 247
 248         kfree(entry);
 249
 250         return size ? size : rc;
 251 }
 252
 253 /* Included for test purposes. User buffer size must be a multiple of
 254  * ofd access entry size. */
 255 static ssize_t oal_file_write(struct file *filp, const char __user *buf,
 256                         size_t count, loff_t *ppos)
 257 {
 258         struct ofd_access_log *oal = filp->private_data;
 259         void *entry;
 260         size_t size = 0;
 261         ssize_t rc = 0;
 262
 263         if (!count)
 264                 return 0;
 265
 266         if (count & (oal->oal_entry_size - 1))
 267                 return -EINVAL;
 268
 269         entry = kzalloc(oal->oal_entry_size, GFP_KERNEL);
 270         if (!entry)
 271                 return -ENOMEM;
 272
 273         while (size < count) {
 274                 if (copy_from_user(entry, buf, oal->oal_entry_size)) {
 275                         rc = -EFAULT;
 276                         break;
 277                 }
 278
 279                 rc = oal_write_entry(oal, entry, oal->oal_entry_size);
 280                 if (rc <= 0)
 281                         break;
 282
 283                 buf += oal->oal_entry_size;
 284                 size += oal->oal_entry_size;
 285         }
 286
 287         kfree(entry);
 288
 289         return size > 0 ? size : rc;
 290 }
 291
 292 unsigned int oal_file_poll(struct file *filp, struct poll_table_struct *wait)
 293 {
 294         struct ofd_access_log *oal = filp->private_data;
 295         unsigned int mask = 0;
 296
 297         poll_wait(filp, &oal->oal_read_wait_queue, wait);
 298
 299         spin_lock(&oal->oal_read_lock);
 300
 301         if (!oal_is_empty(oal) || oal->oal_is_closed)
 302                 mask |= POLLIN;
 303
 304         spin_unlock(&oal->oal_read_lock);
 305
 306         return mask;
 307 }
 308
 309 static long oal_ioctl_info(struct ofd_access_log *oal, unsigned long arg)
 310 {
 311         struct lustre_access_log_info_v1 __user *lali;
 312         u32 entry_count = CIRC_CNT(oal->oal_circ.head,
 313                                 oal->oal_circ.tail,
 314                                 oal->oal_log_size) / oal->oal_entry_size;
 315         u32 entry_space = CIRC_SPACE(oal->oal_circ.head,
 316                                 oal->oal_circ.tail,
 317                                 oal->oal_log_size) / oal->oal_entry_size;
 318
 319         lali = (struct lustre_access_log_info_v1 __user *)arg;
 320         BUILD_BUG_ON(sizeof(lali->lali_name) != sizeof(oal->oal_name));
 321
 322         if (put_user(LUSTRE_ACCESS_LOG_VERSION_1, &lali->lali_version))
 323                 return -EFAULT;
 324
 325         if (put_user(LUSTRE_ACCESS_LOG_TYPE_OFD, &lali->lali_type))
 326                 return -EFAULT;
 327
 328         if (copy_to_user(lali->lali_name, oal->oal_name, sizeof(oal->oal_name)))
 329                 return -EFAULT;
 330
 331         if (put_user(oal->oal_log_size, &lali->lali_log_size))
 332                 return -EFAULT;
 333
 334         if (put_user(oal->oal_entry_size, &lali->lali_entry_size))
 335                 return -EFAULT;
 336
 337         if (put_user(oal->oal_circ.head, &lali->_lali_head))
 338                 return -EFAULT;
 339
 340         if (put_user(oal->oal_circ.tail, &lali->_lali_tail))
 341                 return -EFAULT;
 342
 343         if (put_user(entry_space, &lali->_lali_entry_space))
 344                 return -EFAULT;
 345
 346         if (put_user(entry_count, &lali->_lali_entry_count))
 347                 return -EFAULT;
 348
 349         if (put_user(oal->oal_drop_count, &lali->_lali_drop_count))
 350                 return -EFAULT;
 351
 352         if (put_user(oal->oal_is_closed, &lali->_lali_is_closed))
 353                 return -EFAULT;
 354
 355         return 0;
 356 }
 357
 358 static long oal_file_ioctl(struct file *filp, unsigned int cmd,
 359                         unsigned long arg)
 360 {
 361         struct ofd_access_log *oal = filp->private_data;
 362
 363         switch (cmd) {
 364         case LUSTRE_ACCESS_LOG_IOCTL_VERSION:
 365                 return LUSTRE_ACCESS_LOG_VERSION_1;
 366         case LUSTRE_ACCESS_LOG_IOCTL_INFO:
 367                 return oal_ioctl_info(oal, arg);
 368         default:
 369                 return -ENOTTY;
 370         }
 371 }
 372
 373 static const struct file_operations oal_fops = {
 374         .owner = THIS_MODULE,
 375         .open = &oal_file_open,
 376         .unlocked_ioctl = &oal_file_ioctl,
 377         .read = &oal_file_read,
 378         .write = &oal_file_write,
 379         .poll = &oal_file_poll,
 380         .llseek = &no_llseek,
 381 };
 382
 383 static void oal_device_release(struct device *dev)
 384 {
 385         struct ofd_access_log *oal = dev_get_drvdata(dev);
 386
 387         oal_log_minor_free(MINOR(oal->oal_device.devt));
 388         vfree(oal->oal_circ.buf);
 389         kfree(oal);
 390 }
 391
 392 struct ofd_access_log *ofd_access_log_create(const char *ofd_name, size_t size)
 393 {
 394         const size_t entry_size = sizeof(struct ofd_access_entry_v1);
 395         struct ofd_access_log *oal;
 396         int minor;
 397         int rc;
 398
 399         BUILD_BUG_ON(sizeof(oal->oal_name) != MAX_OBD_NAME);
 400         BUILD_BUG_ON(!is_power_of_2(entry_size));
 401
 402         if (!size)
 403                 return NULL;
 404
 405         if (!is_power_of_2(size) || (size & (entry_size - 1)) ||
 406             (unsigned int)size != size)
 407                 return ERR_PTR(-EINVAL);
 408
 409         oal = kzalloc(sizeof(*oal), GFP_KERNEL);
 410         if (!oal)
 411                 return ERR_PTR(-ENOMEM);
 412
 413         strlcpy(oal->oal_name, ofd_name, sizeof(oal->oal_name));
 414         oal->oal_log_size = size;
 415         oal->oal_entry_size = entry_size;
 416         spin_lock_init(&oal->oal_write_lock);
 417         spin_lock_init(&oal->oal_read_lock);
 418         init_waitqueue_head(&oal->oal_read_wait_queue);
 419
 420         oal->oal_circ.buf = vmalloc(oal->oal_log_size);
 421         if (!oal->oal_circ.buf) {
 422                 rc = -ENOMEM;
 423                 goto out_free;
 424         }
 425
 426         rc = oal_log_minor_alloc(&minor);
 427         if (rc < 0)
 428                 goto out_free;
 429
 430         device_initialize(&oal->oal_device);
 431         oal->oal_device.devt = MKDEV(oal_log_major, minor);
 432         oal->oal_device.class = oal_log_class;
 433         oal->oal_device.release = &oal_device_release;
 434         dev_set_drvdata(&oal->oal_device, oal);
 435         rc = dev_set_name(&oal->oal_device,
 436                         "%s!%s", LUSTRE_ACCESS_LOG_DIR_NAME, oal->oal_name);
 437         if (rc < 0)
 438                 goto out_minor;
 439
 440         cdev_init(&oal->oal_cdev, &oal_fops);
 441         oal->oal_cdev.owner = THIS_MODULE;
 442         rc = cdev_device_add(&oal->oal_cdev, &oal->oal_device);
 443         if (rc < 0)
 444                 goto out_device_name;
 445
 446         oal_control_event_inc();
 447
 448         return oal;
 449
 450 out_device_name:
 451         kfree_const(oal->oal_device.kobj.name);
 452 out_minor:
 453         oal_log_minor_free(minor);
 454 out_free:
 455         vfree(oal->oal_circ.buf);
 456         kfree(oal);
 457
 458         return ERR_PTR(rc);
 459 }
 460
 461 void ofd_access(struct ofd_device *m,
 462                 const struct lu_fid *parent_fid,
 463                 __u64 begin, __u64 end,
 464                 unsigned int size,
 465                 unsigned int segment_count,
 466                 int rw)
 467 {
 468         unsigned int flags = (rw == READ) ? OFD_ACCESS_READ : OFD_ACCESS_WRITE;
 469
 470         if (m->ofd_access_log && (flags & m->ofd_access_log_mask)) {
 471                 struct ofd_access_entry_v1 oae = {
 472                         .oae_parent_fid = *parent_fid,
 473                         .oae_begin = begin,
 474                         .oae_end = end,
 475                         .oae_time = ktime_get_real_seconds(),
 476                         .oae_size = size,
 477                         .oae_segment_count = segment_count,
 478                         .oae_flags = flags,
 479                 };
 480
 481                 oal_write_entry(m->ofd_access_log, &oae, sizeof(oae));
 482         }
 483 }
 484
 485 /* Called on OST umount to:
 486  * - Close the write end of the oal. The wakes any tasks sleeping in
 487  *   read or poll and makes all reads return zero once the log
 488  *   becomes empty.
 489  * - Delete the associated stuct device and cdev, preventing new
 490  *   opens. Existing opens retain a reference on the oal through
 491  *   their reference on oal_device.
 492  * The oal will be freed when the last open file handle is closed. */
 493 void ofd_access_log_delete(struct ofd_access_log *oal)
 494 {
 495         if (!oal)
 496                 return;
 497
 498         oal->oal_is_closed = 1;
 499         wake_up_all(&oal->oal_read_wait_queue);
 500         cdev_device_del(&oal->oal_cdev, &oal->oal_device);
 501 }
 502
 503 /* private_data for control device file. */
 504 struct oal_control_file {
 505         int ccf_event_count;
 506 };
 507
 508 /* Control file usage:
 509  * Open /dev/lustre-access-log/control.
 510  * while (1)
 511  *   Poll for readable on control FD.
 512  *   Call ioctl(FD, LUSTRE_ACCESS_LOG_IOCTL_PRESCAN) to fetch event count.
 513  *   Scan /dev/ or /sys/class/... for new devices.
 514  */
 515 static int oal_control_file_open(struct inode *inode, struct file *filp)
 516 {
 517         struct oal_control_file *ccf;
 518         int rc;
 519
 520         rc = nonseekable_open(inode, filp);
 521         if (rc)
 522                 return rc;
 523
 524         /* ccf->ccf_event_count = 0 on open */
 525         ccf = kzalloc(sizeof(*ccf), GFP_KERNEL);
 526         if (!ccf)
 527                 return -ENOMEM;
 528
 529         filp->private_data = ccf;
 530
 531         return 0;
 532 }
 533
 534 static int oal_control_file_release(struct inode *inode, struct file *filp)
 535 {
 536         kfree(filp->private_data);
 537         return 0;
 538 }
 539
 540 static unsigned int oal_control_file_poll(struct file *filp, poll_table *wait)
 541 {
 542         struct oal_control_file *ccf = filp->private_data;
 543         unsigned int mask = 0;
 544
 545         poll_wait(filp, &oal_control_wait_queue, wait);
 546
 547         if (atomic_read(&oal_control_event_count) != ccf->ccf_event_count)
 548                 mask |= POLLIN;
 549
 550         return mask;
 551 }
 552
 553 static long oal_control_file_ioctl(struct file *filp, unsigned int cmd,
 554                                 unsigned long arg)
 555 {
 556         struct oal_control_file *ccf = filp->private_data;
 557
 558         switch (cmd) {
 559         case LUSTRE_ACCESS_LOG_IOCTL_VERSION:
 560                 return LUSTRE_ACCESS_LOG_VERSION_1;
 561         case LUSTRE_ACCESS_LOG_IOCTL_MAJOR:
 562                 return oal_log_major;
 563         case LUSTRE_ACCESS_LOG_IOCTL_PRESCAN:
 564                 ccf->ccf_event_count = atomic_read(&oal_control_event_count);
 565                 return 0;
 566         default:
 567                 return -ENOTTY;
 568         }
 569 }
 570
 571 static const struct file_operations oal_control_fops = {
 572         .owner = THIS_MODULE,
 573         .open = &oal_control_file_open,
 574         .release = &oal_control_file_release,
 575         .poll = &oal_control_file_poll,
 576         .unlocked_ioctl = &oal_control_file_ioctl,
 577         .llseek = &noop_llseek,
 578 };
 579
 580 static struct miscdevice oal_control_misc = {
 581         .minor = MISC_DYNAMIC_MINOR,
 582         .name = LUSTRE_ACCESS_LOG_DIR_NAME"!control",
 583         .fops = &oal_control_fops,
 584 };
 585
 586 int ofd_access_log_module_init(void)
 587 {
 588         dev_t dev;
 589         int rc;
 590
 591         BUILD_BUG_ON(!is_power_of_2(sizeof(struct ofd_access_entry_v1)));
 592
 593         rc = misc_register(&oal_control_misc);
 594         if (rc)
 595                 return rc;
 596
 597         rc = alloc_chrdev_region(&dev, 0, OAL_DEV_COUNT,
 598                                 LUSTRE_ACCESS_LOG_DIR_NAME);
 599         if (rc)
 600                 goto out_oal_control_misc;
 601
 602         oal_log_major = MAJOR(dev);
 603
 604         oal_log_class = class_create(THIS_MODULE, LUSTRE_ACCESS_LOG_DIR_NAME);
 605         if (IS_ERR(oal_log_class)) {
 606                 rc = PTR_ERR(oal_log_class);
 607                 goto out_dev;
 608         }
 609
 610         return 0;
 611 out_dev:
 612         unregister_chrdev_region(dev, OAL_DEV_COUNT);
 613 out_oal_control_misc:
 614         misc_deregister(&oal_control_misc);
 615
 616         return rc;
 617 }
 618
 619 void ofd_access_log_module_exit(void)
 620 {
 621         class_destroy(oal_log_class);
 622         unregister_chrdev_region(MKDEV(oal_log_major, 0), OAL_DEV_COUNT);
 623         idr_destroy(&oal_log_minor_idr);
 624         misc_deregister(&oal_control_misc);
 625 }