Merge remote-tracking branch 'staging/staging-next'

diff --cc Documentation/devicetree/bindings/vendor-prefixes.txt
Simple merge

diff --cc MAINTAINERS
Simple merge

diff --cc drivers/dma-buf/sync_debug.c
index 0000000000000000000000000000000000000000,fab95204cf74ead77020695c201d322940fd6edf..2dd4c3db6caa83ceff101bb5405baea8c2ef4874
mode 000000,100644..100644
--- /dev/null
--- 2/drivers/dma-buf/sync_debug.c
+++ b/drivers/dma-buf/sync_debug.c
@@@ -1,0 -1,230 +1,236 @@@
 -                 sync_status_str(atomic_read(&sync_file->status)));
+ /*
+  * Sync File validation framework and debug information
+  *
+  * Copyright (C) 2012 Google, Inc.
+  *
+  * This software is licensed under the terms of the GNU General Public
+  * License version 2, as published by the Free Software Foundation, and
+  * may be copied, distributed, and modified under those terms.
+  *
+  * This program is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  */
+ 
+ #include <linux/debugfs.h>
+ #include "sync_debug.h"
+ 
+ static struct dentry *dbgfs;
+ 
+ static LIST_HEAD(sync_timeline_list_head);
+ static DEFINE_SPINLOCK(sync_timeline_list_lock);
+ static LIST_HEAD(sync_file_list_head);
+ static DEFINE_SPINLOCK(sync_file_list_lock);
+ 
+ void sync_timeline_debug_add(struct sync_timeline *obj)
+ {
+       unsigned long flags;
+ 
+       spin_lock_irqsave(&sync_timeline_list_lock, flags);
+       list_add_tail(&obj->sync_timeline_list, &sync_timeline_list_head);
+       spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
+ }
+ 
+ void sync_timeline_debug_remove(struct sync_timeline *obj)
+ {
+       unsigned long flags;
+ 
+       spin_lock_irqsave(&sync_timeline_list_lock, flags);
+       list_del(&obj->sync_timeline_list);
+       spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
+ }
+ 
+ void sync_file_debug_add(struct sync_file *sync_file)
+ {
+       unsigned long flags;
+ 
+       spin_lock_irqsave(&sync_file_list_lock, flags);
+       list_add_tail(&sync_file->sync_file_list, &sync_file_list_head);
+       spin_unlock_irqrestore(&sync_file_list_lock, flags);
+ }
+ 
+ void sync_file_debug_remove(struct sync_file *sync_file)
+ {
+       unsigned long flags;
+ 
+       spin_lock_irqsave(&sync_file_list_lock, flags);
+       list_del(&sync_file->sync_file_list);
+       spin_unlock_irqrestore(&sync_file_list_lock, flags);
+ }
+ 
+ static const char *sync_status_str(int status)
+ {
+       if (status == 0)
+               return "signaled";
+ 
+       if (status > 0)
+               return "active";
+ 
+       return "error";
+ }
+ 
+ static void sync_print_fence(struct seq_file *s, struct fence *fence, bool show)
+ {
+       int status = 1;
+       struct sync_timeline *parent = fence_parent(fence);
+ 
+       if (fence_is_signaled_locked(fence))
+               status = fence->status;
+ 
+       seq_printf(s, "  %s%sfence %s",
+                  show ? parent->name : "",
+                  show ? "_" : "",
+                  sync_status_str(status));
+ 
+       if (status <= 0) {
+               struct timespec64 ts64 =
+                       ktime_to_timespec64(fence->timestamp);
+ 
+               seq_printf(s, "@%lld.%09ld", (s64)ts64.tv_sec, ts64.tv_nsec);
+       }
+ 
+       if (fence->ops->timeline_value_str &&
+               fence->ops->fence_value_str) {
+               char value[64];
+               bool success;
+ 
+               fence->ops->fence_value_str(fence, value, sizeof(value));
+               success = strlen(value);
+ 
+               if (success) {
+                       seq_printf(s, ": %s", value);
+ 
+                       fence->ops->timeline_value_str(fence, value,
+                                                      sizeof(value));
+ 
+                       if (strlen(value))
+                               seq_printf(s, " / %s", value);
+               }
+       }
+ 
+       seq_puts(s, "\n");
+ }
+ 
+ static void sync_print_obj(struct seq_file *s, struct sync_timeline *obj)
+ {
+       struct list_head *pos;
+       unsigned long flags;
+ 
+       seq_printf(s, "%s: %d\n", obj->name, obj->value);
+ 
+       spin_lock_irqsave(&obj->child_list_lock, flags);
+       list_for_each(pos, &obj->child_list_head) {
+               struct sync_pt *pt =
+                       container_of(pos, struct sync_pt, child_list);
+               sync_print_fence(s, &pt->base, false);
+       }
+       spin_unlock_irqrestore(&obj->child_list_lock, flags);
+ }
+ 
+ static void sync_print_sync_file(struct seq_file *s,
+                                 struct sync_file *sync_file)
+ {
+       int i;
+ 
+       seq_printf(s, "[%p] %s: %s\n", sync_file, sync_file->name,
 -      for (i = 0; i < sync_file->num_fences; ++i)
 -              sync_print_fence(s, sync_file->cbs[i].fence, true);
++                 sync_status_str(!fence_is_signaled(sync_file->fence)));
+ 
++      if (fence_is_array(sync_file->fence)) {
++              struct fence_array *array = to_fence_array(sync_file->fence);
++
++              for (i = 0; i < array->num_fences; ++i)
++                      sync_print_fence(s, array->fences[i], true);
++      } else {
++              sync_print_fence(s, sync_file->fence, true);
++      }
+ }
+ 
+ static int sync_debugfs_show(struct seq_file *s, void *unused)
+ {
+       unsigned long flags;
+       struct list_head *pos;
+ 
+       seq_puts(s, "objs:\n--------------\n");
+ 
+       spin_lock_irqsave(&sync_timeline_list_lock, flags);
+       list_for_each(pos, &sync_timeline_list_head) {
+               struct sync_timeline *obj =
+                       container_of(pos, struct sync_timeline,
+                                    sync_timeline_list);
+ 
+               sync_print_obj(s, obj);
+               seq_puts(s, "\n");
+       }
+       spin_unlock_irqrestore(&sync_timeline_list_lock, flags);
+ 
+       seq_puts(s, "fences:\n--------------\n");
+ 
+       spin_lock_irqsave(&sync_file_list_lock, flags);
+       list_for_each(pos, &sync_file_list_head) {
+               struct sync_file *sync_file =
+                       container_of(pos, struct sync_file, sync_file_list);
+ 
+               sync_print_sync_file(s, sync_file);
+               seq_puts(s, "\n");
+       }
+       spin_unlock_irqrestore(&sync_file_list_lock, flags);
+       return 0;
+ }
+ 
+ static int sync_info_debugfs_open(struct inode *inode, struct file *file)
+ {
+       return single_open(file, sync_debugfs_show, inode->i_private);
+ }
+ 
+ static const struct file_operations sync_info_debugfs_fops = {
+       .open           = sync_info_debugfs_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+ };
+ 
+ static __init int sync_debugfs_init(void)
+ {
+       dbgfs = debugfs_create_dir("sync", NULL);
+ 
+       /*
+        * The debugfs files won't ever get removed and thus, there is
+        * no need to protect it against removal races. The use of
+        * debugfs_create_file_unsafe() is actually safe here.
+        */
+       debugfs_create_file_unsafe("info", 0444, dbgfs, NULL,
+                                  &sync_info_debugfs_fops);
+       debugfs_create_file_unsafe("sw_sync", 0644, dbgfs, NULL,
+                                  &sw_sync_debugfs_fops);
+ 
+       return 0;
+ }
+ late_initcall(sync_debugfs_init);
+ 
+ #define DUMP_CHUNK 256
+ static char sync_dump_buf[64 * 1024];
+ void sync_dump(void)
+ {
+       struct seq_file s = {
+               .buf = sync_dump_buf,
+               .size = sizeof(sync_dump_buf) - 1,
+       };
+       int i;
+ 
+       sync_debugfs_show(&s, NULL);
+ 
+       for (i = 0; i < s.count; i += DUMP_CHUNK) {
+               if ((s.count - i) > DUMP_CHUNK) {
+                       char c = s.buf[i + DUMP_CHUNK];
+ 
+                       s.buf[i + DUMP_CHUNK] = 0;
+                       pr_cont("%s", s.buf + i);
+                       s.buf[i + DUMP_CHUNK] = c;
+               } else {
+                       s.buf[s.count] = 0;
+                       pr_cont("%s", s.buf + i);
+               }
+       }
+ }

diff --cc drivers/staging/lustre/lustre/llite/file.c
Simple merge

diff --cc drivers/staging/lustre/lustre/llite/namei.c
Simple merge