void (*release)(struct config_item *);
                int (*allow_link)(struct config_item *src,
                                  struct config_item *target);
-               int (*drop_link)(struct config_item *src,
+               void (*drop_link)(struct config_item *src,
                                 struct config_item *target);
        };
 
 
        return ret;
 }
 
-static int nvmet_port_subsys_drop_link(struct config_item *parent,
+static void nvmet_port_subsys_drop_link(struct config_item *parent,
                struct config_item *target)
 {
        struct nvmet_port *port = to_nvmet_port(parent->ci_parent);
                        goto found;
        }
        up_write(&nvmet_config_sem);
-       return -EINVAL;
+       return;
 
 found:
        list_del(&p->entry);
                nvmet_disable_port(port);
        up_write(&nvmet_config_sem);
        kfree(p);
-       return 0;
 }
 
 static struct configfs_item_operations nvmet_port_subsys_item_ops = {
        return ret;
 }
 
-static int nvmet_allowed_hosts_drop_link(struct config_item *parent,
+static void nvmet_allowed_hosts_drop_link(struct config_item *parent,
                struct config_item *target)
 {
        struct nvmet_subsys *subsys = to_subsys(parent->ci_parent);
                        goto found;
        }
        up_write(&nvmet_config_sem);
-       return -EINVAL;
+       return;
 
 found:
        list_del(&p->entry);
        nvmet_genctr++;
        up_write(&nvmet_config_sem);
        kfree(p);
-       return 0;
 }
 
 static struct configfs_item_operations nvmet_allowed_hosts_item_ops = {
 
        return core_dev_add_initiator_node_lun_acl(se_tpg, lacl, lun, lun_access_ro);
 }
 
-static int target_fabric_mappedlun_unlink(
+static void target_fabric_mappedlun_unlink(
        struct config_item *lun_acl_ci,
        struct config_item *lun_ci)
 {
        struct se_lun *lun = container_of(to_config_group(lun_ci),
                        struct se_lun, lun_group);
 
-       return core_dev_del_initiator_node_lun_acl(lun, lacl);
+       core_dev_del_initiator_node_lun_acl(lun, lacl);
 }
 
 static struct se_lun_acl *item_to_lun_acl(struct config_item *item)
        return ret;
 }
 
-static int target_fabric_port_unlink(
+static void target_fabric_port_unlink(
        struct config_item *lun_ci,
        struct config_item *se_dev_ci)
 {
        }
 
        core_dev_del_lun(se_tpg, lun);
-       return 0;
 }
 
 static void target_fabric_port_release(struct config_item *item)
 
        return ret;
 }
 
-static int config_usb_cfg_unlink(
+static void config_usb_cfg_unlink(
        struct config_item *usb_cfg_ci,
        struct config_item *usb_func_ci)
 {
                        list_del(&f->list);
                        usb_put_function(f);
                        mutex_unlock(&gi->lock);
-                       return 0;
+                       return;
                }
        }
        mutex_unlock(&gi->lock);
        WARN(1, "Unable to locate function to unbind\n");
-       return 0;
 }
 
 static struct configfs_item_operations gadget_config_item_ops = {
        return ret;
 }
 
-static int os_desc_unlink(struct config_item *os_desc_ci,
+static void os_desc_unlink(struct config_item *os_desc_ci,
                          struct config_item *usb_cfg_ci)
 {
        struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
        cdev->os_desc_config = NULL;
        WARN_ON(gi->composite.gadget_driver.udc_name);
        mutex_unlock(&gi->lock);
-       return 0;
 }
 
 static struct configfs_item_operations os_desc_ops = {
 
        return ret;
 }
 
-static int uvcg_control_class_drop_link(struct config_item *src,
+static void uvcg_control_class_drop_link(struct config_item *src,
                                        struct config_item *target)
 {
        struct config_item *control, *header;
        struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
        struct uvc_descriptor_header **class_array;
        struct uvcg_control_header *target_hdr;
-       int ret = -EINVAL;
 
        mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 
        mutex_lock(&opts->lock);
 
        class_array = uvcg_get_ctl_class_arr(src, opts);
-       if (!class_array)
-               goto unlock;
-       if (opts->refcnt) {
-               ret = -EBUSY;
+       if (!class_array || opts->refcnt)
                goto unlock;
-       }
 
        target_hdr = to_uvcg_control_header(target);
        --target_hdr->linked;
        class_array[0] = NULL;
-       ret = 0;
 
 unlock:
        mutex_unlock(&opts->lock);
 out:
        mutex_unlock(su_mutex);
-       return ret;
 }
 
 static struct configfs_item_operations uvcg_control_class_item_ops = {
        return ret;
 }
 
-static int uvcg_streaming_header_drop_link(struct config_item *src,
+static void uvcg_streaming_header_drop_link(struct config_item *src,
                                           struct config_item *target)
 {
        struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
        struct uvcg_streaming_header *src_hdr;
        struct uvcg_format *target_fmt = NULL;
        struct uvcg_format_ptr *format_ptr, *tmp;
-       int ret = -EINVAL;
 
        src_hdr = to_uvcg_streaming_header(src);
        mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 out:
        mutex_unlock(&opts->lock);
        mutex_unlock(su_mutex);
-       return ret;
-
 }
 
 static struct configfs_item_operations uvcg_streaming_header_item_ops = {
        return ret;
 }
 
-static int uvcg_streaming_class_drop_link(struct config_item *src,
+static void uvcg_streaming_class_drop_link(struct config_item *src,
                                          struct config_item *target)
 {
        struct config_item *streaming, *header;
        struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
        struct uvc_descriptor_header ***class_array;
        struct uvcg_streaming_header *target_hdr;
-       int ret = -EINVAL;
 
        mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 
        if (!class_array || !*class_array)
                goto unlock;
 
-       if (opts->refcnt) {
-               ret = -EBUSY;
+       if (opts->refcnt)
                goto unlock;
-       }
 
        target_hdr = to_uvcg_streaming_header(target);
        --target_hdr->linked;
        kfree(**class_array);
        kfree(*class_array);
        *class_array = NULL;
-       ret = 0;
 
 unlock:
        mutex_unlock(&opts->lock);
 out:
        mutex_unlock(su_mutex);
-       return ret;
 }
 
 static struct configfs_item_operations uvcg_streaming_class_item_ops = {
 
 struct configfs_item_operations {
        void (*release)(struct config_item *);
        int (*allow_link)(struct config_item *src, struct config_item *target);
-       int (*drop_link)(struct config_item *src, struct config_item *target);
+       void (*drop_link)(struct config_item *src, struct config_item *target);
 };
 
 struct configfs_group_operations {