Lines Matching refs:disk
43 static void disk_alloc_events(struct gendisk *disk);
44 static void disk_add_events(struct gendisk *disk);
45 static void disk_del_events(struct gendisk *disk);
46 static void disk_release_events(struct gendisk *disk);
49 * Set disk capacity and notify if the size is not currently
52 bool set_capacity_revalidate_and_notify(struct gendisk *disk, sector_t size,
55 sector_t capacity = get_capacity(disk);
57 set_capacity(disk, size);
59 revalidate_disk_size(disk, true);
64 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
74 * Format the device name of the indicated disk into the supplied buffer and
146 struct hd_struct *__disk_get_part(struct gendisk *disk, int partno)
148 struct disk_part_tbl *ptbl = rcu_dereference(disk->part_tbl);
157 * @disk: disk to look partition from
160 * Look for partition @partno from @disk. If found, increment
169 struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
174 part = __disk_get_part(disk, partno);
185 * @disk: disk to iterate over
188 * Initialize @piter so that it iterates over partitions of @disk.
193 void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk,
199 ptbl = rcu_dereference(disk->part_tbl);
201 piter->disk = disk;
237 ptbl = rcu_dereference(piter->disk->part_tbl);
304 * @disk: gendisk of interest
307 * Find out which partition @sector maps to on @disk. This is
313 * is same with the disk.
319 struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
326 ptbl = rcu_dereference(disk->part_tbl);
348 part = &disk->part0;
356 * @disk: gendisk of interest
367 bool disk_has_partitions(struct gendisk *disk)
374 ptbl = rcu_dereference(disk->part_tbl);
576 struct gendisk *disk = part_to_disk(part);
580 if (part->partno < disk->minors) {
581 *devt = MKDEV(disk->major, disk->first_minor + part->partno);
690 static void disk_scan_partitions(struct gendisk *disk)
694 if (!get_capacity(disk) || !disk_part_scan_enabled(disk))
697 set_bit(GD_NEED_PART_SCAN, &disk->state);
698 bdev = blkdev_get_by_dev(disk_devt(disk), FMODE_READ, NULL);
703 static void register_disk(struct device *parent, struct gendisk *disk,
706 struct device *ddev = disk_to_dev(disk);
713 dev_set_name(ddev, "%s", disk->disk_name);
740 disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
741 disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
743 if (disk->flags & GENHD_FL_HIDDEN)
746 disk_scan_partitions(disk);
748 /* announce disk after possible partitions are created */
753 disk_part_iter_init(&piter, disk, 0);
758 if (disk->queue->backing_dev_info->dev) {
760 &disk->queue->backing_dev_info->dev->kobj,
767 * __device_add_disk - add disk information to kernel list
768 * @parent: parent device for the disk
769 * @disk: per-device partitioning information
773 * This function registers the partitioning information in @disk
778 static void __device_add_disk(struct device *parent, struct gendisk *disk,
786 * The disk queue should now be all set with enough information about
792 elevator_init_mq(disk->queue);
798 WARN_ON(disk->minors && !(disk->major || disk->first_minor));
799 WARN_ON(!disk->minors &&
800 !(disk->flags & (GENHD_FL_EXT_DEVT | GENHD_FL_HIDDEN)));
802 disk->flags |= GENHD_FL_UP;
804 retval = blk_alloc_devt(&disk->part0, &devt);
809 disk->major = MAJOR(devt);
810 disk->first_minor = MINOR(devt);
812 disk_alloc_events(disk);
814 if (disk->flags & GENHD_FL_HIDDEN) {
819 disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
820 disk->flags |= GENHD_FL_NO_PART_SCAN;
822 struct backing_dev_info *bdi = disk->queue->backing_dev_info;
823 struct device *dev = disk_to_dev(disk);
831 blk_register_region(disk_devt(disk), disk->minors, NULL,
832 exact_match, exact_lock, disk);
834 register_disk(parent, disk, groups);
836 blk_register_queue(disk);
840 * so that it sticks around as long as @disk is there.
842 WARN_ON_ONCE(!blk_get_queue(disk->queue));
844 disk_add_events(disk);
845 blk_integrity_add(disk);
848 void device_add_disk(struct device *parent, struct gendisk *disk,
852 __device_add_disk(parent, disk, groups, true);
856 void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk)
858 __device_add_disk(parent, disk, NULL, false);
862 static void invalidate_partition(struct gendisk *disk, int partno)
866 bdev = bdget_disk(disk, partno);
883 * @disk: the struct gendisk to remove
900 void del_gendisk(struct gendisk *disk)
907 blk_integrity_del(disk);
908 disk_del_events(disk);
911 * Block lookups of the disk until all bdevs are unhashed and the
912 * disk is marked as dead (GENHD_FL_UP cleared).
914 down_write(&disk->lookup_sem);
916 disk_part_iter_init(&piter, disk,
919 invalidate_partition(disk, part->partno);
924 invalidate_partition(disk, 0);
925 set_capacity(disk, 0);
926 disk->flags &= ~GENHD_FL_UP;
927 up_write(&disk->lookup_sem);
929 if (!(disk->flags & GENHD_FL_HIDDEN))
930 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
931 if (disk->queue) {
936 if (!(disk->flags & GENHD_FL_HIDDEN))
937 bdi_unregister(disk->queue->backing_dev_info);
938 blk_unregister_queue(disk);
943 if (!(disk->flags & GENHD_FL_HIDDEN))
944 blk_unregister_region(disk_devt(disk), disk->minors);
951 blk_invalidate_devt(disk_devt(disk));
953 kobject_put(disk->part0.holder_dir);
954 kobject_put(disk->slave_dir);
956 part_stat_set_all(&disk->part0, 0);
957 disk->part0.stamp = 0;
959 sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
960 pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
961 device_del(disk_to_dev(disk));
970 struct gendisk *disk = dev_to_disk(dev);
972 if (!disk->bb)
975 return badblocks_show(disk->bb, page, 0);
982 struct gendisk *disk = dev_to_disk(dev);
984 if (!disk->bb)
987 return badblocks_store(disk->bb, page, len, 0);
1002 struct gendisk *disk = NULL;
1011 disk = dev_to_disk(kobj_to_dev(kobj));
1019 disk = part_to_disk(part);
1024 if (!disk)
1028 * Synchronize with del_gendisk() to not return disk that is being
1031 down_read(&disk->lookup_sem);
1032 if (unlikely((disk->flags & GENHD_FL_HIDDEN) ||
1033 !(disk->flags & GENHD_FL_UP))) {
1034 up_read(&disk->lookup_sem);
1035 put_disk_and_module(disk);
1036 disk = NULL;
1038 up_read(&disk->lookup_sem);
1040 return disk;
1045 * @disk: gendisk of interest
1048 * Find partition @partno from @disk, do bdget() on it.
1056 struct block_device *bdget_disk(struct gendisk *disk, int partno)
1061 part = disk_get_part(disk, partno);
1082 struct gendisk *disk = dev_to_disk(dev);
1092 if (get_capacity(disk) == 0 ||
1093 (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
1101 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
1103 bool is_part0 = part == &disk->part0;
1108 , disk_name(disk, part->partno, name_buf),
1195 /* show the full disk and all non-0 size partitions of it */
1248 struct gendisk *disk = dev_to_disk(dev);
1250 return sprintf(buf, "%d\n", disk->minors);
1256 struct gendisk *disk = dev_to_disk(dev);
1258 return sprintf(buf, "%d\n", disk_max_parts(disk));
1264 struct gendisk *disk = dev_to_disk(dev);
1267 (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
1273 struct gendisk *disk = dev_to_disk(dev);
1276 (disk->flags & GENHD_FL_HIDDEN ? 1 : 0));
1282 struct gendisk *disk = dev_to_disk(dev);
1284 return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
1358 struct gendisk *disk = dev_to_disk(dev);
1360 return sprintf(buf, "%x\n", disk->flags);
1367 struct gendisk *disk = dev_to_disk(dev);
1369 return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
1376 struct gendisk *disk = dev_to_disk(dev);
1378 return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
1450 struct gendisk *disk = dev_to_disk(dev);
1452 if (a == &dev_attr_badblocks.attr && !disk->bb)
1468 * disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way
1469 * @disk: disk to replace part_tbl for
1472 * Replace disk->part_tbl with @new_ptbl in RCU-safe way. The
1476 * Matching bd_mutex locked or the caller is the only user of @disk.
1478 static void disk_replace_part_tbl(struct gendisk *disk,
1482 rcu_dereference_protected(disk->part_tbl, 1);
1484 rcu_assign_pointer(disk->part_tbl, new_ptbl);
1493 * disk_expand_part_tbl - expand disk->part_tbl
1494 * @disk: disk to expand part_tbl for
1497 * Expand disk->part_tbl such that @partno can fit in. disk->part_tbl
1501 * Matching bd_mutex locked or the caller is the only user of @disk.
1507 int disk_expand_part_tbl(struct gendisk *disk, int partno)
1510 rcu_dereference_protected(disk->part_tbl, 1);
1524 if (disk_max_parts(disk) && target > disk_max_parts(disk))
1531 disk->node_id);
1540 disk_replace_part_tbl(disk, new_ptbl);
1546 * @dev: the device representing this disk
1559 * will also be freed prior to the disk.
1565 struct gendisk *disk = dev_to_disk(dev);
1568 blk_mq_cancel_work_sync(disk->queue);
1571 disk_release_events(disk);
1572 kfree(disk->random);
1573 disk_replace_part_tbl(disk, NULL);
1574 hd_free_part(&disk->part0);
1575 if (disk->queue)
1576 blk_put_queue(disk->queue);
1577 kfree(disk);
1586 struct gendisk *disk = dev_to_disk(dev);
1588 if (disk->fops->devnode)
1589 return disk->fops->devnode(disk, mode);
1594 .name = "disk",
1602 * aggregate disk stat collector. Uses the same stats that the sysfs
1698 struct gendisk *disk = dev_to_disk(dev);
1704 if (partno < disk->minors) {
1712 part = disk_get_part(disk, partno);
1726 struct gendisk *disk;
1736 disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
1737 if (!disk)
1740 disk->part0.dkstats = alloc_percpu(struct disk_stats);
1741 if (!disk->part0.dkstats)
1744 init_rwsem(&disk->lookup_sem);
1745 disk->node_id = node_id;
1746 if (disk_expand_part_tbl(disk, 0)) {
1747 free_percpu(disk->part0.dkstats);
1751 ptbl = rcu_dereference_protected(disk->part_tbl, 1);
1752 rcu_assign_pointer(ptbl->part[0], &disk->part0);
1763 hd_sects_seq_init(&disk->part0);
1764 if (hd_ref_init(&disk->part0))
1767 disk->minors = minors;
1768 rand_initialize_disk(disk);
1769 disk_to_dev(disk)->class = &block_class;
1770 disk_to_dev(disk)->type = &disk_type;
1771 device_initialize(disk_to_dev(disk));
1772 return disk;
1775 hd_free_part(&disk->part0);
1777 kfree(disk);
1784 * @disk: the struct gendisk to increment the refcount for
1791 struct kobject *get_disk_and_module(struct gendisk *disk)
1796 if (!disk->fops)
1798 owner = disk->fops->owner;
1801 kobj = kobject_get_unless_zero(&disk_to_dev(disk)->kobj);
1813 * @disk: the struct gendisk to decrement the refcount for
1821 void put_disk(struct gendisk *disk)
1823 if (disk)
1824 kobject_put(&disk_to_dev(disk)->kobj);
1830 * @disk: the struct gendisk to decrement the refcount for
1838 void put_disk_and_module(struct gendisk *disk)
1840 if (disk) {
1841 struct module *owner = disk->fops->owner;
1843 put_disk(disk);
1866 void set_disk_ro(struct gendisk *disk, int flag)
1871 if (disk->part0.policy != flag) {
1872 set_disk_ro_uevent(disk, flag);
1873 disk->part0.policy = flag;
1876 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
1894 * Disk events - monitor disk events like media change and eject request.
1898 struct gendisk *disk; /* the associated disk */
1927 static unsigned long disk_events_poll_jiffies(struct gendisk *disk)
1929 struct disk_events *ev = disk->ev;
1938 else if (disk->event_flags & DISK_EVENT_FLAG_POLL)
1945 * disk_block_events - block and flush disk event checking
1946 * @disk: disk to block events for
1959 void disk_block_events(struct gendisk *disk)
1961 struct disk_events *ev = disk->ev;
1979 cancel_delayed_work_sync(&disk->ev->dwork);
1984 static void __disk_unblock_events(struct gendisk *disk, bool check_now)
1986 struct disk_events *ev = disk->ev;
1998 intv = disk_events_poll_jiffies(disk);
2010 * disk_unblock_events - unblock disk event checking
2011 * @disk: disk to unblock events for
2019 void disk_unblock_events(struct gendisk *disk)
2021 if (disk->ev)
2022 __disk_unblock_events(disk, false);
2027 * @disk: disk to check and flush events for
2030 * Schedule immediate event checking on @disk if not blocked. Events in
2032 * doesn't clear the events from @disk->ev.
2037 void disk_flush_events(struct gendisk *disk, unsigned int mask)
2039 struct disk_events *ev = disk->ev;
2054 * @disk: disk to fetch and clear events from
2063 static unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask)
2065 struct disk_events *ev = disk->ev;
2072 disk_block_events(disk);
2089 __disk_unblock_events(disk, ev->clearing ? true : false);
2143 struct gendisk *disk = ev->disk;
2151 events = disk->fops->check_events(disk, clearing);
2160 intv = disk_events_poll_jiffies(disk);
2169 * @disk->events are reported, and only if DISK_EVENT_FLAG_UEVENT
2174 if ((events & disk->events & (1 << i)) &&
2175 (disk->event_flags & DISK_EVENT_FLAG_UEVENT))
2179 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
2183 * A disk events enabled device has the following sysfs nodes under
2211 struct gendisk *disk = dev_to_disk(dev);
2213 if (!(disk->event_flags & DISK_EVENT_FLAG_UEVENT))
2216 return __disk_events_show(disk->events, buf);
2229 struct gendisk *disk = dev_to_disk(dev);
2231 if (!disk->ev)
2234 return sprintf(buf, "%ld\n", disk->ev->poll_msecs);
2241 struct gendisk *disk = dev_to_disk(dev);
2250 if (!disk->ev)
2253 disk_block_events(disk);
2254 disk->ev->poll_msecs = intv;
2255 __disk_unblock_events(disk, true);
2292 disk_flush_events(ev->disk, 0);
2313 static void disk_alloc_events(struct gendisk *disk)
2317 if (!disk->fops->check_events || !disk->events)
2322 pr_warn("%s: failed to initialize events\n", disk->disk_name);
2327 ev->disk = disk;
2334 disk->ev = ev;
2337 static void disk_add_events(struct gendisk *disk)
2340 if (sysfs_create_files(&disk_to_dev(disk)->kobj, disk_events_attrs) < 0)
2342 disk->disk_name);
2344 if (!disk->ev)
2348 list_add_tail(&disk->ev->node, &disk_events);
2355 __disk_unblock_events(disk, true);
2358 static void disk_del_events(struct gendisk *disk)
2360 if (disk->ev) {
2361 disk_block_events(disk);
2364 list_del_init(&disk->ev->node);
2368 sysfs_remove_files(&disk_to_dev(disk)->kobj, disk_events_attrs);
2371 static void disk_release_events(struct gendisk *disk)
2374 WARN_ON_ONCE(disk->ev && disk->ev->block != 1);
2375 kfree(disk->ev);