Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

Pull SCSI target updates from Nicholas Bellinger:
 "This series contains HCH's changes to absorb configfs attribute
  ->show() + ->store() function pointer usage from it's original
  tree-wide consumers, into common configfs code.

  It includes usb-gadget, target w/ drivers, netconsole and ocfs2
  changes to realize the improved simplicity, that now renders the
  original include/target/configfs_macros.h CPP magic for fabric drivers
  and others, unnecessary and obsolete.

  And with common code in place, new configfs attributes can be added
  easier than ever before.

  Note, there are further improvements in-flight from other folks for
  v4.5 code in configfs land, plus number of target fixes for post -rc1
  code"

In the meantime, a new user of the now-removed old configfs API came in
through the char/misc tree in commit 7bd1d4093c2f ("stm class: Introduce
an abstraction for System Trace Module devices").

This merge resolution comes from Alexander Shishkin, who updated his stm
class tracing abstraction to account for the removal of the old
show_attribute and store_attribute methods in commit 517982229f78
("configfs: remove old API") from this pull.  As Alexander says about
that patch:

 "There's no need to keep an extra wrapper structure per item and the
  awkward show_attribute/store_attribute item ops are no longer needed.

  This patch converts policy code to the new api, all the while making
  the code quite a bit smaller and easier on the eyes.

  Signed-off-by: Alexander Shishkin <alexander.shishkin@linux.intel.com>"

That patch was folded into the merge so that the tree should be fully
bisectable.

* 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending: (23 commits)
  configfs: remove old API
  ocfs2/cluster: use per-attribute show and store methods
  ocfs2/cluster: move locking into attribute store methods
  netconsole: use per-attribute show and store methods
  target: use per-attribute show and store methods
  spear13xx_pcie_gadget: use per-attribute show and store methods
  dlm: use per-attribute show and store methods
  usb-gadget/f_serial: use per-attribute show and store methods
  usb-gadget/f_phonet: use per-attribute show and store methods
  usb-gadget/f_obex: use per-attribute show and store methods
  usb-gadget/f_uac2: use per-attribute show and store methods
  usb-gadget/f_uac1: use per-attribute show and store methods
  usb-gadget/f_mass_storage: use per-attribute show and store methods
  usb-gadget/f_sourcesink: use per-attribute show and store methods
  usb-gadget/f_printer: use per-attribute show and store methods
  usb-gadget/f_midi: use per-attribute show and store methods
  usb-gadget/f_loopback: use per-attribute show and store methods
  usb-gadget/ether: use per-attribute show and store methods
  usb-gadget/f_acm: use per-attribute show and store methods
  usb-gadget/f_hid: use per-attribute show and store methods
  ...

1 files changed, 132 insertions, 139 deletions

diff --git a/drivers/net/netconsole.c b/drivers/net/netconsole.c
index 97f3acd44798..06ee6395117f 100644
--- a/drivers/net/netconsole.c
+++ b/drivers/net/netconsole.c
@@ -244,15 +244,6 @@ static void free_param_target(struct netconsole_target *nt)
  *                              <target>/...
  */
 
-struct netconsole_target_attr {
-        struct configfs_attribute       attr;
-        ssize_t                         (*show)(struct netconsole_target *nt,
-                                                char *buf);
-        ssize_t                         (*store)(struct netconsole_target *nt,
-                                                 const char *buf,
-                                                 size_t count);
-};
-
 static struct netconsole_target *to_target(struct config_item *item)
 {
         return item ?
@@ -264,58 +255,62 @@ static struct netconsole_target *to_target(struct config_item *item)
  * Attribute operations for netconsole_target.
  */
 
-static ssize_t show_enabled(struct netconsole_target *nt, char *buf)
+static ssize_t enabled_show(struct config_item *item, char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "%d\n", nt->enabled);
+        return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->enabled);
 }
 
