disk->private_data = &ubd_devs[unit];
        disk->queue = ubd_devs[unit].queue;
-       device_add_disk(parent, disk);
+       device_add_disk(parent, disk, NULL);
 
        *disk_out = disk;
        return 0;
 
        return 0;
 }
 
-static void register_disk(struct device *parent, struct gendisk *disk)
+static void register_disk(struct device *parent, struct gendisk *disk,
+                         const struct attribute_group **groups)
 {
        struct device *ddev = disk_to_dev(disk);
        struct block_device *bdev;
        /* delay uevents, until we scanned partition table */
        dev_set_uevent_suppress(ddev, 1);
 
+       if (groups) {
+               WARN_ON(ddev->groups);
+               ddev->groups = groups;
+       }
        if (device_add(ddev))
                return;
        if (!sysfs_deprecated) {
  * __device_add_disk - add disk information to kernel list
  * @parent: parent device for the disk
  * @disk: per-device partitioning information
+ * @groups: Additional per-device sysfs groups
  * @register_queue: register the queue if set to true
  *
  * This function registers the partitioning information in @disk
  * FIXME: error handling
  */
 static void __device_add_disk(struct device *parent, struct gendisk *disk,
+                             const struct attribute_group **groups,
                              bool register_queue)
 {
        dev_t devt;
                blk_register_region(disk_devt(disk), disk->minors, NULL,
                                    exact_match, exact_lock, disk);
        }
-       register_disk(parent, disk);
+       register_disk(parent, disk, groups);
        if (register_queue)
                blk_register_queue(disk);
 
        blk_integrity_add(disk);
 }
 
-void device_add_disk(struct device *parent, struct gendisk *disk)
+void device_add_disk(struct device *parent, struct gendisk *disk,
+                    const struct attribute_group **groups)
+
 {
-       __device_add_disk(parent, disk, true);
+       __device_add_disk(parent, disk, groups, true);
 }
 EXPORT_SYMBOL(device_add_disk);
 
 void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk)
 {
-       __device_add_disk(parent, disk, false);
+       __device_add_disk(parent, disk, NULL, false);
 }
 EXPORT_SYMBOL(device_add_disk_no_queue_reg);
 
 
                /* to be cleaned up... */
                disks[drive]->private_data = (void *)(long)drive;
                disks[drive]->flags |= GENHD_FL_REMOVABLE;
-               device_add_disk(&floppy_device[drive].dev, disks[drive]);
+               device_add_disk(&floppy_device[drive].dev, disks[drive], NULL);
        }
 
        return 0;
 
        set_capacity(dd->disk, capacity);
 
        /* Enable the block device and add it to /dev */
