taglinefilesource code
dev22fs/block_dev.cunsigned int dev;
dev26fs/block_dev.cdev = inode->i_rdev;
dev27fs/block_dev.cif (blk_size[MAJOR(dev)])
dev28fs/block_dev.csize = blk_size[MAJOR(dev)][MINOR(dev)];
dev38fs/block_dev.cbh = getblk(dev, block, BLOCK_SIZE);
dev40fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
dev65fs/block_dev.cunsigned int dev;
dev70fs/block_dev.cdev = inode->i_rdev;
dev71fs/block_dev.cif (blk_size[MAJOR(dev)])
dev72fs/block_dev.csize = blk_size[MAJOR(dev)][MINOR(dev)];
dev81fs/block_dev.cif (!(bh = breada(dev,block,block+1,block+2,-1)))
dev47fs/buffer.cstatic void sync_buffers(int dev)
dev77fs/buffer.cint sync_dev(int dev)
dev81fs/buffer.cif (sb = get_super (dev))
dev84fs/buffer.csync_buffers(dev);
dev86fs/buffer.csync_buffers(dev);
dev90fs/buffer.cvoid inline invalidate_buffers(int dev)
dev97fs/buffer.cif (bh->b_dev != dev)
dev100fs/buffer.cif (bh->b_dev == dev)
dev119fs/buffer.cvoid check_disk_change(int dev)
dev124fs/buffer.cif (MAJOR(dev) != 2)
dev126fs/buffer.cif (!(bh = getblk(dev,0,1024)))
dev133fs/buffer.cif (super_block[i].s_dev == dev)
dev135fs/buffer.cinvalidate_inodes(dev);
dev136fs/buffer.cinvalidate_buffers(dev);
dev139fs/buffer.c#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
dev140fs/buffer.c#define hash(dev,block) hash_table[_hashfn(dev,block)]
dev217fs/buffer.cstatic struct buffer_head * find_buffer(int dev, int block, int size)
dev221fs/buffer.cfor (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
dev222fs/buffer.cif (tmp->b_dev==dev && tmp->b_blocknr==block)
dev226fs/buffer.cprintk("wrong block-size on device %04x\n",dev);
dev239fs/buffer.cstruct buffer_head * get_hash_table(int dev, int block, int size)
dev244fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
dev248fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size) {
dev267fs/buffer.cstruct buffer_head * getblk(int dev, int block, int size)
dev273fs/buffer.cif (bh = get_hash_table(dev, block, size))
dev315fs/buffer.cif (find_buffer(dev,block,size))
dev323fs/buffer.cbh->b_dev=dev;
dev343fs/buffer.cstruct buffer_head * bread(int dev, int block, int size)
dev347fs/buffer.cif (!(bh = getblk(dev, block, size))) {
dev374fs/buffer.cvoid bread_page(unsigned long address,int dev,int b[4])
dev381fs/buffer.cif (bh[i] = getblk(dev, b[i], 1024))
dev400fs/buffer.cstruct buffer_head * breada(int dev,int first, ...)
dev406fs/buffer.cif (!(bh = getblk(dev, first, 1024))) {
dev413fs/buffer.ctmp = getblk(dev, first, 1024);
dev85fs/ext/bitmap.cint ext_free_block(int dev, int block)
dev91fs/ext/bitmap.cif (!(sb = get_super(dev)))
dev95fs/ext/bitmap.cbh = get_hash_table(dev,block);
dev111fs/ext/bitmap.cprintk("free_block (%04x:%d): bit already cleared\n",dev,block);
dev116fs/ext/bitmap.cint ext_new_block(int dev)
dev122fs/ext/bitmap.cif (!(sb = get_super(dev)))
dev137fs/ext/bitmap.cif (!(bh=getblk(dev,j)))
dev193fs/ext/bitmap.cstruct inode * ext_new_inode(int dev)
dev201fs/ext/bitmap.cif (!(inode->i_sb = get_super(dev))) {
dev224fs/ext/bitmap.cinode->i_dev = dev;
dev49fs/ext/freelists.cint ext_free_block(int dev, int block)
dev55fs/ext/freelists.cif (!(sb = get_super(dev)))
dev60fs/ext/freelists.cbh = get_hash_table(dev, block, sb->s_blocksize);
dev80fs/ext/freelists.cif (!(sb->u.ext_sb.s_zmap[1] = bread (dev, block, sb->s_blocksize)))
dev96fs/ext/freelists.cint ext_new_block(int dev)
dev103fs/ext/freelists.cif (!(sb = get_super(dev)))
dev122fs/ext/freelists.cif (!(sb->u.ext_sb.s_zmap[1] = bread (dev, (unsigned long) sb->u.ext_sb.s_zmap[0], sb->s_blocksize)))
dev133fs/ext/freelists.cif (!(bh=getblk(dev, j, sb->s_blocksize)))
dev241fs/ext/freelists.cstruct inode * ext_new_inode(int dev)
dev250fs/ext/freelists.cif (!(inode->i_sb = get_super(dev))) {
dev279fs/ext/freelists.cif (!(inode->i_sb->u.ext_sb.s_imap[1] = bread (dev, block, inode->i_sb->s_blocksize)))
dev287fs/ext/freelists.cinode->i_dev = dev;
dev23fs/ext/inode.cint sync_dev(int dev);
dev69fs/ext/inode.cint dev = s->s_dev,block;
dev75fs/ext/inode.cif (!(bh = bread(dev, 1, BLOCK_SIZE))) {
dev115fs/ext/inode.cif (s->u.ext_sb.s_imap[i]=bread(dev, block, BLOCK_SIZE))
dev120fs/ext/inode.cif (s->u.ext_sb.s_zmap[i]=bread(dev, block, BLOCK_SIZE))
dev141fs/ext/inode.cif (!(s->u.ext_sb.s_zmap[1] = bread(dev, (unsigned long) s->u.ext_sb.s_zmap[0], BLOCK_SIZE))) {
dev151fs/ext/inode.cif (!(s->u.ext_sb.s_imap[1] = bread(dev, block, BLOCK_SIZE))) {
dev163fs/ext/inode.cs->s_dev = dev;
dev165fs/ext/inode.cif (!(s->s_mounted = iget(dev,EXT_ROOT_INO))) {
dev77fs/inode.cvoid invalidate_inodes(int dev)
dev85fs/inode.cif (inode->i_dev == dev) {
dev202fs/inode.cstruct inode * iget(int dev,int nr)
dev206fs/inode.cif (!dev)
dev211fs/inode.cif (inode->i_dev != dev || inode->i_ino != nr) {
dev216fs/inode.cif (inode->i_dev != dev || inode->i_ino != nr) {
dev248fs/inode.cif (!(inode->i_sb = get_super(dev))) {
dev253fs/inode.cinode->i_dev = dev;
dev76fs/minix/bitmap.cint minix_free_block(int dev, int block)
dev82fs/minix/bitmap.cif (!(sb = get_super(dev)))
dev86fs/minix/bitmap.cbh = get_hash_table(dev,block,BLOCK_SIZE);
dev102fs/minix/bitmap.cprintk("free_block (%04x:%d): bit already cleared\n",dev,block);
dev107fs/minix/bitmap.cint minix_new_block(int dev)
dev113fs/minix/bitmap.cif (!(sb = get_super(dev)))
dev128fs/minix/bitmap.cif (!(bh=getblk(dev,j,BLOCK_SIZE)))
dev181fs/minix/bitmap.cstruct inode * minix_new_inode(int dev)
dev189fs/minix/bitmap.cif (!(inode->i_sb = get_super(dev))) {
dev212fs/minix/bitmap.cinode->i_dev = dev;
dev17fs/minix/inode.cint sync_dev(int dev);
dev53fs/minix/inode.cint i,dev=s->s_dev,block;
dev56fs/minix/inode.cif (!(bh = bread(dev,1,BLOCK_SIZE))) {
dev85fs/minix/inode.cif (s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE))
dev90fs/minix/inode.cif (s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE))
dev108fs/minix/inode.cs->s_dev = dev;
dev110fs/minix/inode.cif (!(s->s_mounted = iget(dev,MINIX_ROOT_INO))) {
dev289fs/namei.cint do_mknod(const char * filename, int mode, int dev)
dev313fs/namei.creturn dir->i_op->mknod(dir,basename,namelen,mode,dev);
dev316fs/namei.cint sys_mknod(const char * filename, int mode, int dev)
dev319fs/namei.creturn do_mknod(filename,mode,dev);
dev28fs/open.cint sys_ustat(int dev, struct ustat * ubuf)
dev22fs/super.cint sync_dev(int dev);
dev79fs/super.cstruct super_block * get_super(int dev)
dev83fs/super.cif (!dev)
dev87fs/super.cif (s->s_dev == dev) {
dev89fs/super.cif (s->s_dev == dev)
dev97fs/super.cvoid put_super(int dev)
dev101fs/super.cif (dev == ROOT_DEV) {
dev105fs/super.cif (!(sb = get_super(dev)))
dev115fs/super.cstatic struct super_block * read_super(int dev,char *name,int flags,void *data)
dev120fs/super.cif (!dev)
dev122fs/super.ccheck_disk_change(dev);
dev123fs/super.cif (s = get_super(dev))
dev135fs/super.cs->s_dev = dev;
dev139fs/super.cs->s_dev = dev;
dev146fs/super.cstatic int do_umount(int dev)
dev151fs/super.cif (dev==ROOT_DEV)
dev153fs/super.cif (!(sb=get_super(dev)) || !(sb->s_covered))
dev158fs/super.cif (inode->i_dev==dev && inode->i_count)
dev170fs/super.cput_super(dev);
dev177fs/super.cint dev,retval;
dev183fs/super.cdev = inode->i_rdev;
dev188fs/super.cretval = do_umount(dev);
dev189fs/super.cif (!retval && MAJOR(dev) < MAX_BLKDEV &&
dev190fs/super.cblkdev_fops[MAJOR(dev)]->release)
dev191fs/super.cblkdev_fops[MAJOR(dev)]->release(inode,NULL);
dev194fs/super.csync_dev(dev);
dev207fs/super.cstatic int do_mount(int dev, const char * dir, char * type, int flags, void * data)
dev223fs/super.cif (inode->i_dev != dev)
dev231fs/super.csb = read_super(dev,type,flags,data);
dev258fs/super.cint dev;
dev269fs/super.cdev = inode->i_rdev;
dev274fs/super.cif (!retval && blkdev_fops[MAJOR(dev)]->open)
dev275fs/super.cretval = blkdev_fops[MAJOR(dev)]->open(inode,NULL);
dev298fs/super.cretval = do_mount(dev,dir_name,t,flags,(void *) page);
dev300fs/super.cif (retval && blkdev_fops[MAJOR(dev)]->release)
dev301fs/super.cblkdev_fops[MAJOR(dev)]->release(inode,NULL);
dev95include/linux/ext_fs.hextern struct inode * ext_new_inode(int dev);
dev98include/linux/ext_fs.hextern int ext_new_block(int dev);
dev99include/linux/ext_fs.hextern int ext_free_block(int dev, int block);
dev233include/linux/fs.hextern void check_disk_change(int dev);
dev234include/linux/fs.hextern void invalidate_inodes(int dev);
dev236include/linux/fs.hextern int ticks_to_floppy_on(unsigned int dev);
dev237include/linux/fs.hextern void floppy_on(unsigned int dev);
dev238include/linux/fs.hextern void floppy_off(unsigned int dev);
dev249include/linux/fs.hextern int do_mknod(const char * filename, int mode, int dev);
dev251include/linux/fs.hextern struct inode * iget(int dev,int nr);
dev255include/linux/fs.hextern struct buffer_head * get_hash_table(int dev, int block, int size);
dev256include/linux/fs.hextern struct buffer_head * getblk(int dev, int block, int size);
dev258include/linux/fs.hextern void ll_rw_page(int rw, int dev, int nr, char * buffer);
dev259include/linux/fs.hextern void ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buffer);
dev261include/linux/fs.hextern struct buffer_head * bread(int dev, int block, int size);
dev262include/linux/fs.hextern void bread_page(unsigned long addr,int dev,int b[4]);
dev263include/linux/fs.hextern struct buffer_head * breada(int dev,int block,...);
dev264include/linux/fs.hextern int sync_dev(int dev);
dev265include/linux/fs.hextern struct super_block * get_super(int dev);
dev266include/linux/fs.hextern void put_super(int dev);
dev62include/linux/minix_fs.hextern struct inode * minix_new_inode(int dev);
dev65include/linux/minix_fs.hextern int minix_new_block(int dev);
dev66include/linux/minix_fs.hextern int minix_free_block(int dev, int block);
dev99include/linux/msdos_fs.hstatic inline struct buffer_head *msdos_sread(int dev,int sector,void **start)
dev103include/linux/msdos_fs.hif (!(bh = bread(dev,sector >> 1, 1024)))
dev253include/linux/tty.hextern int  pty_open(unsigned int dev, struct file * filp);
dev254include/linux/tty.hextern void pty_close(unsigned int dev, struct file * filp);
dev24kernel/blk_drv/blk.hint dev;    /* -1 if no request */
dev44kernel/blk_drv/blk.h((s1)->dev < (s2)->dev || (((s1)->dev == (s2)->dev && \
dev72kernel/blk_drv/blk.hextern int is_read_only(int dev);
dev73kernel/blk_drv/blk.hextern void set_device_ro(int dev,int flag);
dev75kernel/blk_drv/blk.h#define RO_IOCTLS(dev,where) \
dev77kernel/blk_drv/blk.hset_device_ro((dev),get_fs_long((long *) (where))); return 0; \
dev79kernel/blk_drv/blk.hput_fs_long(is_read_only(dev),(long *) (where)); return 0;
dev145kernel/blk_drv/blk.h#define CURRENT_DEV DEVICE_NR(CURRENT->dev)
dev189kernel/blk_drv/blk.hprintk("dev %04x, sector %d\n\r",req->dev,req->sector);
dev211kernel/blk_drv/blk.hDEVICE_OFF(req->dev);
dev214kernel/blk_drv/blk.hreq->dev = -1;
dev229kernel/blk_drv/blk.hif (MAJOR(CURRENT->dev) != MAJOR_NR) \
dev216kernel/blk_drv/floppy.c(CURRENT->dev))
dev558kernel/blk_drv/floppy.cint drive = MINOR(CURRENT->dev);
dev911kernel/blk_drv/floppy.cif (MAJOR(CURRENT->dev) != MAJOR_NR)
dev32kernel/blk_drv/genhd.cstatic void extended_partition(struct gendisk *hd, int dev)
dev39kernel/blk_drv/genhd.cfirst_sector = hd->part[MINOR(dev)].start_sect;
dev45kernel/blk_drv/genhd.cif (!(bh = bread(dev,0,1024))) {
dev46kernel/blk_drv/genhd.cprintk("Unable to read partition table of device %04x\n",dev);
dev84kernel/blk_drv/genhd.cdev = ((hd->major) << 8) | current_minor;
dev93kernel/blk_drv/genhd.cstatic void check_partition(struct gendisk *hd, unsigned int dev)
dev100kernel/blk_drv/genhd.cfirst_sector = hd->part[MINOR(dev)].start_sect;
dev102kernel/blk_drv/genhd.cif (!(bh = bread(dev,0,1024))) {
dev103kernel/blk_drv/genhd.cprintk("Unable to read partition table of device %04x\n",dev);
dev145kernel/blk_drv/genhd.cprintk("Bad partition table on dev %04x\n",dev);
dev149kernel/blk_drv/genhd.cstatic void setup_dev(struct gendisk *dev)
dev152kernel/blk_drv/genhd.cint j = dev->max_nr * dev->max_p;
dev153kernel/blk_drv/genhd.cint major = dev->major << 8;
dev158kernel/blk_drv/genhd.cdev->part[i].start_sect = 0;
dev159kernel/blk_drv/genhd.cdev->part[i].nr_sects = 0;
dev161kernel/blk_drv/genhd.cdev->init();  
dev162kernel/blk_drv/genhd.cfor (drive=0 ; drive<dev->nr_real ; drive++) {
dev163kernel/blk_drv/genhd.ccurrent_minor = 1+(drive<<dev->minor_shift);
dev164kernel/blk_drv/genhd.ccheck_partition(dev, major+(drive<<dev->minor_shift));
dev167kernel/blk_drv/genhd.cdev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
dev168kernel/blk_drv/genhd.cblk_size[dev->major] = dev->sizes;
dev274kernel/blk_drv/hd.cMINOR(CURRENT->dev), CURRENT->sector, i, CURRENT-> 
dev380kernel/blk_drv/hd.cunsigned int block,dev;
dev389kernel/blk_drv/hd.cdev = MINOR(CURRENT->dev);
dev392kernel/blk_drv/hd.cif (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) {
dev395kernel/blk_drv/hd.cblock, hd[dev].nr_sects);
dev400kernel/blk_drv/hd.cblock += hd[dev].start_sect;
dev401kernel/blk_drv/hd.cdev >>= 6;
dev402kernel/blk_drv/hd.csec = block % hd_info[dev].sect;
dev403kernel/blk_drv/hd.cblock /= hd_info[dev].sect;
dev404kernel/blk_drv/hd.chead = block % hd_info[dev].head;
dev405kernel/blk_drv/hd.ccyl = block / hd_info[dev].head;
dev409kernel/blk_drv/hd.cdev, cyl, head, sec, CURRENT->buffer);
dev420kernel/blk_drv/hd.chd_out(dev,hd_info[dev].sect,0,0,0,WIN_RESTORE,&recal_intr);
dev427kernel/blk_drv/hd.chd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr);
dev438kernel/blk_drv/hd.chd_out(dev,nsect,sec,head,cyl,WIN_READ,&read_intr);
dev450kernel/blk_drv/hd.cint dev;
dev454kernel/blk_drv/hd.cdev = MINOR(inode->i_rdev) >> 6;
dev455kernel/blk_drv/hd.cif (dev >= NR_HD)
dev460kernel/blk_drv/hd.cput_fs_byte(hd_info[dev].head,
dev462kernel/blk_drv/hd.cput_fs_byte(hd_info[dev].sect,
dev464kernel/blk_drv/hd.cput_fs_word(hd_info[dev].cyl,
dev79kernel/blk_drv/ll_rw_blk.cint is_read_only(int dev)
dev83kernel/blk_drv/ll_rw_blk.cmajor = MAJOR(dev);
dev84kernel/blk_drv/ll_rw_blk.cminor = MINOR(dev);
dev89kernel/blk_drv/ll_rw_blk.cvoid set_device_ro(int dev,int flag)
dev93kernel/blk_drv/ll_rw_blk.cmajor = MAJOR(dev);
dev94kernel/blk_drv/ll_rw_blk.cminor = MINOR(dev);
dev108kernel/blk_drv/ll_rw_blk.cstatic void add_request(struct blk_dev_struct * dev, struct request * req)
dev116kernel/blk_drv/ll_rw_blk.cif (!(tmp = dev->current_request)) {
dev117kernel/blk_drv/ll_rw_blk.cdev->current_request = req;
dev118kernel/blk_drv/ll_rw_blk.c(dev->request_fn)();
dev174kernel/blk_drv/ll_rw_blk.cif (req->dev == bh->b_dev &&
dev198kernel/blk_drv/ll_rw_blk.cif (req->dev < 0)
dev212kernel/blk_drv/ll_rw_blk.creq->dev = bh->b_dev;
dev226kernel/blk_drv/ll_rw_blk.cvoid ll_rw_page(int rw, int dev, int page, char * buffer)
dev229kernel/blk_drv/ll_rw_blk.cunsigned int major = MAJOR(dev);
dev232kernel/blk_drv/ll_rw_blk.cprintk("Trying to read nonexistent block-device %04x (%d)\n",dev,page*8);
dev237kernel/blk_drv/ll_rw_blk.cif (rw == WRITE && is_read_only(dev)) {
dev238kernel/blk_drv/ll_rw_blk.cprintk("Can't page to read-only device 0x%X\n\r",dev);
dev245kernel/blk_drv/ll_rw_blk.cif (req->dev<0)
dev253kernel/blk_drv/ll_rw_blk.creq->dev = dev;
dev298kernel/blk_drv/ll_rw_blk.crequest[i].dev = -1;
dev308kernel/blk_drv/ll_rw_blk.cvoid ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buf)
dev312kernel/blk_drv/ll_rw_blk.cunsigned int major = MAJOR(dev);
dev323kernel/blk_drv/ll_rw_blk.cif (rw == WRITE && is_read_only(dev)) {
dev324kernel/blk_drv/ll_rw_blk.cprintk("Can't swap to read-only device 0x%X\n\r",dev);
dev333kernel/blk_drv/ll_rw_blk.cif (req->dev<0)
dev340kernel/blk_drv/ll_rw_blk.creq->dev = dev;
dev34kernel/blk_drv/ramdisk.cif ((MINOR(CURRENT->dev) != 1) || (addr+len > rd_start+rd_length)) {
dev127kernel/blk_drv/scsi/scsi.cint host_nr , dev, lun, type, maxed, slave;
dev137kernel/blk_drv/scsi/scsi.cfor (dev = 0; dev < 7; ++dev)
dev138kernel/blk_drv/scsi/scsi.cif (scsi_hosts[host_nr].this_id != dev)
dev160kernel/blk_drv/scsi/scsi.cscsi_do_cmd (host_nr, dev, (void *)  scsi_cmd, (void *)                   
dev175kernel/blk_drv/scsi/scsi.cid = dev;
dev210kernel/blk_drv/scsi/scsi.cprintk("Detected scsi tape at host %d, ID  %d, lun %d \n", host_nr, dev, lun);
dev219kernel/blk_drv/scsi/scsi.cprintk("Detected scsi disk at host %d, ID  %d, lun %d \n", host_nr, dev, lun);
dev232kernel/blk_drv/scsi/scsi.cdev, lun);
dev262kernel/blk_drv/scsi/scsi.c,host_nr , dev, lun, p); 
dev30kernel/blk_drv/scsi/scsi_ioctl.cstatic int ioctl_probe(int dev, void *buffer)
dev35kernel/blk_drv/scsi/scsi_ioctl.cif ((temp = scsi_hosts[dev].present) && buffer) {
dev37kernel/blk_drv/scsi/scsi_ioctl.cmemcpy_tofs (buffer, scsi_hosts[dev].info(), len);
dev73kernel/blk_drv/scsi/scsi_ioctl.cstatic int ioctl_command(Scsi_Device *dev, void *buffer)
dev92kernel/blk_drv/scsi/scsi_ioctl.chost = dev->host_no;
dev108kernel/blk_drv/scsi/scsi_ioctl.cscsi_do_cmd(host,  dev->id,  cmd,  buf,  ((outlen > MAX_BUF) ? 
dev121kernel/blk_drv/scsi/scsi_ioctl.cprintk("scsi_ioctl : device %d.  command = ", dev->id);
dev142kernel/blk_drv/scsi/scsi_ioctl.cint scsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
dev144kernel/blk_drv/scsi/scsi_ioctl.cif ((cmd != 0 && dev->id > NR_SCSI_DEVICES))
dev146kernel/blk_drv/scsi/scsi_ioctl.cif ((cmd == 0 && dev->host_no > MAX_SCSI_HOSTS))
dev151kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_probe(dev->host_no, arg);
dev153kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_command((Scsi_Device *) dev, arg);
dev102kernel/blk_drv/scsi/sd.cprintk("sd%d : rw_intr(%d, %x)\n", MINOR(CURRENT->dev), host, result);
dev115kernel/blk_drv/scsi/sd.cprintk("sd%d : %d sectors remain.\n", MINOR(CURRENT->dev), CURRENT->nr_sectors);
dev132kernel/blk_drv/scsi/sd.cMINOR(CURRENT->dev));
dev144kernel/blk_drv/scsi/sd.cprintk("sd%d :  handling linked buffer request\n", MINOR(CURRENT->dev));
dev174kernel/blk_drv/scsi/sd.cif rscsi_disks[DEVICE_NR(CURRENT->dev)].remap
dev191kernel/blk_drv/scsi/sd.cif (rscsi_disks[DEVICE_NR(CURRENT->dev)].ten) {
dev192kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(CURRENT->dev)].ten = 0;
dev201kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(CURRENT->dev)].device->host_no, 
dev202kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(CURRENT->dev)].device->id,
dev203kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(CURRENT->dev)].device->lun);
dev223kernel/blk_drv/scsi/sd.cint dev, block;
dev228kernel/blk_drv/scsi/sd.cdev =  MINOR(CURRENT->dev);
dev232kernel/blk_drv/scsi/sd.cprintk("Doing sd request, dev = %d, block = %d\n", dev, block);
dev235kernel/blk_drv/scsi/sd.cif (dev >= (NR_SD << 4) || block + CURRENT->nr_sectors > sd[dev].nr_sects) 
dev241kernel/blk_drv/scsi/sd.cblock += sd[dev].start_sect;
dev242kernel/blk_drv/scsi/sd.cdev = DEVICE_NR(dev);
dev245kernel/blk_drv/scsi/sd.cprintk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(CURRENT->dev), dev, block);
dev255kernel/blk_drv/scsi/sd.cprintk("sd%d : %s %d/%d 512 byte blocks.\n", MINOR(CURRENT->dev), 
dev263kernel/blk_drv/scsi/sd.cif (!rscsi_disks[dev].device->writeable)
dev280kernel/blk_drv/scsi/sd.cif (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten) 
dev47kernel/blk_drv/scsi/sd.h#define HOST (rscsi_disks[DEVICE_NR(CURRENT->dev)].device->host_no)
dev48kernel/blk_drv/scsi/sd.h#define ID (rscsi_disks[DEVICE_NR(CURRENT->dev)].device->id)
dev49kernel/blk_drv/scsi/sd.h#define LUN (rscsi_disks[DEVICE_NR(CURRENT->dev)].device->lun)
dev9kernel/blk_drv/scsi/sd_ioctl.cextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
dev13kernel/blk_drv/scsi/sd_ioctl.cint dev = inode->i_rdev;
dev17kernel/blk_drv/scsi/sd_ioctl.creturn scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device, cmd, (void *) arg);
dev8kernel/blk_drv/scsi/st_ioctl.cextern int scsi_ioctl(Scsi_Device *dev, int cmd, void *arg);
dev12kernel/blk_drv/scsi/st_ioctl.cint dev = inode->i_rdev;
dev16kernel/blk_drv/scsi/st_ioctl.creturn scsi_ioctl(scsi_tapes[MINOR(dev)].device, cmd, (void *) arg);
dev23kernel/chr_drv/pty.cint pty_open(unsigned int dev, struct file * filp)
dev27kernel/chr_drv/pty.ctty = tty_table + dev;
dev40kernel/chr_drv/pty.cvoid pty_close(unsigned int dev, struct file * filp)
dev44kernel/chr_drv/pty.ctty = tty_table + dev;
dev47kernel/chr_drv/pty.cif (IS_A_PTY_MASTER(dev)) {
dev505kernel/chr_drv/tty_io.cint dev, retval;
dev507kernel/chr_drv/tty_io.cdev = inode->i_rdev;
dev508kernel/chr_drv/tty_io.cif (MAJOR(dev) == 5)
dev509kernel/chr_drv/tty_io.cdev = current->tty;
dev511kernel/chr_drv/tty_io.cdev = MINOR(dev);
dev512kernel/chr_drv/tty_io.cif (dev < 0)
dev514kernel/chr_drv/tty_io.cfilp->f_rdev = 0x0400 | dev;
dev515kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev521kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev)) {
dev533kernel/chr_drv/tty_io.ccurrent->tty = dev;
dev537kernel/chr_drv/tty_io.cif (IS_A_SERIAL(dev) && tty->count < 2)
dev538kernel/chr_drv/tty_io.cretval = serial_open(dev-64,filp);
dev539kernel/chr_drv/tty_io.celse if (IS_A_PTY(dev))
dev540kernel/chr_drv/tty_io.cretval = pty_open(dev,filp);
dev543kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev) && tty->link)
dev556kernel/chr_drv/tty_io.cint dev;
dev559kernel/chr_drv/tty_io.cdev = filp->f_rdev;
dev560kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev564kernel/chr_drv/tty_io.cdev = MINOR(filp->f_rdev);
dev565kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev566kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev) && tty->link)
dev571kernel/chr_drv/tty_io.cif (IS_A_SERIAL(dev)) {
dev573kernel/chr_drv/tty_io.cserial_close(dev-64,filp);
dev574kernel/chr_drv/tty_io.c} else if (IS_A_PTY(dev))
dev575kernel/chr_drv/tty_io.cpty_close(dev,filp);
dev585kernel/chr_drv/tty_io.cint dev;
dev588kernel/chr_drv/tty_io.cdev = filp->f_rdev;
dev589kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev593kernel/chr_drv/tty_io.cdev = MINOR(filp->f_rdev);
dev594kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev22kernel/chr_drv/tty_ioctl.cextern int vt_ioctl(struct tty_struct *tty, int dev, int cmd, int arg);
dev235kernel/chr_drv/tty_ioctl.cint dev;
dev241kernel/chr_drv/tty_ioctl.cdev = MINOR(file->f_rdev);
dev242kernel/chr_drv/tty_ioctl.ctty = tty_table + (dev ? ((dev < 64)? dev-1:dev) : fg_console);
dev244kernel/chr_drv/tty_ioctl.cif (IS_A_PTY(dev))
dev245kernel/chr_drv/tty_ioctl.cother_tty = tty_table + PTY_OTHER(dev);
dev261kernel/chr_drv/tty_ioctl.creturn set_termios(tty,(struct termios *) arg, dev);
dev270kernel/chr_drv/tty_ioctl.creturn set_termio(tty,(struct termio *) arg, dev);
dev272kernel/chr_drv/tty_ioctl.cif (!IS_A_SERIAL(dev))
dev276kernel/chr_drv/tty_ioctl.csend_break(dev-64);
dev321kernel/chr_drv/tty_ioctl.c(current->tty != dev) ||
dev348kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev))
dev374kernel/chr_drv/tty_ioctl.cif (!IS_A_PTY(dev))
dev380kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev))
dev386kernel/chr_drv/tty_ioctl.cif (!IS_A_SERIAL(dev))
dev389kernel/chr_drv/tty_ioctl.creturn get_serial_info(dev-64,(struct serial_struct *) arg);
dev391kernel/chr_drv/tty_ioctl.cif (!IS_A_SERIAL(dev))
dev393kernel/chr_drv/tty_ioctl.creturn set_serial_info(dev-64,(struct serial_struct *) arg);
dev412kernel/chr_drv/tty_ioctl.creturn vt_ioctl(tty, dev, cmd, arg);
dev70kernel/chr_drv/vt.cvt_ioctl(struct tty_struct *tty, int dev, int cmd, int arg)
dev72kernel/chr_drv/vt.cint console = dev ? dev - 1 : fg_console;
dev75kernel/chr_drv/vt.cif (!IS_A_CONSOLE(dev) || console < 0 || console >= NR_CONSOLES)