-static ssize_t show_extended(struct netconsole_target *nt, char *buf)
+static ssize_t extended_show(struct config_item *item, char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "%d\n", nt->extended);
+        return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->extended);
 }
 
-static ssize_t show_dev_name(struct netconsole_target *nt, char *buf)
+static ssize_t dev_name_show(struct config_item *item, char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "%s\n", nt->np.dev_name);
+        return snprintf(buf, PAGE_SIZE, "%s\n", to_target(item)->np.dev_name);
 }
 
-static ssize_t show_local_port(struct netconsole_target *nt, char *buf)
+static ssize_t local_port_show(struct config_item *item, char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.local_port);
+        return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.local_port);
 }
 
-static ssize_t show_remote_port(struct netconsole_target *nt, char *buf)
+static ssize_t remote_port_show(struct config_item *item, char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "%d\n", nt->np.remote_port);
+        return snprintf(buf, PAGE_SIZE, "%d\n", to_target(item)->np.remote_port);
 }
 
-static ssize_t show_local_ip(struct netconsole_target *nt, char *buf)
+static ssize_t local_ip_show(struct config_item *item, char *buf)
 {
+        struct netconsole_target *nt = to_target(item);
+
         if (nt->np.ipv6)
                 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.local_ip.in6);
         else
                 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.local_ip);
 }
 
-static ssize_t show_remote_ip(struct netconsole_target *nt, char *buf)
+static ssize_t remote_ip_show(struct config_item *item, char *buf)
 {
+        struct netconsole_target *nt = to_target(item);
+
         if (nt->np.ipv6)
                 return snprintf(buf, PAGE_SIZE, "%pI6c\n", &nt->np.remote_ip.in6);
         else
                 return snprintf(buf, PAGE_SIZE, "%pI4\n", &nt->np.remote_ip);
 }
 
-static ssize_t show_local_mac(struct netconsole_target *nt, char *buf)
+static ssize_t local_mac_show(struct config_item *item, char *buf)
 {
-        struct net_device *dev = nt->np.dev;
+        struct net_device *dev = to_target(item)->np.dev;
         static const u8 bcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 
         return snprintf(buf, PAGE_SIZE, "%pM\n", dev ? dev->dev_addr : bcast);
 }
 
-static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
+static ssize_t remote_mac_show(struct config_item *item, char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "%pM\n", nt->np.remote_mac);
+        return snprintf(buf, PAGE_SIZE, "%pM\n", to_target(item)->np.remote_mac);
 }
 
 /*
@@ -325,23 +320,26 @@ static ssize_t show_remote_mac(struct netconsole_target *nt, char *buf)
  * would enable him to dynamically add new netpoll targets for new
  * network interfaces as and when they come up).
  */
