OSCL-LXR linux-6.0.1/​drivers/​acpi/​acpi_dbg.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * ACPI AML interfacing support
  *
  * Copyright (C) 2015, Intel Corporation
  * Authors: Lv Zheng <lv.zheng@intel.com>
  */
 
 /* #define DEBUG */
 #define pr_fmt(fmt) "ACPI: AML: " fmt
 
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/wait.h>
 #include <linux/poll.h>
 #include <linux/sched.h>
 #include <linux/kthread.h>
 #include <linux/proc_fs.h>
 #include <linux/debugfs.h>
 #include <linux/circ_buf.h>
 #include <linux/acpi.h>
 #include "internal.h"
 
 #define ACPI_AML_BUF_ALIGN  (sizeof (acpi_size))
 #define ACPI_AML_BUF_SIZE   PAGE_SIZE
 
 #define circ_count(circ) \
     (CIRC_CNT((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
 #define circ_count_to_end(circ) \
     (CIRC_CNT_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
 #define circ_space(circ) \
     (CIRC_SPACE((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
 #define circ_space_to_end(circ) \
     (CIRC_SPACE_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
 
 #define ACPI_AML_OPENED     0x0001
 #define ACPI_AML_CLOSED     0x0002
 #define ACPI_AML_IN_USER    0x0004 /* user space is writing cmd */
 #define ACPI_AML_IN_KERN    0x0008 /* kernel space is reading cmd */
 #define ACPI_AML_OUT_USER   0x0010 /* user space is reading log */
 #define ACPI_AML_OUT_KERN   0x0020 /* kernel space is writing log */
 #define ACPI_AML_USER       (ACPI_AML_IN_USER | ACPI_AML_OUT_USER)
 #define ACPI_AML_KERN       (ACPI_AML_IN_KERN | ACPI_AML_OUT_KERN)
 #define ACPI_AML_BUSY       (ACPI_AML_USER | ACPI_AML_KERN)
 #define ACPI_AML_OPEN       (ACPI_AML_OPENED | ACPI_AML_CLOSED)
 
 struct acpi_aml_io {
     wait_queue_head_t wait;
     unsigned long flags;
     unsigned long users;
     struct mutex lock;
     struct task_struct *thread;
     char out_buf[ACPI_AML_BUF_SIZE] __aligned(ACPI_AML_BUF_ALIGN);
     struct circ_buf out_crc;
     char in_buf[ACPI_AML_BUF_SIZE] __aligned(ACPI_AML_BUF_ALIGN);
     struct circ_buf in_crc;
     acpi_osd_exec_callback function;
     void *context;
     unsigned long usages;
 };
 
 static struct acpi_aml_io acpi_aml_io;
 static bool acpi_aml_initialized;
 static struct file *acpi_aml_active_reader;
 static struct dentry *acpi_aml_dentry;
 
 static inline bool __acpi_aml_running(void)
 {
     return acpi_aml_io.thread ? true : false;
 }
 
 static inline bool __acpi_aml_access_ok(unsigned long flag)
 {
     /*
      * The debugger interface is in opened state (OPENED && !CLOSED),
      * then it is allowed to access the debugger buffers from either
      * user space or the kernel space.
      * In addition, for the kernel space, only the debugger thread
      * (thread ID matched) is allowed to access.
      */
     if (!(acpi_aml_io.flags & ACPI_AML_OPENED) ||
         (acpi_aml_io.flags & ACPI_AML_CLOSED) ||
         !__acpi_aml_running())
         return false;
     if ((flag & ACPI_AML_KERN) &&
         current != acpi_aml_io.thread)
         return false;
     return true;
 }
 
 static inline bool __acpi_aml_readable(struct circ_buf *circ, unsigned long flag)
 {
     /*
      * Another read is not in progress and there is data in buffer
      * available for read.
      */
     if (!(acpi_aml_io.flags & flag) && circ_count(circ))
         return true;
     return false;
 }
 
 static inline bool __acpi_aml_writable(struct circ_buf *circ, unsigned long flag)
 {
     /*
      * Another write is not in progress and there is buffer space
      * available for write.
      */
     if (!(acpi_aml_io.flags & flag) && circ_space(circ))
         return true;
     return false;
 }
 
 static inline bool __acpi_aml_busy(void)
 {
     if (acpi_aml_io.flags & ACPI_AML_BUSY)
         return true;
     return false;
 }
 
 static inline bool __acpi_aml_used(void)
 {
     return acpi_aml_io.usages ? true : false;
 }
 
 static inline bool acpi_aml_running(void)
 {
     bool ret;
 
     mutex_lock(&acpi_aml_io.lock);
     ret = __acpi_aml_running();
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static bool acpi_aml_busy(void)
 {
     bool ret;
 
     mutex_lock(&acpi_aml_io.lock);
     ret = __acpi_aml_busy();
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static bool acpi_aml_used(void)
 {
     bool ret;
 
     /*
      * The usage count is prepared to avoid race conditions between the
      * starts and the stops of the debugger thread.
      */
     mutex_lock(&acpi_aml_io.lock);
     ret = __acpi_aml_used();
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static bool acpi_aml_kern_readable(void)
 {
     bool ret;
 
     mutex_lock(&acpi_aml_io.lock);
     ret = !__acpi_aml_access_ok(ACPI_AML_IN_KERN) ||
           __acpi_aml_readable(&acpi_aml_io.in_crc, ACPI_AML_IN_KERN);
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static bool acpi_aml_kern_writable(void)
 {
     bool ret;
 
     mutex_lock(&acpi_aml_io.lock);
     ret = !__acpi_aml_access_ok(ACPI_AML_OUT_KERN) ||
           __acpi_aml_writable(&acpi_aml_io.out_crc, ACPI_AML_OUT_KERN);
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static bool acpi_aml_user_readable(void)
 {
     bool ret;
 
     mutex_lock(&acpi_aml_io.lock);
     ret = !__acpi_aml_access_ok(ACPI_AML_OUT_USER) ||
           __acpi_aml_readable(&acpi_aml_io.out_crc, ACPI_AML_OUT_USER);
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static bool acpi_aml_user_writable(void)
 {
     bool ret;
 
     mutex_lock(&acpi_aml_io.lock);
     ret = !__acpi_aml_access_ok(ACPI_AML_IN_USER) ||
           __acpi_aml_writable(&acpi_aml_io.in_crc, ACPI_AML_IN_USER);
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static int acpi_aml_lock_write(struct circ_buf *circ, unsigned long flag)
 {
     int ret = 0;
 
     mutex_lock(&acpi_aml_io.lock);
     if (!__acpi_aml_access_ok(flag)) {
         ret = -EFAULT;
         goto out;
     }
     if (!__acpi_aml_writable(circ, flag)) {
         ret = -EAGAIN;
         goto out;
     }
     acpi_aml_io.flags |= flag;
 out:
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static int acpi_aml_lock_read(struct circ_buf *circ, unsigned long flag)
 {
     int ret = 0;
 
     mutex_lock(&acpi_aml_io.lock);
     if (!__acpi_aml_access_ok(flag)) {
         ret = -EFAULT;
         goto out;
     }
     if (!__acpi_aml_readable(circ, flag)) {
         ret = -EAGAIN;
         goto out;
     }
     acpi_aml_io.flags |= flag;
 out:
     mutex_unlock(&acpi_aml_io.lock);
     return ret;
 }
 
 static void acpi_aml_unlock_fifo(unsigned long flag, bool wakeup)
 {
     mutex_lock(&acpi_aml_io.lock);
     acpi_aml_io.flags &= ~flag;
     if (wakeup)
         wake_up_interruptible(&acpi_aml_io.wait);
     mutex_unlock(&acpi_aml_io.lock);
 }
 
 static int acpi_aml_write_kern(const char *buf, int len)
 {
     int ret;
     struct circ_buf *crc = &acpi_aml_io.out_crc;
     int n;
     char *p;
 
     ret = acpi_aml_lock_write(crc, ACPI_AML_OUT_KERN);
     if (ret < 0)
         return ret;
     /* sync tail before inserting logs */
     smp_mb();
     p = &crc->buf[crc->head];
     n = min(len, circ_space_to_end(crc));
     memcpy(p, buf, n);
     /* sync head after inserting logs */
     smp_wmb();
     crc->head = (crc->head + n) & (ACPI_AML_BUF_SIZE - 1);
     acpi_aml_unlock_fifo(ACPI_AML_OUT_KERN, true);
     return n;
 }
 
 static int acpi_aml_readb_kern(void)
 {
     int ret;
     struct circ_buf *crc = &acpi_aml_io.in_crc;
     char *p;
 
     ret = acpi_aml_lock_read(crc, ACPI_AML_IN_KERN);
     if (ret < 0)
         return ret;
     /* sync head before removing cmds */
     smp_rmb();
     p = &crc->buf[crc->tail];
     ret = (int)*p;
     /* sync tail before inserting cmds */
     smp_mb();
     crc->tail = (crc->tail + 1) & (ACPI_AML_BUF_SIZE - 1);
     acpi_aml_unlock_fifo(ACPI_AML_IN_KERN, true);
     return ret;
 }
 
 /*
  * acpi_aml_write_log() - Capture debugger output
  * @msg: the debugger output
  *
  * This function should be used to implement acpi_os_printf() to filter out
  * the debugger output and store the output into the debugger interface
  * buffer. Return the size of stored logs or errno.
  */
 static ssize_t acpi_aml_write_log(const char *msg)
 {
     int ret = 0;
     int count = 0, size = 0;
 
     if (!acpi_aml_initialized)
         return -ENODEV;
     if (msg)
         count = strlen(msg);
     while (count > 0) {
 again:
         ret = acpi_aml_write_kern(msg + size, count);
         if (ret == -EAGAIN) {
             ret = wait_event_interruptible(acpi_aml_io.wait,
                 acpi_aml_kern_writable());
             /*
              * We need to retry when the condition
              * becomes true.
              */
             if (ret == 0)
                 goto again;
             break;
         }
         if (ret < 0)
             break;
         size += ret;
         count -= ret;
     }
     return size > 0 ? size : ret;
 }
 
 /*
  * acpi_aml_read_cmd() - Capture debugger input
  * @msg: the debugger input
  * @size: the size of the debugger input
  *
  * This function should be used to implement acpi_os_get_line() to capture
  * the debugger input commands and store the input commands into the
  * debugger interface buffer. Return the size of stored commands or errno.
  */
 static ssize_t acpi_aml_read_cmd(char *msg, size_t count)
 {
     int ret = 0;
     int size = 0;
 
     /*
      * This is ensured by the running fact of the debugger thread
      * unless a bug is introduced.
      */
     BUG_ON(!acpi_aml_initialized);
     while (count > 0) {
 again:
         /*
          * Check each input byte to find the end of the command.
          */
         ret = acpi_aml_readb_kern();
         if (ret == -EAGAIN) {
             ret = wait_event_interruptible(acpi_aml_io.wait,
                 acpi_aml_kern_readable());
             /*
              * We need to retry when the condition becomes
              * true.
              */
             if (ret == 0)
                 goto again;
         }
         if (ret < 0)
             break;
         *(msg + size) = (char)ret;
         size++;
         count--;
         if (ret == '\n') {
             /*
              * acpi_os_get_line() requires a zero terminated command
              * string.
              */
             *(msg + size - 1) = '\0';
             break;
         }
     }
     return size > 0 ? size : ret;
 }
 
 static int acpi_aml_thread(void *unused)
 {
     acpi_osd_exec_callback function = NULL;
     void *context;
 
     mutex_lock(&acpi_aml_io.lock);
     if (acpi_aml_io.function) {
         acpi_aml_io.usages++;
         function = acpi_aml_io.function;
         context = acpi_aml_io.context;
     }
     mutex_unlock(&acpi_aml_io.lock);
 
     if (function)
         function(context);
 
     mutex_lock(&acpi_aml_io.lock);
     acpi_aml_io.usages--;
     if (!__acpi_aml_used()) {
         acpi_aml_io.thread = NULL;
         wake_up(&acpi_aml_io.wait);
     }
     mutex_unlock(&acpi_aml_io.lock);
 
     return 0;
 }
 
 /*
  * acpi_aml_create_thread() - Create AML debugger thread
  * @function: the debugger thread callback
  * @context: the context to be passed to the debugger thread
  *
  * This function should be used to implement acpi_os_execute() which is
  * used by the ACPICA debugger to create the debugger thread.
  */
 static int acpi_aml_create_thread(acpi_osd_exec_callback function, void *context)
 {
     struct task_struct *t;
 
     mutex_lock(&acpi_aml_io.lock);
     acpi_aml_io.function = function;
     acpi_aml_io.context = context;
     mutex_unlock(&acpi_aml_io.lock);
 
     t = kthread_create(acpi_aml_thread, NULL, "aml");
     if (IS_ERR(t)) {
         pr_err("Failed to create AML debugger thread.\n");
         return PTR_ERR(t);
     }
 
     mutex_lock(&acpi_aml_io.lock);
     acpi_aml_io.thread = t;
     acpi_set_debugger_thread_id((acpi_thread_id)(unsigned long)t);
     wake_up_process(t);
     mutex_unlock(&acpi_aml_io.lock);
     return 0;
 }
 
 static int acpi_aml_wait_command_ready(bool single_step,
                        char *buffer, size_t length)
 {
     acpi_status status;
 
     if (single_step)
         acpi_os_printf("\n%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT);
     else
         acpi_os_printf("\n%1c ", ACPI_DEBUGGER_COMMAND_PROMPT);
 
     status = acpi_os_get_line(buffer, length, NULL);
     if (ACPI_FAILURE(status))
         return -EINVAL;
     return 0;
 }
 
 static int acpi_aml_notify_command_complete(void)
 {
     return 0;
 }
 
 static int acpi_aml_open(struct inode *inode, struct file *file)
 {
     int ret = 0;
     acpi_status status;
 
     mutex_lock(&acpi_aml_io.lock);
     /*
      * The debugger interface is being closed, no new user is allowed
      * during this period.
      */
     if (acpi_aml_io.flags & ACPI_AML_CLOSED) {
         ret = -EBUSY;
         goto err_lock;
     }
     if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
         /*
          * Only one reader is allowed to initiate the debugger
          * thread.
          */
         if (acpi_aml_active_reader) {
             ret = -EBUSY;
             goto err_lock;
         } else {
             pr_debug("Opening debugger reader.\n");
             acpi_aml_active_reader = file;
         }
     } else {
         /*
          * No writer is allowed unless the debugger thread is
          * ready.
          */
         if (!(acpi_aml_io.flags & ACPI_AML_OPENED)) {
             ret = -ENODEV;
             goto err_lock;
         }
     }
     if (acpi_aml_active_reader == file) {
         pr_debug("Opening debugger interface.\n");
         mutex_unlock(&acpi_aml_io.lock);
 
         pr_debug("Initializing debugger thread.\n");
         status = acpi_initialize_debugger();
         if (ACPI_FAILURE(status)) {
             pr_err("Failed to initialize debugger.\n");
             ret = -EINVAL;
             goto err_exit;
         }
         pr_debug("Debugger thread initialized.\n");
 
         mutex_lock(&acpi_aml_io.lock);
         acpi_aml_io.flags |= ACPI_AML_OPENED;
         acpi_aml_io.out_crc.head = acpi_aml_io.out_crc.tail = 0;
         acpi_aml_io.in_crc.head = acpi_aml_io.in_crc.tail = 0;
         pr_debug("Debugger interface opened.\n");
     }
     acpi_aml_io.users++;
 err_lock:
     if (ret < 0) {
         if (acpi_aml_active_reader == file)
             acpi_aml_active_reader = NULL;
     }
     mutex_unlock(&acpi_aml_io.lock);
 err_exit:
     return ret;
 }
 
 static int acpi_aml_release(struct inode *inode, struct file *file)
 {
     mutex_lock(&acpi_aml_io.lock);
     acpi_aml_io.users--;
     if (file == acpi_aml_active_reader) {
         pr_debug("Closing debugger reader.\n");
         acpi_aml_active_reader = NULL;
 
         pr_debug("Closing debugger interface.\n");
         acpi_aml_io.flags |= ACPI_AML_CLOSED;
 
         /*
          * Wake up all user space/kernel space blocked
          * readers/writers.
          */
         wake_up_interruptible(&acpi_aml_io.wait);
         mutex_unlock(&acpi_aml_io.lock);
         /*
          * Wait all user space/kernel space readers/writers to
          * stop so that ACPICA command loop of the debugger thread
          * should fail all its command line reads after this point.
          */
         wait_event(acpi_aml_io.wait, !acpi_aml_busy());
 
         /*
          * Then we try to terminate the debugger thread if it is
          * not terminated.
          */
         pr_debug("Terminating debugger thread.\n");
         acpi_terminate_debugger();
         wait_event(acpi_aml_io.wait, !acpi_aml_used());
         pr_debug("Debugger thread terminated.\n");
 
         mutex_lock(&acpi_aml_io.lock);
         acpi_aml_io.flags &= ~ACPI_AML_OPENED;
     }
     if (acpi_aml_io.users == 0) {
         pr_debug("Debugger interface closed.\n");
         acpi_aml_io.flags &= ~ACPI_AML_CLOSED;
     }
     mutex_unlock(&acpi_aml_io.lock);
     return 0;
 }
 
 static int acpi_aml_read_user(char __user *buf, int len)
 {
     int ret;
     struct circ_buf *crc = &acpi_aml_io.out_crc;
     int n;
     char *p;
 
     ret = acpi_aml_lock_read(crc, ACPI_AML_OUT_USER);
     if (ret < 0)
         return ret;
     /* sync head before removing logs */
     smp_rmb();
     p = &crc->buf[crc->tail];
     n = min(len, circ_count_to_end(crc));
     if (copy_to_user(buf, p, n)) {
         ret = -EFAULT;
         goto out;
     }
     /* sync tail after removing logs */
     smp_mb();
     crc->tail = (crc->tail + n) & (ACPI_AML_BUF_SIZE - 1);
     ret = n;
 out:
     acpi_aml_unlock_fifo(ACPI_AML_OUT_USER, ret >= 0);
     return ret;
 }
 
 static ssize_t acpi_aml_read(struct file *file, char __user *buf,
                  size_t count, loff_t *ppos)
 {
     int ret = 0;
     int size = 0;
 
     if (!count)
         return 0;
     if (!access_ok(buf, count))
         return -EFAULT;
 
     while (count > 0) {
 again:
         ret = acpi_aml_read_user(buf + size, count);
         if (ret == -EAGAIN) {
             if (file->f_flags & O_NONBLOCK)
                 break;
             else {
                 ret = wait_event_interruptible(acpi_aml_io.wait,
                     acpi_aml_user_readable());
                 /*
                  * We need to retry when the condition
                  * becomes true.
                  */
                 if (ret == 0)
                     goto again;
             }
         }
         if (ret < 0) {
             if (!acpi_aml_running())
                 ret = 0;
             break;
         }
         if (ret) {
             size += ret;
             count -= ret;
             *ppos += ret;
             break;
         }
     }
     return size > 0 ? size : ret;
 }
 
 static int acpi_aml_write_user(const char __user *buf, int len)
 {
     int ret;
     struct circ_buf *crc = &acpi_aml_io.in_crc;
     int n;
     char *p;
 
     ret = acpi_aml_lock_write(crc, ACPI_AML_IN_USER);
     if (ret < 0)
         return ret;
     /* sync tail before inserting cmds */
     smp_mb();
     p = &crc->buf[crc->head];
     n = min(len, circ_space_to_end(crc));
     if (copy_from_user(p, buf, n)) {
         ret = -EFAULT;
         goto out;
     }
     /* sync head after inserting cmds */
     smp_wmb();
     crc->head = (crc->head + n) & (ACPI_AML_BUF_SIZE - 1);
     ret = n;
 out:
     acpi_aml_unlock_fifo(ACPI_AML_IN_USER, ret >= 0);
     return n;
 }
 
 static ssize_t acpi_aml_write(struct file *file, const char __user *buf,
                   size_t count, loff_t *ppos)
 {
     int ret = 0;
     int size = 0;
 
     if (!count)
         return 0;
     if (!access_ok(buf, count))
         return -EFAULT;
 
     while (count > 0) {
 again:
         ret = acpi_aml_write_user(buf + size, count);
         if (ret == -EAGAIN) {
             if (file->f_flags & O_NONBLOCK)
                 break;
             else {
                 ret = wait_event_interruptible(acpi_aml_io.wait,
                     acpi_aml_user_writable());
                 /*
                  * We need to retry when the condition
                  * becomes true.
                  */
                 if (ret == 0)
                     goto again;
             }
         }
         if (ret < 0) {
             if (!acpi_aml_running())
                 ret = 0;
             break;
         }
         if (ret) {
             size += ret;
             count -= ret;
             *ppos += ret;
         }
     }
     return size > 0 ? size : ret;
 }
 
 static __poll_t acpi_aml_poll(struct file *file, poll_table *wait)
 {
     __poll_t masks = 0;
 
     poll_wait(file, &acpi_aml_io.wait, wait);
     if (acpi_aml_user_readable())
         masks |= EPOLLIN | EPOLLRDNORM;
     if (acpi_aml_user_writable())
         masks |= EPOLLOUT | EPOLLWRNORM;
 
     return masks;
 }
 
 static const struct file_operations acpi_aml_operations = {
     .read       = acpi_aml_read,
     .write      = acpi_aml_write,
     .poll       = acpi_aml_poll,
     .open       = acpi_aml_open,
     .release    = acpi_aml_release,
     .llseek     = generic_file_llseek,
 };
 
 static const struct acpi_debugger_ops acpi_aml_debugger = {
     .create_thread       = acpi_aml_create_thread,
     .read_cmd        = acpi_aml_read_cmd,
     .write_log       = acpi_aml_write_log,
     .wait_command_ready  = acpi_aml_wait_command_ready,
     .notify_command_complete = acpi_aml_notify_command_complete,
 };
 
 static int __init acpi_aml_init(void)
 {
     int ret;
 
     if (acpi_disabled)
         return -ENODEV;
 
     /* Initialize AML IO interface */
     mutex_init(&acpi_aml_io.lock);
     init_waitqueue_head(&acpi_aml_io.wait);
     acpi_aml_io.out_crc.buf = acpi_aml_io.out_buf;
     acpi_aml_io.in_crc.buf = acpi_aml_io.in_buf;
 
     acpi_aml_dentry = debugfs_create_file("acpidbg",
                           S_IFREG | S_IRUGO | S_IWUSR,
                           acpi_debugfs_dir, NULL,
                           &acpi_aml_operations);
 
     ret = acpi_register_debugger(THIS_MODULE, &acpi_aml_debugger);
     if (ret) {
         debugfs_remove(acpi_aml_dentry);
         acpi_aml_dentry = NULL;
         return ret;
     }
 
     acpi_aml_initialized = true;
     return 0;
 }
 
 static void __exit acpi_aml_exit(void)
 {
     if (acpi_aml_initialized) {
         acpi_unregister_debugger(&acpi_aml_debugger);
         debugfs_remove(acpi_aml_dentry);
         acpi_aml_dentry = NULL;
         acpi_aml_initialized = false;
     }
 }
 
 module_init(acpi_aml_init);
 module_exit(acpi_aml_exit);
 
 MODULE_AUTHOR("Lv Zheng");
 MODULE_DESCRIPTION("ACPI debugger userspace IO driver");
 MODULE_LICENSE("GPL");

This page was automatically generated by the 2.1.0 LXR engine. The LXR team