-       device_add_disk(&dd->pdev->dev, dd->disk);
+       device_add_disk(&dd->pdev->dev, dd->disk, NULL);
 
        dd->bdev = bdget_disk(dd->disk, 0);
        /*
 
                 gendisk->disk_name, priv->model, priv->raw_capacity >> 11,
                 get_capacity(gendisk) >> 11);
 
-       device_add_disk(&dev->sbd.core, gendisk);
+       device_add_disk(&dev->sbd.core, gendisk, NULL);
        return 0;
 
 fail_cleanup_queue:
 
        dev_info(&dev->core, "%s: Using %lu MiB of GPU memory\n",
                 gendisk->disk_name, get_capacity(gendisk) >> 11);
 
-       device_add_disk(&dev->core, gendisk);
+       device_add_disk(&dev->core, gendisk, NULL);
        return 0;
 
 fail_cleanup_queue:
 
                        set_capacity(card->gendisk, card->size8 >> 9);
                else
                        set_capacity(card->gendisk, 0);
-               device_add_disk(CARD_TO_DEV(card), card->gendisk);
+               device_add_disk(CARD_TO_DEV(card), card->gendisk, NULL);
                card->bdev_attached = 1;
        }
 
 
 static int skd_bdev_attach(struct device *parent, struct skd_device *skdev)
 {
        dev_dbg(&skdev->pdev->dev, "add_disk\n");
-       device_add_disk(parent, skdev->disk);
+       device_add_disk(parent, skdev->disk, NULL);
        return 0;
 }
 
 
               port->vdisk_size, (port->vdisk_size >> (20 - 9)),
               port->vio.ver.major, port->vio.ver.minor);
 
-       device_add_disk(&port->vio.vdev->dev, g);
+       device_add_disk(&port->vio.vdev->dev, g, NULL);
 
        return 0;
 }
 
        virtblk_update_capacity(vblk, false);
        virtio_device_ready(vdev);
 
-       device_add_disk(&vdev->dev, vblk->disk);
+       device_add_disk(&vdev->dev, vblk->disk, NULL);
        err = device_create_file(disk_to_dev(vblk->disk), &dev_attr_serial);
        if (err)
                goto out_del_disk;
 
        for (i = 0; i < info->nr_rings; i++)
                kick_pending_request_queues(&info->rinfo[i]);
 
-       device_add_disk(&info->xbdev->dev, info->gd);
+       device_add_disk(&info->xbdev->dev, info->gd, NULL);
 
        info->is_ready = 1;
        return;
 
        ide_cd_read_toc(drive);
        g->fops = &idecd_ops;
        g->flags |= GENHD_FL_REMOVABLE | GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
-       device_add_disk(&drive->gendev, g);
+       device_add_disk(&drive->gendev, g, NULL);
        return 0;
 
 out_free_disk:
 
        if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
                g->flags = GENHD_FL_REMOVABLE;
        g->fops = &ide_gd_ops;
-       device_add_disk(&drive->gendev, g);
+       device_add_disk(&drive->gendev, g, NULL);
        return 0;
 
 out_free_disk:
 
                set_disk_ro(msb->disk, 1);
 
        msb_start(card);
-       device_add_disk(&card->dev, msb->disk);
+       device_add_disk(&card->dev, msb->disk, NULL);
        dbg("Disk added");
        return 0;
 
 
        set_capacity(msb->disk, capacity);
        dev_dbg(&card->dev, "capacity set %ld\n", capacity);
 
-       device_add_disk(&card->dev, msb->disk);
+       device_add_disk(&card->dev, msb->disk, NULL);
        msb->active = 1;
        return 0;
 
 
        int ret;
        struct mmc_card *card = md->queue.card;
 
-       device_add_disk(md->parent, md->disk);
+       device_add_disk(md->parent, md->disk, NULL);
        md->force_ro.show = force_ro_show;
        md->force_ro.store = force_ro_store;
        sysfs_attr_init(&md->force_ro.attr);
 
        if (new->readonly)
                set_disk_ro(gd, 1);
 
-       device_add_disk(&new->mtd->dev, gd);
+       device_add_disk(&new->mtd->dev, gd, NULL);
 
        if (new->disk_attributes) {
                ret = sysfs_create_group(&disk_to_dev(gd)->kobj,
 
        }
 
        set_capacity(disk, available_disk_size >> SECTOR_SHIFT);
-       device_add_disk(dev, disk);
+       device_add_disk(dev, disk, NULL);
        revalidate_disk(disk);
        return 0;
 }
 
                }
        }
        set_capacity(btt->btt_disk, btt->nlba * btt->sector_size >> 9);
-       device_add_disk(&btt->nd_btt->dev, btt->btt_disk);
+       device_add_disk(&btt->nd_btt->dev, btt->btt_disk, NULL);
        btt->nd_btt->size = btt->nlba * (u64)btt->sector_size;
        revalidate_disk(btt->btt_disk);
 
 
        gendev = disk_to_dev(disk);
        gendev->groups = pmem_attribute_groups;
 
-       device_add_disk(dev, disk);
+       device_add_disk(dev, disk, NULL);
        if (devm_add_action_or_reset(dev, pmem_release_disk, pmem))
                return -ENOMEM;
 
 
 
        nvme_get_ctrl(ctrl);
 
-       device_add_disk(ctrl->device, ns->disk);
+       device_add_disk(ctrl->device, ns->disk, NULL);
        if (sysfs_create_group(&disk_to_dev(ns->disk)->kobj,
                                        &nvme_ns_id_attr_group))
                pr_warn("%s: failed to create sysfs group for identification\n",
 
                return;
 
        if (!(head->disk->flags & GENHD_FL_UP)) {
-               device_add_disk(&head->subsys->dev, head->disk);
+               device_add_disk(&head->subsys->dev, head->disk, NULL);
                if (sysfs_create_group(&disk_to_dev(head->disk)->kobj,
                                &nvme_ns_id_attr_group))
                        dev_warn(&head->subsys->dev,
 
        gdp->queue = block->request_queue;
        block->gdp = gdp;
        set_capacity(block->gdp, 0);
-       device_add_disk(&base->cdev->dev, block->gdp);
+       device_add_disk(&base->cdev->dev, block->gdp, NULL);
        return 0;
 }
 
 
        }
 
        get_device(&dev_info->dev);
-       device_add_disk(&dev_info->dev, dev_info->gd);
+       device_add_disk(&dev_info->dev, dev_info->gd, NULL);
 
        switch (dev_info->segment_type) {
                case SEG_TYPE_SR:
 
 
        /* 512 byte sectors */
        set_capacity(bdev->gendisk, scmdev->size >> 9);
-       device_add_disk(&scmdev->dev, bdev->gendisk);
+       device_add_disk(&scmdev->dev, bdev->gendisk, NULL);
        return 0;
 
 out_queue:
 
        }
 
        blk_pm_runtime_init(sdp->request_queue, dev);
-       device_add_disk(dev, gd);
+       device_add_disk(dev, gd, NULL);
        if (sdkp->capacity)
                sd_dif_config_host(sdkp);
 
 
 
        dev_set_drvdata(dev, cd);
        disk->flags |= GENHD_FL_REMOVABLE;
-       device_add_disk(&sdev->sdev_gendev, disk);
+       device_add_disk(&sdev->sdev_gendev, disk, NULL);
 
        sdev_printk(KERN_DEBUG, sdev,
                    "Attached scsi CD-ROM %s\n", cd->cdi.name);
 
 extern void part_round_stats(struct request_queue *q, int cpu, struct hd_struct *part);
 
 /* block/genhd.c */
-extern void device_add_disk(struct device *parent, struct gendisk *disk);
+extern void device_add_disk(struct device *parent, struct gendisk *disk,
+                           const struct attribute_group **groups);
 static inline void add_disk(struct gendisk *disk)
 {
-       device_add_disk(NULL, disk);
+       device_add_disk(NULL, disk, NULL);
 }
 extern void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk);
 static inline void add_disk_no_queue_reg(struct gendisk *disk)