2005-04-17 02:20:36 +04:00
/*
* gendisk handling
*/
# include <linux/module.h>
# include <linux/fs.h>
# include <linux/genhd.h>
2007-02-21 00:57:48 +03:00
# include <linux/kdev_t.h>
2005-04-17 02:20:36 +04:00
# include <linux/kernel.h>
# include <linux/blkdev.h>
# include <linux/init.h>
# include <linux/spinlock.h>
# include <linux/seq_file.h>
# include <linux/slab.h>
# include <linux/kmod.h>
# include <linux/kobj_map.h>
2005-05-06 03:15:59 +04:00
# include <linux/buffer_head.h>
2006-02-07 01:12:43 +03:00
# include <linux/mutex.h>
2008-08-25 14:47:22 +04:00
# include <linux/idr.h>
2005-04-17 02:20:36 +04:00
2008-03-04 13:23:45 +03:00
# include "blk.h"
2007-05-22 00:08:01 +04:00
static DEFINE_MUTEX ( block_class_lock ) ;
# ifndef CONFIG_SYSFS_DEPRECATED
struct kobject * block_depr ;
# endif
2005-04-17 02:20:36 +04:00
2008-08-25 14:47:22 +04:00
/* for extended dynamic devt allocation, currently only one major is used */
# define MAX_EXT_DEVT (1 << MINORBITS)
/* For extended devt allocation. ext_devt_mutex prevents look up
* results from going away underneath its user .
*/
static DEFINE_MUTEX ( ext_devt_mutex ) ;
static DEFINE_IDR ( ext_devt_idr ) ;
2008-03-04 13:23:46 +03:00
static struct device_type disk_type ;
2008-09-03 11:03:02 +04:00
/**
* disk_get_part - get partition
* @ disk : disk to look partition from
* @ partno : partition number
*
* Look for partition @ partno from @ disk . If found , increment
* reference count and return it .
*
* CONTEXT :
* Don ' t care .
*
* RETURNS :
* Pointer to the found partition on success , NULL if not found .
*/
struct hd_struct * disk_get_part ( struct gendisk * disk , int partno )
{
struct hd_struct * part ;
2008-09-03 11:06:42 +04:00
if ( unlikely ( partno < 0 | | partno > = disk_max_parts ( disk ) ) )
2008-09-03 11:03:02 +04:00
return NULL ;
rcu_read_lock ( ) ;
2008-09-03 11:06:42 +04:00
part = rcu_dereference ( disk - > __part [ partno ] ) ;
2008-09-03 11:03:02 +04:00
if ( part )
2008-08-25 14:56:05 +04:00
get_device ( part_to_dev ( part ) ) ;
2008-09-03 11:03:02 +04:00
rcu_read_unlock ( ) ;
return part ;
}
EXPORT_SYMBOL_GPL ( disk_get_part ) ;
/**
* disk_part_iter_init - initialize partition iterator
* @ piter : iterator to initialize
* @ disk : disk to iterate over
* @ flags : DISK_PITER_ * flags
*
* Initialize @ piter so that it iterates over partitions of @ disk .
*
* CONTEXT :
* Don ' t care .
*/
void disk_part_iter_init ( struct disk_part_iter * piter , struct gendisk * disk ,
unsigned int flags )
{
piter - > disk = disk ;
piter - > part = NULL ;
if ( flags & DISK_PITER_REVERSE )
piter - > idx = disk_max_parts ( piter - > disk ) - 1 ;
2008-09-03 11:06:42 +04:00
else if ( flags & DISK_PITER_INCL_PART0 )
2008-09-03 11:03:02 +04:00
piter - > idx = 0 ;
2008-09-03 11:06:42 +04:00
else
piter - > idx = 1 ;
2008-09-03 11:03:02 +04:00
piter - > flags = flags ;
}
EXPORT_SYMBOL_GPL ( disk_part_iter_init ) ;
/**
* disk_part_iter_next - proceed iterator to the next partition and return it
* @ piter : iterator of interest
*
* Proceed @ piter to the next partition and return it .
*
* CONTEXT :
* Don ' t care .
*/
struct hd_struct * disk_part_iter_next ( struct disk_part_iter * piter )
{
int inc , end ;
/* put the last partition */
disk_put_part ( piter - > part ) ;
piter - > part = NULL ;
rcu_read_lock ( ) ;
/* determine iteration parameters */
if ( piter - > flags & DISK_PITER_REVERSE ) {
inc = - 1 ;
2008-09-03 11:06:42 +04:00
if ( piter - > flags & DISK_PITER_INCL_PART0 )
end = - 1 ;
else
end = 0 ;
2008-09-03 11:03:02 +04:00
} else {
inc = 1 ;
end = disk_max_parts ( piter - > disk ) ;
}
/* iterate to the next partition */
for ( ; piter - > idx ! = end ; piter - > idx + = inc ) {
struct hd_struct * part ;
part = rcu_dereference ( piter - > disk - > __part [ piter - > idx ] ) ;
if ( ! part )
continue ;
if ( ! ( piter - > flags & DISK_PITER_INCL_EMPTY ) & & ! part - > nr_sects )
continue ;
2008-08-25 14:56:05 +04:00
get_device ( part_to_dev ( part ) ) ;
2008-09-03 11:03:02 +04:00
piter - > part = part ;
piter - > idx + = inc ;
break ;
}
rcu_read_unlock ( ) ;
return piter - > part ;
}
EXPORT_SYMBOL_GPL ( disk_part_iter_next ) ;
/**
* disk_part_iter_exit - finish up partition iteration
* @ piter : iter of interest
*
* Called when iteration is over . Cleans up @ piter .
*
* CONTEXT :
* Don ' t care .
*/
void disk_part_iter_exit ( struct disk_part_iter * piter )
{
disk_put_part ( piter - > part ) ;
piter - > part = NULL ;
}
EXPORT_SYMBOL_GPL ( disk_part_iter_exit ) ;
/**
* disk_map_sector_rcu - map sector to partition
* @ disk : gendisk of interest
* @ sector : sector to map
*
* Find out which partition @ sector maps to on @ disk . This is
* primarily used for stats accounting .
*
* CONTEXT :
* RCU read locked . The returned partition pointer is valid only
* while preemption is disabled .
*
* RETURNS :
* Found partition on success , NULL if there ' s no matching partition .
*/
struct hd_struct * disk_map_sector_rcu ( struct gendisk * disk , sector_t sector )
{
int i ;
2008-09-03 11:06:42 +04:00
for ( i = 1 ; i < disk_max_parts ( disk ) ; i + + ) {
2008-09-03 11:03:02 +04:00
struct hd_struct * part = rcu_dereference ( disk - > __part [ i ] ) ;
if ( part & & part - > start_sect < = sector & &
sector < part - > start_sect + part - > nr_sects )
return part ;
}
return NULL ;
}
EXPORT_SYMBOL_GPL ( disk_map_sector_rcu ) ;
2005-04-17 02:20:36 +04:00
/*
* Can be deleted altogether . Later .
*
*/
static struct blk_major_name {
struct blk_major_name * next ;
int major ;
char name [ 16 ] ;
2006-03-31 14:30:32 +04:00
} * major_names [ BLKDEV_MAJOR_HASH_SIZE ] ;
2005-04-17 02:20:36 +04:00
/* index in the above - for now: assume no multimajor ranges */
static inline int major_to_index ( int major )
{
2006-03-31 14:30:32 +04:00
return major % BLKDEV_MAJOR_HASH_SIZE ;
2006-01-15 00:20:38 +03:00
}
2006-03-31 14:30:32 +04:00
# ifdef CONFIG_PROC_FS
2008-09-03 11:01:09 +04:00
void blkdev_show ( struct seq_file * seqf , off_t offset )
2006-01-15 00:20:38 +03:00
{
2006-03-31 14:30:32 +04:00
struct blk_major_name * dp ;
2006-01-15 00:20:38 +03:00
2006-03-31 14:30:32 +04:00
if ( offset < BLKDEV_MAJOR_HASH_SIZE ) {
2007-05-22 00:08:01 +04:00
mutex_lock ( & block_class_lock ) ;
2006-03-31 14:30:32 +04:00
for ( dp = major_names [ offset ] ; dp ; dp = dp - > next )
2008-09-03 11:01:09 +04:00
seq_printf ( seqf , " %3d %s \n " , dp - > major , dp - > name ) ;
2007-05-22 00:08:01 +04:00
mutex_unlock ( & block_class_lock ) ;
2005-04-17 02:20:36 +04:00
}
}
2006-03-31 14:30:32 +04:00
# endif /* CONFIG_PROC_FS */
2005-04-17 02:20:36 +04:00
int register_blkdev ( unsigned int major , const char * name )
{
struct blk_major_name * * n , * p ;
int index , ret = 0 ;
2007-05-22 00:08:01 +04:00
mutex_lock ( & block_class_lock ) ;
2005-04-17 02:20:36 +04:00
/* temporary */
if ( major = = 0 ) {
for ( index = ARRAY_SIZE ( major_names ) - 1 ; index > 0 ; index - - ) {
if ( major_names [ index ] = = NULL )
break ;
}
if ( index = = 0 ) {
printk ( " register_blkdev: failed to get major for %s \n " ,
name ) ;
ret = - EBUSY ;
goto out ;
}
major = index ;
ret = major ;
}
p = kmalloc ( sizeof ( struct blk_major_name ) , GFP_KERNEL ) ;
if ( p = = NULL ) {
ret = - ENOMEM ;
goto out ;
}
p - > major = major ;
strlcpy ( p - > name , name , sizeof ( p - > name ) ) ;
p - > next = NULL ;
index = major_to_index ( major ) ;
for ( n = & major_names [ index ] ; * n ; n = & ( * n ) - > next ) {
if ( ( * n ) - > major = = major )
break ;
}
if ( ! * n )
* n = p ;
else
ret = - EBUSY ;
if ( ret < 0 ) {
printk ( " register_blkdev: cannot get major %d for %s \n " ,
major , name ) ;
kfree ( p ) ;
}
out :
2007-05-22 00:08:01 +04:00
mutex_unlock ( & block_class_lock ) ;
2005-04-17 02:20:36 +04:00
return ret ;
}
EXPORT_SYMBOL ( register_blkdev ) ;
2007-07-17 15:03:47 +04:00
void unregister_blkdev ( unsigned int major , const char * name )
2005-04-17 02:20:36 +04:00
{
struct blk_major_name * * n ;
struct blk_major_name * p = NULL ;
int index = major_to_index ( major ) ;
2007-05-22 00:08:01 +04:00
mutex_lock ( & block_class_lock ) ;
2005-04-17 02:20:36 +04:00
for ( n = & major_names [ index ] ; * n ; n = & ( * n ) - > next )
if ( ( * n ) - > major = = major )
break ;
2007-07-17 15:03:45 +04:00
if ( ! * n | | strcmp ( ( * n ) - > name , name ) ) {
WARN_ON ( 1 ) ;
} else {
2005-04-17 02:20:36 +04:00
p = * n ;
* n = p - > next ;
}
2007-05-22 00:08:01 +04:00
mutex_unlock ( & block_class_lock ) ;
2005-04-17 02:20:36 +04:00
kfree ( p ) ;
}
EXPORT_SYMBOL ( unregister_blkdev ) ;
static struct kobj_map * bdev_map ;
2008-08-25 14:47:25 +04:00
/**
* blk_mangle_minor - scatter minor numbers apart
* @ minor : minor number to mangle
*
* Scatter consecutively allocated @ minor number apart if MANGLE_DEVT
* is enabled . Mangling twice gives the original value .
*
* RETURNS :
* Mangled value .
*
* CONTEXT :
* Don ' t care .
*/
static int blk_mangle_minor ( int minor )
{
# ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
int i ;
for ( i = 0 ; i < MINORBITS / 2 ; i + + ) {
int low = minor & ( 1 < < i ) ;
int high = minor & ( 1 < < ( MINORBITS - 1 - i ) ) ;
int distance = MINORBITS - 1 - 2 * i ;
minor ^ = low | high ; /* clear both bits */
low < < = distance ; /* swap the positions */
high > > = distance ;
minor | = low | high ; /* and set */
}
# endif
return minor ;
}
2008-08-25 14:47:22 +04:00
/**
* blk_alloc_devt - allocate a dev_t for a partition
* @ part : partition to allocate dev_t for
* @ gfp_mask : memory allocation flag
* @ devt : out parameter for resulting dev_t
*
* Allocate a dev_t for block device .
*
* RETURNS :
* 0 on success , allocated dev_t is returned in * @ devt . - errno on
* failure .
*
* CONTEXT :
* Might sleep .
*/
int blk_alloc_devt ( struct hd_struct * part , dev_t * devt )
{
struct gendisk * disk = part_to_disk ( part ) ;
int idx , rc ;
/* in consecutive minor range? */
if ( part - > partno < disk - > minors ) {
* devt = MKDEV ( disk - > major , disk - > first_minor + part - > partno ) ;
return 0 ;
}
/* allocate ext devt */
do {
if ( ! idr_pre_get ( & ext_devt_idr , GFP_KERNEL ) )
return - ENOMEM ;
rc = idr_get_new ( & ext_devt_idr , part , & idx ) ;
} while ( rc = = - EAGAIN ) ;
if ( rc )
return rc ;
if ( idx > MAX_EXT_DEVT ) {
idr_remove ( & ext_devt_idr , idx ) ;
return - EBUSY ;
}
2008-08-25 14:47:25 +04:00
* devt = MKDEV ( BLOCK_EXT_MAJOR , blk_mangle_minor ( idx ) ) ;
2008-08-25 14:47:22 +04:00
return 0 ;
}
/**
* blk_free_devt - free a dev_t
* @ devt : dev_t to free
*
* Free @ devt which was allocated using blk_alloc_devt ( ) .
*
* CONTEXT :
* Might sleep .
*/
void blk_free_devt ( dev_t devt )
{
might_sleep ( ) ;
if ( devt = = MKDEV ( 0 , 0 ) )
return ;
if ( MAJOR ( devt ) = = BLOCK_EXT_MAJOR ) {
mutex_lock ( & ext_devt_mutex ) ;
2008-08-25 14:47:25 +04:00
idr_remove ( & ext_devt_idr , blk_mangle_minor ( MINOR ( devt ) ) ) ;
2008-08-25 14:47:22 +04:00
mutex_unlock ( & ext_devt_mutex ) ;
}
}
2008-08-25 14:47:23 +04:00
static char * bdevt_str ( dev_t devt , char * buf )
{
if ( MAJOR ( devt ) < = 0xff & & MINOR ( devt ) < = 0xff ) {
char tbuf [ BDEVT_SIZE ] ;
snprintf ( tbuf , BDEVT_SIZE , " %02x%02x " , MAJOR ( devt ) , MINOR ( devt ) ) ;
snprintf ( buf , BDEVT_SIZE , " %-9s " , tbuf ) ;
} else
snprintf ( buf , BDEVT_SIZE , " %03x:%05x " , MAJOR ( devt ) , MINOR ( devt ) ) ;
return buf ;
}
2005-04-17 02:20:36 +04:00
/*
* Register device numbers dev . . ( dev + range - 1 )
* range must be nonzero
* The hash chain is sorted on range , so that subranges can override .
*/
2007-05-22 00:08:01 +04:00
void blk_register_region ( dev_t devt , unsigned long range , struct module * module ,
2005-04-17 02:20:36 +04:00
struct kobject * ( * probe ) ( dev_t , int * , void * ) ,
int ( * lock ) ( dev_t , void * ) , void * data )
{
2007-05-22 00:08:01 +04:00
kobj_map ( bdev_map , devt , range , module , probe , lock , data ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( blk_register_region ) ;
2007-05-22 00:08:01 +04:00
void blk_unregister_region ( dev_t devt , unsigned long range )
2005-04-17 02:20:36 +04:00
{
2007-05-22 00:08:01 +04:00
kobj_unmap ( bdev_map , devt , range ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( blk_unregister_region ) ;
2008-09-03 11:01:09 +04:00
static struct kobject * exact_match ( dev_t devt , int * partno , void * data )
2005-04-17 02:20:36 +04:00
{
struct gendisk * p = data ;
2007-05-22 00:08:01 +04:00
2008-08-25 14:56:05 +04:00
return & disk_to_dev ( p ) - > kobj ;
2005-04-17 02:20:36 +04:00
}
2007-05-22 00:08:01 +04:00
static int exact_lock ( dev_t devt , void * data )
2005-04-17 02:20:36 +04:00
{
struct gendisk * p = data ;
if ( ! get_disk ( p ) )
return - 1 ;
return 0 ;
}
/**
* add_disk - add partitioning information to kernel list
* @ disk : per - device partitioning information
*
* This function registers the partitioning information in @ disk
* with the kernel .
*/
void add_disk ( struct gendisk * disk )
{
2008-04-30 11:54:32 +04:00
struct backing_dev_info * bdi ;
2008-05-23 01:21:08 +04:00
int retval ;
2008-04-30 11:54:32 +04:00
2005-04-17 02:20:36 +04:00
disk - > flags | = GENHD_FL_UP ;
2008-08-25 14:56:05 +04:00
disk_to_dev ( disk ) - > devt = MKDEV ( disk - > major , disk - > first_minor ) ;
2008-09-03 11:01:48 +04:00
blk_register_region ( disk_devt ( disk ) , disk - > minors , NULL ,
exact_match , exact_lock , disk ) ;
2005-04-17 02:20:36 +04:00
register_disk ( disk ) ;
blk_register_queue ( disk ) ;
2008-04-30 11:54:32 +04:00
bdi = & disk - > queue - > backing_dev_info ;
2008-09-03 11:01:48 +04:00
bdi_register_dev ( bdi , disk_devt ( disk ) ) ;
2008-08-25 14:56:05 +04:00
retval = sysfs_create_link ( & disk_to_dev ( disk ) - > kobj , & bdi - > dev - > kobj ,
" bdi " ) ;
2008-05-23 01:21:08 +04:00
WARN_ON ( retval ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( add_disk ) ;
EXPORT_SYMBOL ( del_gendisk ) ; /* in partitions/check.c */
void unlink_gendisk ( struct gendisk * disk )
{
2008-08-25 14:56:05 +04:00
sysfs_remove_link ( & disk_to_dev ( disk ) - > kobj , " bdi " ) ;
2008-04-30 11:54:32 +04:00
bdi_unregister ( & disk - > queue - > backing_dev_info ) ;
2005-04-17 02:20:36 +04:00
blk_unregister_queue ( disk ) ;
2008-09-03 11:01:48 +04:00
blk_unregister_region ( disk_devt ( disk ) , disk - > minors ) ;
2005-04-17 02:20:36 +04:00
}
/**
* get_gendisk - get partitioning information for a given device
2008-08-19 22:13:11 +04:00
* @ devt : device to get partitioning information for
* @ part : returned partition index
2005-04-17 02:20:36 +04:00
*
* This function gets the structure containing partitioning
2008-08-19 22:13:11 +04:00
* information for the given device @ devt .
2005-04-17 02:20:36 +04:00
*/
2008-09-03 11:01:09 +04:00
struct gendisk * get_gendisk ( dev_t devt , int * partno )
2005-04-17 02:20:36 +04:00
{
2008-08-25 14:47:22 +04:00
struct gendisk * disk = NULL ;
if ( MAJOR ( devt ) ! = BLOCK_EXT_MAJOR ) {
struct kobject * kobj ;
kobj = kobj_lookup ( bdev_map , devt , partno ) ;
if ( kobj )
disk = dev_to_disk ( kobj_to_dev ( kobj ) ) ;
} else {
struct hd_struct * part ;
mutex_lock ( & ext_devt_mutex ) ;
2008-08-25 14:47:25 +04:00
part = idr_find ( & ext_devt_idr , blk_mangle_minor ( MINOR ( devt ) ) ) ;
2008-08-25 14:47:22 +04:00
if ( part & & get_disk ( part_to_disk ( part ) ) ) {
* partno = part - > partno ;
disk = part_to_disk ( part ) ;
}
mutex_unlock ( & ext_devt_mutex ) ;
}
2007-05-22 00:08:01 +04:00
2008-08-25 14:47:22 +04:00
return disk ;
2005-04-17 02:20:36 +04:00
}
2008-09-03 11:01:48 +04:00
/**
* bdget_disk - do bdget ( ) by gendisk and partition number
* @ disk : gendisk of interest
* @ partno : partition number
*
* Find partition @ partno from @ disk , do bdget ( ) on it .
*
* CONTEXT :
* Don ' t care .
*
* RETURNS :
* Resulting block_device on success , NULL on failure .
*/
extern struct block_device * bdget_disk ( struct gendisk * disk , int partno )
{
2008-08-29 11:01:47 +04:00
struct hd_struct * part ;
struct block_device * bdev = NULL ;
2008-09-03 11:01:48 +04:00
2008-08-29 11:01:47 +04:00
part = disk_get_part ( disk , partno ) ;
if ( part & & ( part - > nr_sects | | partno = = 0 ) )
bdev = bdget ( part_devt ( part ) ) ;
disk_put_part ( part ) ;
2008-09-03 11:01:48 +04:00
2008-08-29 11:01:47 +04:00
return bdev ;
2008-09-03 11:01:48 +04:00
}
EXPORT_SYMBOL ( bdget_disk ) ;
2008-05-23 01:21:08 +04:00
/*
* print a full list of all partitions - intended for places where the root
* filesystem can ' t be mounted and thus to give the victim some idea of what
* went wrong
*/
void __init printk_all_partitions ( void )
{
2008-09-03 10:57:12 +04:00
struct class_dev_iter iter ;
struct device * dev ;
class_dev_iter_init ( & iter , & block_class , NULL , & disk_type ) ;
while ( ( dev = class_dev_iter_next ( & iter ) ) ) {
struct gendisk * disk = dev_to_disk ( dev ) ;
2008-09-03 11:03:02 +04:00
struct disk_part_iter piter ;
struct hd_struct * part ;
2008-08-25 14:47:23 +04:00
char name_buf [ BDEVNAME_SIZE ] ;
char devt_buf [ BDEVT_SIZE ] ;
2008-09-03 10:57:12 +04:00
/*
* Don ' t show empty devices or things that have been
* surpressed
*/
if ( get_capacity ( disk ) = = 0 | |
( disk - > flags & GENHD_FL_SUPPRESS_PARTITION_INFO ) )
continue ;
/*
* Note , unlike / proc / partitions , I am showing the
* numbers in hex - the same format as the root =
* option takes .
*/
2008-08-25 14:47:23 +04:00
printk ( " %s %10llu %s " ,
bdevt_str ( disk_devt ( disk ) , devt_buf ) ,
2008-09-03 10:57:12 +04:00
( unsigned long long ) get_capacity ( disk ) > > 1 ,
2008-08-25 14:47:23 +04:00
disk_name ( disk , 0 , name_buf ) ) ;
2008-09-03 10:57:12 +04:00
if ( disk - > driverfs_dev ! = NULL & &
disk - > driverfs_dev - > driver ! = NULL )
printk ( " driver: %s \n " ,
disk - > driverfs_dev - > driver - > name ) ;
else
printk ( " (driver?) \n " ) ;
/* now show the partitions */
2008-09-03 11:03:02 +04:00
disk_part_iter_init ( & piter , disk , 0 ) ;
while ( ( part = disk_part_iter_next ( & piter ) ) )
2008-08-25 14:47:23 +04:00
printk ( " %s %10llu %s \n " ,
bdevt_str ( part_devt ( part ) , devt_buf ) ,
2008-09-03 11:01:48 +04:00
( unsigned long long ) part - > nr_sects > > 1 ,
2008-08-25 14:47:23 +04:00
disk_name ( disk , part - > partno , name_buf ) ) ;
2008-09-03 11:03:02 +04:00
disk_part_iter_exit ( & piter ) ;
2008-09-03 10:57:12 +04:00
}
class_dev_iter_exit ( & iter ) ;
2007-05-09 13:33:24 +04:00
}
2005-04-17 02:20:36 +04:00
# ifdef CONFIG_PROC_FS
/* iterator */
2008-09-03 10:57:12 +04:00
static void * disk_seqf_start ( struct seq_file * seqf , loff_t * pos )
2008-05-23 01:21:08 +04:00
{
2008-09-03 10:57:12 +04:00
loff_t skip = * pos ;
struct class_dev_iter * iter ;
struct device * dev ;
2008-05-23 01:21:08 +04:00
2008-09-03 10:57:12 +04:00
iter = kmalloc ( GFP_KERNEL , sizeof ( * iter ) ) ;
if ( ! iter )
return ERR_PTR ( - ENOMEM ) ;
seqf - > private = iter ;
class_dev_iter_init ( iter , & block_class , NULL , & disk_type ) ;
do {
dev = class_dev_iter_next ( iter ) ;
if ( ! dev )
return NULL ;
} while ( skip - - ) ;
return dev_to_disk ( dev ) ;
2008-05-23 01:21:08 +04:00
}
2008-09-03 10:57:12 +04:00
static void * disk_seqf_next ( struct seq_file * seqf , void * v , loff_t * pos )
2005-04-17 02:20:36 +04:00
{
2007-05-22 00:08:01 +04:00
struct device * dev ;
2005-04-17 02:20:36 +04:00
2008-09-03 10:57:12 +04:00
( * pos ) + + ;
dev = class_dev_iter_next ( seqf - > private ) ;
2008-09-03 10:53:37 +04:00
if ( dev )
2008-05-23 01:21:08 +04:00
return dev_to_disk ( dev ) ;
2008-09-03 10:53:37 +04:00
2005-04-17 02:20:36 +04:00
return NULL ;
}
2008-09-03 10:57:12 +04:00
static void disk_seqf_stop ( struct seq_file * seqf , void * v )
2008-05-23 01:21:08 +04:00
{
2008-09-03 10:57:12 +04:00
struct class_dev_iter * iter = seqf - > private ;
2008-05-23 01:21:08 +04:00
2008-09-03 10:57:12 +04:00
/* stop is called even after start failed :-( */
if ( iter ) {
class_dev_iter_exit ( iter ) ;
kfree ( iter ) ;
2008-08-16 16:30:30 +04:00
}
2005-04-17 02:20:36 +04:00
}
2008-09-03 10:57:12 +04:00
static void * show_partition_start ( struct seq_file * seqf , loff_t * pos )
2005-04-17 02:20:36 +04:00
{
2008-09-03 10:57:12 +04:00
static void * p ;
p = disk_seqf_start ( seqf , pos ) ;
if ( ! IS_ERR ( p ) & & p )
seq_puts ( seqf , " major minor #blocks name \n \n " ) ;
return p ;
2005-04-17 02:20:36 +04:00
}
2008-09-03 11:01:09 +04:00
static int show_partition ( struct seq_file * seqf , void * v )
2005-04-17 02:20:36 +04:00
{
struct gendisk * sgp = v ;
2008-09-03 11:03:02 +04:00
struct disk_part_iter piter ;
struct hd_struct * part ;
2005-04-17 02:20:36 +04:00
char buf [ BDEVNAME_SIZE ] ;
/* Don't show non-partitionable removeable devices or empty devices */
2008-09-03 11:06:42 +04:00
if ( ! get_capacity ( sgp ) | | ( ! disk_partitionable ( sgp ) & &
2008-09-03 11:01:48 +04:00
( sgp - > flags & GENHD_FL_REMOVABLE ) ) )
2005-04-17 02:20:36 +04:00
return 0 ;
if ( sgp - > flags & GENHD_FL_SUPPRESS_PARTITION_INFO )
return 0 ;
/* show the full disk and all non-0 size partitions of it */
2008-08-25 14:47:23 +04:00
seq_printf ( seqf , " %4d %7d %10llu %s \n " ,
2008-09-03 11:01:48 +04:00
MAJOR ( disk_devt ( sgp ) ) , MINOR ( disk_devt ( sgp ) ) ,
2005-04-17 02:20:36 +04:00
( unsigned long long ) get_capacity ( sgp ) > > 1 ,
disk_name ( sgp , 0 , buf ) ) ;
2008-09-03 11:03:02 +04:00
disk_part_iter_init ( & piter , sgp , 0 ) ;
while ( ( part = disk_part_iter_next ( & piter ) ) )
2008-08-25 14:47:23 +04:00
seq_printf ( seqf , " %4d %7d %10llu %s \n " ,
2008-09-03 11:01:48 +04:00
MAJOR ( part_devt ( part ) ) , MINOR ( part_devt ( part ) ) ,
( unsigned long long ) part - > nr_sects > > 1 ,
disk_name ( sgp , part - > partno , buf ) ) ;
2008-09-03 11:03:02 +04:00
disk_part_iter_exit ( & piter ) ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
2008-01-29 22:57:51 +03:00
const struct seq_operations partitions_op = {
2008-09-03 10:57:12 +04:00
. start = show_partition_start ,
. next = disk_seqf_next ,
. stop = disk_seqf_stop ,
2007-05-22 00:08:01 +04:00
. show = show_partition
2005-04-17 02:20:36 +04:00
} ;
# endif
2008-09-03 11:01:09 +04:00
static struct kobject * base_probe ( dev_t devt , int * partno , void * data )
2005-04-17 02:20:36 +04:00
{
2007-05-22 00:08:01 +04:00
if ( request_module ( " block-major-%d-%d " , MAJOR ( devt ) , MINOR ( devt ) ) > 0 )
2005-04-17 02:20:36 +04:00
/* Make old-style 2.4 aliases work */
2007-05-22 00:08:01 +04:00
request_module ( " block-major-%d " , MAJOR ( devt ) ) ;
2005-04-17 02:20:36 +04:00
return NULL ;
}
static int __init genhd_device_init ( void )
{
2008-04-21 21:51:07 +04:00
int error ;
block_class . dev_kobj = sysfs_dev_block_kobj ;
error = class_register ( & block_class ) ;
2008-03-12 03:13:15 +03:00
if ( unlikely ( error ) )
return error ;
2007-05-22 00:08:01 +04:00
bdev_map = kobj_map_init ( base_probe , & block_class_lock ) ;
2005-04-17 02:20:36 +04:00
blk_dev_init ( ) ;
2007-05-22 00:08:01 +04:00
# ifndef CONFIG_SYSFS_DEPRECATED
/* create top-level block dir */
block_depr = kobject_create_and_add ( " block " , NULL ) ;
# endif
2007-11-06 21:36:58 +03:00
return 0 ;
2005-04-17 02:20:36 +04:00
}
subsys_initcall ( genhd_device_init ) ;
2007-05-22 00:08:01 +04:00
static ssize_t disk_range_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
2005-04-17 02:20:36 +04:00
{
2007-05-22 00:08:01 +04:00
struct gendisk * disk = dev_to_disk ( dev ) ;
2005-04-17 02:20:36 +04:00
2007-05-22 00:08:01 +04:00
return sprintf ( buf , " %d \n " , disk - > minors ) ;
2005-04-17 02:20:36 +04:00
}
2008-08-25 14:47:23 +04:00
static ssize_t disk_ext_range_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
{
struct gendisk * disk = dev_to_disk ( dev ) ;
2008-09-03 11:06:42 +04:00
return sprintf ( buf , " %d \n " , disk_max_parts ( disk ) ) ;
2008-08-25 14:47:23 +04:00
}
2007-05-22 00:08:01 +04:00
static ssize_t disk_removable_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
2005-10-01 16:49:43 +04:00
{
2007-05-22 00:08:01 +04:00
struct gendisk * disk = dev_to_disk ( dev ) ;
2005-10-01 16:49:43 +04:00
2007-05-22 00:08:01 +04:00
return sprintf ( buf , " %d \n " ,
( disk - > flags & GENHD_FL_REMOVABLE ? 1 : 0 ) ) ;
2005-10-01 16:49:43 +04:00
}
2008-06-13 11:41:00 +04:00
static ssize_t disk_ro_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
{
struct gendisk * disk = dev_to_disk ( dev ) ;
2008-08-25 14:56:10 +04:00
return sprintf ( buf , " %d \n " , get_disk_ro ( disk ) ? 1 : 0 ) ;
2008-06-13 11:41:00 +04:00
}
2007-05-22 00:08:01 +04:00
static ssize_t disk_capability_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
2007-05-24 00:57:38 +04:00
{
2007-05-22 00:08:01 +04:00
struct gendisk * disk = dev_to_disk ( dev ) ;
return sprintf ( buf , " %x \n " , disk - > flags ) ;
2007-05-24 00:57:38 +04:00
}
2007-05-22 00:08:01 +04:00
static ssize_t disk_stat_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
2005-04-17 02:20:36 +04:00
{
2007-05-22 00:08:01 +04:00
struct gendisk * disk = dev_to_disk ( dev ) ;
2008-08-25 14:47:21 +04:00
int cpu ;
2007-05-22 00:08:01 +04:00
2008-08-25 14:47:21 +04:00
cpu = disk_stat_lock ( ) ;
disk_round_stats ( cpu , disk ) ;
disk_stat_unlock ( ) ;
2007-05-22 00:08:01 +04:00
return sprintf ( buf ,
2006-03-22 10:09:31 +03:00
" %8lu %8lu %8llu %8u "
" %8lu %8lu %8llu %8u "
2005-04-17 02:20:36 +04:00
" %8u %8u %8u "
" \n " ,
2005-11-09 15:38:47 +03:00
disk_stat_read ( disk , ios [ READ ] ) ,
disk_stat_read ( disk , merges [ READ ] ) ,
( unsigned long long ) disk_stat_read ( disk , sectors [ READ ] ) ,
jiffies_to_msecs ( disk_stat_read ( disk , ticks [ READ ] ) ) ,
disk_stat_read ( disk , ios [ WRITE ] ) ,
disk_stat_read ( disk , merges [ WRITE ] ) ,
( unsigned long long ) disk_stat_read ( disk , sectors [ WRITE ] ) ,
jiffies_to_msecs ( disk_stat_read ( disk , ticks [ WRITE ] ) ) ,
2005-04-17 02:20:36 +04:00
disk - > in_flight ,
jiffies_to_msecs ( disk_stat_read ( disk , io_ticks ) ) ,
jiffies_to_msecs ( disk_stat_read ( disk , time_in_queue ) ) ) ;
}
2006-12-08 13:39:46 +03:00
# ifdef CONFIG_FAIL_MAKE_REQUEST
2007-05-22 00:08:01 +04:00
static ssize_t disk_fail_show ( struct device * dev ,
struct device_attribute * attr , char * buf )
{
struct gendisk * disk = dev_to_disk ( dev ) ;
return sprintf ( buf , " %d \n " , disk - > flags & GENHD_FL_FAIL ? 1 : 0 ) ;
}
2006-12-08 13:39:46 +03:00
2007-05-22 00:08:01 +04:00
static ssize_t disk_fail_store ( struct device * dev ,
struct device_attribute * attr ,
2006-12-08 13:39:46 +03:00
const char * buf , size_t count )
{
2007-05-22 00:08:01 +04:00
struct gendisk * disk = dev_to_disk ( dev ) ;
2006-12-08 13:39:46 +03:00
int i ;
if ( count > 0 & & sscanf ( buf , " %d " , & i ) > 0 ) {
if ( i = = 0 )
disk - > flags & = ~ GENHD_FL_FAIL ;
else
disk - > flags | = GENHD_FL_FAIL ;
}
return count ;
}
# endif
2007-05-22 00:08:01 +04:00
static DEVICE_ATTR ( range , S_IRUGO , disk_range_show , NULL ) ;
2008-08-25 14:47:23 +04:00
static DEVICE_ATTR ( ext_range , S_IRUGO , disk_ext_range_show , NULL ) ;
2007-05-22 00:08:01 +04:00
static DEVICE_ATTR ( removable , S_IRUGO , disk_removable_show , NULL ) ;
2008-06-13 11:41:00 +04:00
static DEVICE_ATTR ( ro , S_IRUGO , disk_ro_show , NULL ) ;
2008-08-25 14:56:09 +04:00
static DEVICE_ATTR ( size , S_IRUGO , part_size_show , NULL ) ;
2007-05-22 00:08:01 +04:00
static DEVICE_ATTR ( capability , S_IRUGO , disk_capability_show , NULL ) ;
static DEVICE_ATTR ( stat , S_IRUGO , disk_stat_show , NULL ) ;
2006-12-08 13:39:46 +03:00
# ifdef CONFIG_FAIL_MAKE_REQUEST
2007-05-22 00:08:01 +04:00
static struct device_attribute dev_attr_fail =
__ATTR ( make - it - fail , S_IRUGO | S_IWUSR , disk_fail_show , disk_fail_store ) ;
2006-12-08 13:39:46 +03:00
# endif
2007-05-22 00:08:01 +04:00
static struct attribute * disk_attrs [ ] = {
& dev_attr_range . attr ,
2008-08-25 14:47:23 +04:00
& dev_attr_ext_range . attr ,
2007-05-22 00:08:01 +04:00
& dev_attr_removable . attr ,
2008-06-13 11:41:00 +04:00
& dev_attr_ro . attr ,
2007-05-22 00:08:01 +04:00
& dev_attr_size . attr ,
& dev_attr_capability . attr ,
& dev_attr_stat . attr ,
# ifdef CONFIG_FAIL_MAKE_REQUEST
& dev_attr_fail . attr ,
# endif
NULL
} ;
static struct attribute_group disk_attr_group = {
. attrs = disk_attrs ,
} ;
static struct attribute_group * disk_attr_groups [ ] = {
& disk_attr_group ,
NULL
2005-04-17 02:20:36 +04:00
} ;
2007-05-22 00:08:01 +04:00
static void disk_release ( struct device * dev )
2005-04-17 02:20:36 +04:00
{
2007-05-22 00:08:01 +04:00
struct gendisk * disk = dev_to_disk ( dev ) ;
2005-04-17 02:20:36 +04:00
kfree ( disk - > random ) ;
2008-09-03 11:03:02 +04:00
kfree ( disk - > __part ) ;
2005-04-17 02:20:36 +04:00
free_disk_stats ( disk ) ;
kfree ( disk ) ;
}
2007-05-22 00:08:01 +04:00
struct class block_class = {
. name = " block " ,
2005-04-17 02:20:36 +04:00
} ;
2008-03-04 13:23:46 +03:00
static struct device_type disk_type = {
2007-05-22 00:08:01 +04:00
. name = " disk " ,
. groups = disk_attr_groups ,
. release = disk_release ,
2005-04-17 02:20:36 +04:00
} ;
2008-05-23 20:44:11 +04:00
# ifdef CONFIG_PROC_FS
2008-09-03 11:01:09 +04:00
/*
* aggregate disk stat collector . Uses the same stats that the sysfs
* entries do , above , but makes them available through one seq_file .
*
* The output looks suspiciously like / proc / partitions with a bunch of
* extra fields .
*/
static int diskstats_show ( struct seq_file * seqf , void * v )
2005-04-17 02:20:36 +04:00
{
struct gendisk * gp = v ;
2008-09-03 11:03:02 +04:00
struct disk_part_iter piter ;
struct hd_struct * hd ;
2005-04-17 02:20:36 +04:00
char buf [ BDEVNAME_SIZE ] ;
2008-08-25 14:47:21 +04:00
int cpu ;
2005-04-17 02:20:36 +04:00
/*
2008-08-25 14:56:05 +04:00
if ( & disk_to_dev ( gp ) - > kobj . entry = = block_class . devices . next )
2008-09-03 11:01:09 +04:00
seq_puts ( seqf , " major minor name "
2005-04-17 02:20:36 +04:00
" rio rmerge rsect ruse wio wmerge "
" wsect wuse running use aveq "
" \n \n " ) ;
*/
2008-08-25 14:47:21 +04:00
cpu = disk_stat_lock ( ) ;
disk_round_stats ( cpu , gp ) ;
disk_stat_unlock ( ) ;
2008-08-25 14:47:23 +04:00
seq_printf ( seqf , " %4d %7d %s %lu %lu %llu %u %lu %lu %llu %u %u %u %u \n " ,
2008-09-03 11:01:48 +04:00
MAJOR ( disk_devt ( gp ) ) , MINOR ( disk_devt ( gp ) ) ,
disk_name ( gp , 0 , buf ) ,
2005-11-01 11:26:16 +03:00
disk_stat_read ( gp , ios [ 0 ] ) , disk_stat_read ( gp , merges [ 0 ] ) ,
( unsigned long long ) disk_stat_read ( gp , sectors [ 0 ] ) ,
jiffies_to_msecs ( disk_stat_read ( gp , ticks [ 0 ] ) ) ,
disk_stat_read ( gp , ios [ 1 ] ) , disk_stat_read ( gp , merges [ 1 ] ) ,
( unsigned long long ) disk_stat_read ( gp , sectors [ 1 ] ) ,
jiffies_to_msecs ( disk_stat_read ( gp , ticks [ 1 ] ) ) ,
2005-04-17 02:20:36 +04:00
gp - > in_flight ,
jiffies_to_msecs ( disk_stat_read ( gp , io_ticks ) ) ,
jiffies_to_msecs ( disk_stat_read ( gp , time_in_queue ) ) ) ;
/* now show all non-0 size partitions of it */
2008-09-03 11:03:02 +04:00
disk_part_iter_init ( & piter , gp , 0 ) ;
while ( ( hd = disk_part_iter_next ( & piter ) ) ) {
2008-08-25 14:47:21 +04:00
cpu = disk_stat_lock ( ) ;
part_round_stats ( cpu , hd ) ;
disk_stat_unlock ( ) ;
2008-08-25 14:47:23 +04:00
seq_printf ( seqf , " %4d %7d %s %lu %lu %llu "
2008-02-08 13:04:56 +03:00
" %u %lu %lu %llu %u %u %u %u \n " ,
2008-09-03 11:01:48 +04:00
MAJOR ( part_devt ( hd ) ) , MINOR ( part_devt ( hd ) ) ,
disk_name ( gp , hd - > partno , buf ) ,
2008-02-08 13:04:56 +03:00
part_stat_read ( hd , ios [ 0 ] ) ,
part_stat_read ( hd , merges [ 0 ] ) ,
( unsigned long long ) part_stat_read ( hd , sectors [ 0 ] ) ,
jiffies_to_msecs ( part_stat_read ( hd , ticks [ 0 ] ) ) ,
part_stat_read ( hd , ios [ 1 ] ) ,
part_stat_read ( hd , merges [ 1 ] ) ,
( unsigned long long ) part_stat_read ( hd , sectors [ 1 ] ) ,
jiffies_to_msecs ( part_stat_read ( hd , ticks [ 1 ] ) ) ,
hd - > in_flight ,
jiffies_to_msecs ( part_stat_read ( hd , io_ticks ) ) ,
jiffies_to_msecs ( part_stat_read ( hd , time_in_queue ) )
) ;
2005-04-17 02:20:36 +04:00
}
2008-09-03 11:03:02 +04:00
disk_part_iter_exit ( & piter ) ;
2005-04-17 02:20:36 +04:00
return 0 ;
}
2008-01-29 22:57:51 +03:00
const struct seq_operations diskstats_op = {
2008-09-03 10:57:12 +04:00
. start = disk_seqf_start ,
. next = disk_seqf_next ,
. stop = disk_seqf_stop ,
2005-04-17 02:20:36 +04:00
. show = diskstats_show
} ;
2008-05-23 20:44:11 +04:00
# endif /* CONFIG_PROC_FS */
2005-04-17 02:20:36 +04:00
2007-05-24 00:57:38 +04:00
static void media_change_notify_thread ( struct work_struct * work )
{
struct gendisk * gd = container_of ( work , struct gendisk , async_notify ) ;
char event [ ] = " MEDIA_CHANGE=1 " ;
char * envp [ ] = { event , NULL } ;
/*
* set enviroment vars to indicate which event this is for
* so that user space will know to go check the media status .
*/
2008-08-25 14:56:05 +04:00
kobject_uevent_env ( & disk_to_dev ( gd ) - > kobj , KOBJ_CHANGE , envp ) ;
2007-05-24 00:57:38 +04:00
put_device ( gd - > driverfs_dev ) ;
}
2008-03-04 13:23:46 +03:00
#if 0
2007-05-24 00:57:38 +04:00
void genhd_media_change_notify ( struct gendisk * disk )
{
get_device ( disk - > driverfs_dev ) ;
schedule_work ( & disk - > async_notify ) ;
}
EXPORT_SYMBOL_GPL ( genhd_media_change_notify ) ;
2008-03-04 13:23:46 +03:00
# endif /* 0 */
2007-05-24 00:57:38 +04:00
2008-09-03 11:01:09 +04:00
dev_t blk_lookup_devt ( const char * name , int partno )
2008-05-23 01:21:08 +04:00
{
2008-09-03 10:57:12 +04:00
dev_t devt = MKDEV ( 0 , 0 ) ;
struct class_dev_iter iter ;
struct device * dev ;
2008-05-23 01:21:08 +04:00
2008-09-03 10:57:12 +04:00
class_dev_iter_init ( & iter , & block_class , NULL , & disk_type ) ;
while ( ( dev = class_dev_iter_next ( & iter ) ) ) {
2008-05-23 01:21:08 +04:00
struct gendisk * disk = dev_to_disk ( dev ) ;
2008-08-29 11:01:47 +04:00
struct hd_struct * part ;
2008-05-23 01:21:08 +04:00
2008-09-03 11:01:48 +04:00
if ( strcmp ( dev - > bus_id , name ) )
continue ;
2008-08-29 11:01:47 +04:00
part = disk_get_part ( disk , partno ) ;
if ( part & & ( part - > nr_sects | | partno = = 0 ) ) {
2008-09-03 11:01:48 +04:00
devt = part_devt ( part ) ;
2008-09-03 11:03:02 +04:00
disk_put_part ( part ) ;
2008-08-29 11:01:47 +04:00
break ;
2008-09-03 10:57:12 +04:00
}
2008-08-29 11:01:47 +04:00
disk_put_part ( part ) ;
2008-08-16 16:30:30 +04:00
}
2008-09-03 10:57:12 +04:00
class_dev_iter_exit ( & iter ) ;
2007-05-22 00:08:01 +04:00
return devt ;
}
EXPORT_SYMBOL ( blk_lookup_devt ) ;
2005-04-17 02:20:36 +04:00
struct gendisk * alloc_disk ( int minors )
{
2005-06-23 11:08:19 +04:00
return alloc_disk_node ( minors , - 1 ) ;
}
struct gendisk * alloc_disk_node ( int minors , int node_id )
2008-08-25 14:47:22 +04:00
{
return alloc_disk_ext_node ( minors , 0 , node_id ) ;
}
struct gendisk * alloc_disk_ext ( int minors , int ext_minors )
{
return alloc_disk_ext_node ( minors , ext_minors , - 1 ) ;
}
struct gendisk * alloc_disk_ext_node ( int minors , int ext_minors , int node_id )
2005-06-23 11:08:19 +04:00
{
struct gendisk * disk ;
2007-07-17 15:03:29 +04:00
disk = kmalloc_node ( sizeof ( struct gendisk ) ,
GFP_KERNEL | __GFP_ZERO , node_id ) ;
2005-04-17 02:20:36 +04:00
if ( disk ) {
2008-08-25 14:47:22 +04:00
int tot_minors = minors + ext_minors ;
2008-09-03 11:06:42 +04:00
int size = tot_minors * sizeof ( struct hd_struct * ) ;
2008-08-25 14:47:22 +04:00
2005-04-17 02:20:36 +04:00
if ( ! init_disk_stats ( disk ) ) {
kfree ( disk ) ;
return NULL ;
}
2008-09-03 11:06:42 +04:00
disk - > __part = kmalloc_node ( size , GFP_KERNEL | __GFP_ZERO ,
node_id ) ;
if ( ! disk - > __part ) {
free_disk_stats ( disk ) ;
kfree ( disk ) ;
return NULL ;
2005-04-17 02:20:36 +04:00
}
2008-09-03 11:06:42 +04:00
disk - > __part [ 0 ] = & disk - > part0 ;
2005-04-17 02:20:36 +04:00
disk - > minors = minors ;
2008-08-25 14:47:22 +04:00
disk - > ext_minors = ext_minors ;
2005-04-17 02:20:36 +04:00
rand_initialize_disk ( disk ) ;
2008-08-25 14:56:05 +04:00
disk_to_dev ( disk ) - > class = & block_class ;
disk_to_dev ( disk ) - > type = & disk_type ;
device_initialize ( disk_to_dev ( disk ) ) ;
2007-05-24 00:57:38 +04:00
INIT_WORK ( & disk - > async_notify ,
media_change_notify_thread ) ;
2005-04-17 02:20:36 +04:00
}
return disk ;
}
EXPORT_SYMBOL ( alloc_disk ) ;
2005-06-23 11:08:19 +04:00
EXPORT_SYMBOL ( alloc_disk_node ) ;
2008-08-25 14:47:22 +04:00
EXPORT_SYMBOL ( alloc_disk_ext ) ;
EXPORT_SYMBOL ( alloc_disk_ext_node ) ;
2005-04-17 02:20:36 +04:00
struct kobject * get_disk ( struct gendisk * disk )
{
struct module * owner ;
struct kobject * kobj ;
if ( ! disk - > fops )
return NULL ;
owner = disk - > fops - > owner ;
if ( owner & & ! try_module_get ( owner ) )
return NULL ;
2008-08-25 14:56:05 +04:00
kobj = kobject_get ( & disk_to_dev ( disk ) - > kobj ) ;
2005-04-17 02:20:36 +04:00
if ( kobj = = NULL ) {
module_put ( owner ) ;
return NULL ;
}
return kobj ;
}
EXPORT_SYMBOL ( get_disk ) ;
void put_disk ( struct gendisk * disk )
{
if ( disk )
2008-08-25 14:56:05 +04:00
kobject_put ( & disk_to_dev ( disk ) - > kobj ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( put_disk ) ;
void set_device_ro ( struct block_device * bdev , int flag )
{
2008-08-25 14:56:10 +04:00
bdev - > bd_part - > policy = flag ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( set_device_ro ) ;
void set_disk_ro ( struct gendisk * disk , int flag )
{
2008-09-03 11:03:02 +04:00
struct disk_part_iter piter ;
struct hd_struct * part ;
2008-08-25 14:56:10 +04:00
disk_part_iter_init ( & piter , disk ,
DISK_PITER_INCL_EMPTY | DISK_PITER_INCL_PART0 ) ;
2008-09-03 11:03:02 +04:00
while ( ( part = disk_part_iter_next ( & piter ) ) )
part - > policy = flag ;
disk_part_iter_exit ( & piter ) ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( set_disk_ro ) ;
int bdev_read_only ( struct block_device * bdev )
{
if ( ! bdev )
return 0 ;
2008-08-25 14:56:10 +04:00
return bdev - > bd_part - > policy ;
2005-04-17 02:20:36 +04:00
}
EXPORT_SYMBOL ( bdev_read_only ) ;
2008-09-03 11:01:09 +04:00
int invalidate_partition ( struct gendisk * disk , int partno )
2005-04-17 02:20:36 +04:00
{
int res = 0 ;
2008-09-03 11:01:09 +04:00
struct block_device * bdev = bdget_disk ( disk , partno ) ;
2005-04-17 02:20:36 +04:00
if ( bdev ) {
2005-05-06 03:15:59 +04:00
fsync_bdev ( bdev ) ;
res = __invalidate_device ( bdev ) ;
2005-04-17 02:20:36 +04:00
bdput ( bdev ) ;
}
return res ;
}
EXPORT_SYMBOL ( invalidate_partition ) ;