-static ssize_t store_enabled(struct netconsole_target *nt,
-                             const char *buf,
-                             size_t count)
+static ssize_t enabled_store(struct config_item *item,
+                const char *buf, size_t count)
 {
+        struct netconsole_target *nt = to_target(item);
         unsigned long flags;
         int enabled;
         int err;
 
+        mutex_lock(&dynamic_netconsole_mutex);
         err = kstrtoint(buf, 10, &enabled);
         if (err < 0)
-                return err;
+                goto out_unlock;
+
+        err = -EINVAL;
         if (enabled < 0 || enabled > 1)
-                return -EINVAL;
+                goto out_unlock;
         if ((bool)enabled == nt->enabled) {
                 pr_info("network logging has already %s\n",
                         nt->enabled ? "started" : "stopped");
-                return -EINVAL;
+                goto out_unlock;
         }
 
         if (enabled) {  /* true */
@@ -358,7 +356,7 @@ static ssize_t store_enabled(struct netconsole_target *nt,
 
                 err = netpoll_setup(&nt->np);
                 if (err)
-                        return err;
+                        goto out_unlock;
 
                 pr_info("netconsole: network logging started\n");
         } else {        /* false */
@@ -374,42 +372,56 @@ static ssize_t store_enabled(struct netconsole_target *nt,
 
         nt->enabled = enabled;
 
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
+out_unlock:
+        mutex_unlock(&dynamic_netconsole_mutex);
+        return err;
 }
 
-static ssize_t store_extended(struct netconsole_target *nt,
-                              const char *buf,
-                              size_t count)
+static ssize_t extended_store(struct config_item *item, const char *buf,
+                size_t count)
 {
+        struct netconsole_target *nt = to_target(item);
         int extended;
         int err;
 
+        mutex_lock(&dynamic_netconsole_mutex);
         if (nt->enabled) {
                 pr_err("target (%s) is enabled, disable to update parameters\n",
                        config_item_name(&nt->item));
-                return -EINVAL;
+                err = -EINVAL;
+                goto out_unlock;
         }
 
         err = kstrtoint(buf, 10, &extended);
         if (err < 0)
-                return err;
-        if (extended < 0 || extended > 1)
-                return -EINVAL;
+                goto out_unlock;
+        if (extended < 0 || extended > 1) {
+                err = -EINVAL;
+                goto out_unlock;
+        }
 
         nt->extended = extended;
 
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
+out_unlock:
+        mutex_unlock(&dynamic_netconsole_mutex);
+        return err;
 }
 
-static ssize_t store_dev_name(struct netconsole_target *nt,
-                              const char *buf,
-                              size_t count)
+static ssize_t dev_name_store(struct config_item *item, const char *buf,
+                size_t count)
 {
+        struct netconsole_target *nt = to_target(item);
         size_t len;
 
+        mutex_lock(&dynamic_netconsole_mutex);
         if (nt->enabled) {
                 pr_err("target (%s) is enabled, disable to update parameters\n",
                        config_item_name(&nt->item));
+                mutex_unlock(&dynamic_netconsole_mutex);
                 return -EINVAL;
         }
 
@@ -420,53 +432,66 @@ static ssize_t store_dev_name(struct netconsole_target *nt,
         if (nt->np.dev_name[len - 1] == '\n')
                 nt->np.dev_name[len - 1] = '\0';
 
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
 }
 
-static ssize_t store_local_port(struct netconsole_target *nt,
-                                const char *buf,
-                                size_t count)
+static ssize_t local_port_store(struct config_item *item, const char *buf,
+                size_t count)
 {
-        int rv;
+        struct netconsole_target *nt = to_target(item);
+        int rv = -EINVAL;
 
+        mutex_lock(&dynamic_netconsole_mutex);
         if (nt->enabled) {
                 pr_err("target (%s) is enabled, disable to update parameters\n",
                        config_item_name(&nt->item));
-                return -EINVAL;
+                goto out_unlock;
         }
 
         rv = kstrtou16(buf, 10, &nt->np.local_port);
         if (rv < 0)
-                return rv;
+                goto out_unlock;
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
+out_unlock:
+        mutex_unlock(&dynamic_netconsole_mutex);
+        return rv;
 }
 
-static ssize_t store_remote_port(struct netconsole_target *nt,
-                                 const char *buf,
-                                 size_t count)
+static ssize_t remote_port_store(struct config_item *item,
+                const char *buf, size_t count)
 {
-        int rv;
+        struct netconsole_target *nt = to_target(item);
+        int rv = -EINVAL;
 
+        mutex_lock(&dynamic_netconsole_mutex);
         if (nt->enabled) {
                 pr_err("target (%s) is enabled, disable to update parameters\n",
                        config_item_name(&nt->item));
-                return -EINVAL;
+                goto out_unlock;
         }
 
         rv = kstrtou16(buf, 10, &nt->np.remote_port);
         if (rv < 0)
-                return rv;
+                goto out_unlock;
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
+out_unlock:
+        mutex_unlock(&dynamic_netconsole_mutex);
+        return rv;
 }
 
-static ssize_t store_local_ip(struct netconsole_target *nt,
-                              const char *buf,
-                              size_t count)
+static ssize_t local_ip_store(struct config_item *item, const char *buf,
+                size_t count)
 {
+        struct netconsole_target *nt = to_target(item);
+
+        mutex_lock(&dynamic_netconsole_mutex);
         if (nt->enabled) {
                 pr_err("target (%s) is enabled, disable to update parameters\n",
                        config_item_name(&nt->item));
-                return -EINVAL;
+                goto out_unlock;
         }
 
         if (strnchr(buf, count, ':')) {
@@ -474,29 +499,35 @@ static ssize_t store_local_ip(struct netconsole_target *nt,
                 if (in6_pton(buf, count, nt->np.local_ip.in6.s6_addr, -1, &end) > 0) {
                         if (*end && *end != '\n') {
                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
-                                return -EINVAL;
+                                goto out_unlock;
                         }
                         nt->np.ipv6 = true;
                 } else
-                        return -EINVAL;
+                        goto out_unlock;
         } else {
                 if (!nt->np.ipv6) {
                         nt->np.local_ip.ip = in_aton(buf);
                 } else
-                        return -EINVAL;
+                        goto out_unlock;
         }
 
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
+out_unlock:
+        mutex_unlock(&dynamic_netconsole_mutex);
+        return -EINVAL;
 }
 
-static ssize_t store_remote_ip(struct netconsole_target *nt,
-                               const char *buf,
-                               size_t count)
+static ssize_t remote_ip_store(struct config_item *item, const char *buf,
+               size_t count)
 {
+        struct netconsole_target *nt = to_target(item);
+
+        mutex_lock(&dynamic_netconsole_mutex);
         if (nt->enabled) {
                 pr_err("target (%s) is enabled, disable to update parameters\n",
                        config_item_name(&nt->item));
-                return -EINVAL;
+                goto out_unlock;
         }
 
         if (strnchr(buf, count, ':')) {
@@ -504,74 +535,71 @@ static ssize_t store_remote_ip(struct netconsole_target *nt,
                 if (in6_pton(buf, count, nt->np.remote_ip.in6.s6_addr, -1, &end) > 0) {
                         if (*end && *end != '\n') {
                                 pr_err("invalid IPv6 address at: <%c>\n", *end);
-                                return -EINVAL;
+                                goto out_unlock;
                         }
                         nt->np.ipv6 = true;
                 } else
-                        return -EINVAL;
+                        goto out_unlock;
         } else {
                 if (!nt->np.ipv6) {
                         nt->np.remote_ip.ip = in_aton(buf);
                 } else
-                        return -EINVAL;
+                        goto out_unlock;
         }
 
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
+out_unlock:
+        mutex_unlock(&dynamic_netconsole_mutex);
+        return -EINVAL;
 }
 
-static ssize_t store_remote_mac(struct netconsole_target *nt,
-                                const char *buf,
-                                size_t count)
+static ssize_t remote_mac_store(struct config_item *item, const char *buf,
+                size_t count)
 {
+        struct netconsole_target *nt = to_target(item);
         u8 remote_mac[ETH_ALEN];
 
+        mutex_lock(&dynamic_netconsole_mutex);
         if (nt->enabled) {
                 pr_err("target (%s) is enabled, disable to update parameters\n",
                        config_item_name(&nt->item));
-                return -EINVAL;
+                goto out_unlock;
         }
 
         if (!mac_pton(buf, remote_mac))
-                return -EINVAL;
+                goto out_unlock;
         if (buf[3 * ETH_ALEN - 1] && buf[3 * ETH_ALEN - 1] != '\n')
-                return -EINVAL;
+                goto out_unlock;
         memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
 
+        mutex_unlock(&dynamic_netconsole_mutex);
         return strnlen(buf, count);
+out_unlock:
+        mutex_unlock(&dynamic_netconsole_mutex);
+        return -EINVAL;
 }
 
-/*
- * Attribute definitions for netconsole_target.
- */
-
-#define NETCONSOLE_TARGET_ATTR_RO(_name)                                \
-static struct netconsole_target_attr netconsole_target_##_name =        \
-        __CONFIGFS_ATTR(_name, S_IRUGO, show_##_name, NULL)
-
-#define NETCONSOLE_TARGET_ATTR_RW(_name)                                \
-static struct netconsole_target_attr netconsole_target_##_name =        \
-        __CONFIGFS_ATTR(_name, S_IRUGO | S_IWUSR, show_##_name, store_##_name)
-
-NETCONSOLE_TARGET_ATTR_RW(enabled);
-NETCONSOLE_TARGET_ATTR_RW(extended);
-NETCONSOLE_TARGET_ATTR_RW(dev_name);
-NETCONSOLE_TARGET_ATTR_RW(local_port);
-NETCONSOLE_TARGET_ATTR_RW(remote_port);
-NETCONSOLE_TARGET_ATTR_RW(local_ip);
-NETCONSOLE_TARGET_ATTR_RW(remote_ip);
-NETCONSOLE_TARGET_ATTR_RO(local_mac);
-NETCONSOLE_TARGET_ATTR_RW(remote_mac);
+CONFIGFS_ATTR(, enabled);
+CONFIGFS_ATTR(, extended);
+CONFIGFS_ATTR(, dev_name);
+CONFIGFS_ATTR(, local_port);
+CONFIGFS_ATTR(, remote_port);
+CONFIGFS_ATTR(, local_ip);
+CONFIGFS_ATTR(, remote_ip);
+CONFIGFS_ATTR_RO(, local_mac);
+CONFIGFS_ATTR(, remote_mac);
 
 static struct configfs_attribute *netconsole_target_attrs[] = {
-        &netconsole_target_enabled.attr,
-        &netconsole_target_extended.attr,
-        &netconsole_target_dev_name.attr,
-        &netconsole_target_local_port.attr,
-        &netconsole_target_remote_port.attr,
-        &netconsole_target_local_ip.attr,
-        &netconsole_target_remote_ip.attr,
-        &netconsole_target_local_mac.attr,
-        &netconsole_target_remote_mac.attr,
+        &attr_enabled,
+        &attr_extended,
+        &attr_dev_name,
+        &attr_local_port,
+        &attr_remote_port,
+        &attr_local_ip,
+        &attr_remote_ip,
+        &attr_local_mac,
+        &attr_remote_mac,
         NULL,
 };
 
@@ -584,43 +612,8 @@ static void netconsole_target_release(struct config_item *item)
         kfree(to_target(item));
 }
 
-static ssize_t netconsole_target_attr_show(struct config_item *item,
-                                           struct configfs_attribute *attr,
-                                           char *buf)
-{
-        ssize_t ret = -EINVAL;
-        struct netconsole_target *nt = to_target(item);
-        struct netconsole_target_attr *na =
-                container_of(attr, struct netconsole_target_attr, attr);
-
-        if (na->show)
-                ret = na->show(nt, buf);
-
-        return ret;
-}
-
-static ssize_t netconsole_target_attr_store(struct config_item *item,
-                                            struct configfs_attribute *attr,
-                                            const char *buf,
-                                            size_t count)
-{
-        ssize_t ret = -EINVAL;
-        struct netconsole_target *nt = to_target(item);
-        struct netconsole_target_attr *na =
-                container_of(attr, struct netconsole_target_attr, attr);
-
-        mutex_lock(&dynamic_netconsole_mutex);
-        if (na->store)
-                ret = na->store(nt, buf, count);
-        mutex_unlock(&dynamic_netconsole_mutex);
-
-        return ret;
-}
-
 static struct configfs_item_operations netconsole_target_item_ops = {
         .release                = netconsole_target_release,
-        .show_attribute         = netconsole_target_attr_show,
-        .store_attribute        = netconsole_target_attr_store,
 };
 
 static struct config_item_type netconsole_target_type = {