/*
* This routine checks whether a floppy has been changed, and
* invalidates all buffer-cache-entries in that case. This
* is a relatively slow routine, so we have to try to minimize using
* it. Thus it is called only upon a 'mount' or 'open'. This
* is the best way of combining speed and utility, I think.
* People changing diskettes in the middle of an operation deserve
* to loose :-)
*
* NOTE! Although currently this is only for floppies, the idea is
* that any additional removable block-device will use this routine,
* and that mount/open needn't know that floppies/whatever are
* special.
*/
void check_disk_change(int dev)
{
int i;
struct buffer_head * bh;
switch(MAJOR(dev)){
case 2: /* floppy disc */
if (!(bh = getblk(dev,0,1024)))
return;
i = floppy_change(bh);
brelse(bh);
break;
#if defined(CONFIG_BLK_DEV_SR) && defined(CONFIG_SCSI)
case 11: /* CDROM */
i = check_cdrom_media_change(dev, 0);
if (i) printk("Flushing buffers and inodes for CDROM\n");
break;
#endif
default:
return;
};
if (!i) return;
for (i=0 ; i<NR_SUPER ; i++)
if (super_block[i].s_dev == dev)
put_super(super_block[i].s_dev);
invalidate_inodes(dev);
invalidate_buffers(dev);
}
static int __minix1_rw_inode(struct inode *inode, int rw)
{
struct buffer *buf;
struct minix1_inode *m1;
long block;
struct super *super = get_super(inode->i_dev);
struct minix_s_ext *s_ext = (struct minix_s_ext*) super->s_ext;
block = 2 + s_ext->s_imap_blocks
+ s_ext->s_zmap_blocks
+ (inode->i_ino - 1) / INODES_PER_BLOCK;
put_super(super);
buf = bread(inode->i_dev, block);
m1 = (struct minix1_inode *) buf->b_data
+ (inode->i_ino - 1) % INODES_PER_BLOCK;
if (rw) {
m1_read_inode(inode, m1);
} else {
m1_write_inode(inode, m1);
buf->b_flag|=B_DIRTY;
}
brelse(buf);
return 0;
}
//// 检查磁盘是否更换，如果已更换就使对应高速缓冲区无效。
void
check_disk_change( int dev )
{
int i;
// 是软盘设备吗？如果不是则退出。
if( MAJOR( dev ) != 2 )
{
return;
}
// 测试对应软盘是否已更换，如果没有则退出。
if( !floppy_change( dev & 0x03 ) )
{
return;
}
// 软盘已经更换，所以释放对应设备的i 节点位图和逻辑块位图所占的高速缓冲区；并使该设备的
// i 节点和数据块信息所占的高速缓冲区无效。
for( i = 0; i < NR_SUPER; i++ )
{
if( super_block[i].s_dev == dev )
{
put_super( super_block[i].s_dev );
}
}
invalidate_inodes( dev );
invalidate_buffers( dev );
}
/*
* This routine checks whether a removable media has been changed,
* and invalidates all buffer-cache-entries in that case. This
* is a relatively slow routine, so we have to try to minimize using
* it. Thus it is called only upon a 'mount' or 'open'. This
* is the best way of combining speed and utility, I think.
* People changing diskettes in the middle of an operation deserve
* to loose :-)
*/
int check_disk_change(kdev_t dev)
{
int i;
struct file_operations * fops;
i = MAJOR(dev);
if (i >= MAX_BLKDEV || (fops = blkdevs[i].fops) == NULL)
return 0;
if (fops->check_media_change == NULL)
return 0;
if (!fops->check_media_change(dev))
return 0;
printk(KERN_DEBUG "VFS: Disk change detected on device %s\n",
kdevname(dev));
for (i=0 ; i<NR_SUPER ; i++)
if (super_blocks[i].s_dev == dev)
put_super(super_blocks[i].s_dev);
invalidate_inodes(dev);
invalidate_buffers(dev);
if (fops->revalidate)
fops->revalidate(dev);
return 1;
}
static int do_umount(dev_t dev)
{
struct super_block * sb;
//int retval;
if (dev == ROOT_DEV) {
// Special case for "unmounting" root. We just try to remount
// it readonly, and sync() the device.
/*if (!(sb=get_super(dev)))
return -ENOENT;
if (!(sb->s_flags & MS_RDONLY)) {
fsync_dev(dev);
retval = do_remount_sb(sb, MS_RDONLY, 0);
if (retval)
return retval;
}
return 0;*/
return -ENOTSUP;
}
if (!(sb = get_super(dev)) || !(sb->s_covered))
return -ENOENT;
if (!sb->s_covered->i_mount)
kprintf("VFS: umount: mounted inode has i_mount=NULL\n");
//if (!fs_may_umount(dev, sb->s_mounted))
// return -EBUSY;
sb->s_covered->i_mount = NULL;
iput(sb->s_covered);
sb->s_covered = NULL;
iput(sb->s_mounted);
sb->s_mounted = NULL;
if (sb->s_op && sb->s_op->write_super && sb->s_dirt)
sb->s_op->write_super(sb);
put_super(dev);
return 0;
}
/*
* This routine checks whether a floppy has been changed, and
* invalidates all buffer-cache-entries in that case. This
* is a relatively slow routine, so we have to try to minimize using
* it. Thus it is called only upon a 'mount' or 'open'. This
* is the best way of combining speed and utility, I think.
* People changing diskettes in the middle of an operation deserve
* to loose :-)
*
* NOTE! Although currently this is only for floppies, the idea is
* that any additional removable block-device will use this routine,
* and that mount/open needn't know that floppies/whatever are
* special.
*/
void check_disk_change(dev_t dev)
{
int i;
struct buffer_head * bh;
switch(MAJOR(dev)){
case FLOPPY_MAJOR:
if (!(bh = getblk(dev,0,1024)))
return;
i = floppy_change(bh);
brelse(bh);
break;
#if defined(CONFIG_BLK_DEV_SD) && defined(CONFIG_SCSI)
case SCSI_DISK_MAJOR:
i = check_scsidisk_media_change(dev, 0);
break;
#endif
#if defined(CONFIG_BLK_DEV_SR) && defined(CONFIG_SCSI)
case SCSI_CDROM_MAJOR:
i = check_cdrom_media_change(dev, 0);
break;
#endif
#if defined(CONFIG_CDU31A)
case CDU31A_CDROM_MAJOR:
i = check_cdu31a_media_change(dev, 0);
break;
#endif
#if defined(CONFIG_MCD)
case MITSUMI_CDROM_MAJOR:
i = check_mcd_media_change(dev, 0);
break;
#endif
default:
return;
};
if (!i) return;
printk("VFS: Disk change detected on device %d/%d\n",
MAJOR(dev), MINOR(dev));
for (i=0 ; i<NR_SUPER ; i++)
if (super_blocks[i].s_dev == dev)
put_super(super_blocks[i].s_dev);
invalidate_inodes(dev);
invalidate_buffers(dev);
#if defined(CONFIG_BLK_DEV_SD) && defined(CONFIG_SCSI)
/* This is trickier for a removable hardisk, because we have to invalidate
all of the partitions that lie on the disk. */
if (MAJOR(dev) == SCSI_DISK_MAJOR)
revalidate_scsidisk(dev, 0);
#endif
}
void set_free_blocks(int dev, int change)
{
SUPER* sp = get_super(dev);
sp->s_free_blocks_count += change;
put_super(dev, sp);
GD* gp = get_gd(dev);
gp->bg_free_blocks_count += change;
put_gd(dev, gp);
}
static void clean_main(struct sb *sb, struct inode *inode)
{
log_finish(sb);
log_finish_cycle(sb, 1);
free_map(inode->map);
destroy_defer_bfree(&sb->derollup);
destroy_defer_bfree(&sb->defree);
tux3_clear_dirty_inode(sb->logmap);
invalidate_buffers(sb->volmap->map);
tux3_clear_dirty_inode(sb->volmap);
put_super(sb);
tux3_exit_mem();
}
static int do_umount(kdev_t dev,int unmount_root)
{
struct super_block * sb;
int retval;
if (dev==ROOT_DEV && !unmount_root) {
/*
* Special case for "unmounting" root. We just try to remount
* it readonly, and sync() the device.
*/
if (!(sb=get_super(dev)))
return -ENOENT;
if (!(sb->s_flags & MS_RDONLY)) {
/*
* Make sure all quotas are turned off on this device we need to mount
* it readonly so no more writes by the quotasystem.
* If later on the remount fails too bad there are no quotas running
* anymore. Turn them on again by hand.
*/
quota_off(dev, -1);
fsync_dev(dev);
retval = do_remount_sb(sb, MS_RDONLY, 0);
if (retval)
return retval;
}
return 0;
}
if (!(sb=get_super(dev)) || !(sb->s_covered))
return -ENOENT;
if (!sb->s_covered->i_mount)
printk("VFS: umount(%s): mounted inode has i_mount=NULL\n",
kdevname(dev));
/*
* Before checking if the filesystem is still busy make sure the kernel
* doesn't hold any quotafiles open on that device. If the umount fails
* too bad there are no quotas running anymore. Turn them on again by hand.
*/
quota_off(dev, -1);
if (!fs_may_umount(dev, sb->s_mounted))
return -EBUSY;
sb->s_covered->i_mount = NULL;
iput(sb->s_covered);
sb->s_covered = NULL;
iput(sb->s_mounted);
sb->s_mounted = NULL;
if (sb->s_op && sb->s_op->write_super && sb->s_dirt)
sb->s_op->write_super(sb);
put_super(dev);
remove_vfsmnt(dev);
return 0;
}
/*
* This routine checks whether a floppy has been changed, and
* invalidates all buffer-cache-entries in that case. This
* is a relatively slow routine, so we have to try to minimize using
* it. Thus it is called only upon a 'mount' or 'open'. This
* is the best way of combining speed and utility, I think.
* People changing diskettes in the middle of an operation deserve
* to loose :-)
*
* NOTE! Although currently this is only for floppies, the idea is
* that any additional removable block-device will use this routine,
* and that mount/open needn't know that floppies/whatever are
* special.
*/
void check_disk_change(int dev)
{
int i;
if (MAJOR(dev) != 2)
return;
if (!floppy_change(dev & 0x03))
return;
for (i=0 ; i<NR_SUPER ; i++)
if (super_block[i].s_dev == dev)
put_super(super_block[i].s_dev);
invalidate_inodes(dev);
invalidate_buffers(dev);
}
/*
* This routine checks whether a floppy has been changed, and
* invalidates all buffer-cache-entries in that case. This
* is a relatively slow routine, so we have to try to minimize using
* it. Thus it is called only upon a 'mount' or 'open'. This
* is the best way of combining speed and utility, I think.
* People changing diskettes in the middle of an operation deserve
* to loose :-)
*
* NOTE! Although currently this is only for floppies, the idea is
* that any additional removable block-device will use this routine,
* and that mount/open needn't know that floppies/whatever are
* special.
*/
void check_disk_change(int dev)
{
int i;
struct buffer_head * bh;
if (MAJOR(dev) != 2)
return;
if (!(bh = getblk(dev,0)))
return;
i = floppy_change(bh);
brelse(bh);
if (!i)
return;
for (i=0 ; i<NR_SUPER ; i++)
if (super_block[i].s_dev == dev)
put_super(super_block[i].s_dev);
invalidate_inodes(dev);
invalidate_buffers(dev);
}
static int do_umount(kdev_t dev)
{
register struct super_block *sb;
register struct super_operations *sop;
int retval = -ENOENT;
if ((sb = get_super(dev))) {
if (dev == ROOT_DEV) {
/* Special case for "unmounting" root. We just try to remount
* it readonly, and sync() the device.
*/
retval = 0;
if (!(sb->s_flags & MS_RDONLY)) {
fsync_dev(dev);
retval = do_remount_sb(sb, MS_RDONLY, 0);
}
}
else if (sb->s_covered) {
if (!sb->s_covered->i_mount)
panic("umount: i_mount=NULL\n");
if (!fs_may_umount(dev, sb->s_mounted))
retval = -EBUSY;
else {
retval = 0;
sb->s_covered->i_mount = NULL;
iput(sb->s_covered);
sb->s_covered = NULL;
iput(sb->s_mounted);
sb->s_mounted = NULL;
sop = sb->s_op;
if (sop && sop->write_super && sb->s_dirt)
sop->write_super(sb);
put_super(dev);
}
}
}
return retval;
}
static void clean_main(struct sb *sb, struct inode *inode)
{
iput(inode);
put_super(sb);
tux3_exit_mem();
}
static void clean_main(struct sb *sb)
{
put_super(sb);
tux3_exit_mem();
}
