taglinefilesource code
block2155drivers/block/floppy.cint block;
block2168drivers/block/floppy.cblock = current_count_sectors + CURRENT->sector;
block2169drivers/block/floppy.cINFBOUND(DRS->maxblock, block);
block2170drivers/block/floppy.cif (block > _floppy->sect)
block3487drivers/block/floppy.cint block;
block3498drivers/block/floppy.cblock = (filp->f_pos + count) >> 9;
block3499drivers/block/floppy.cINFBOUND(UDRS->maxblock, block);
block696drivers/block/hd.cunsigned int dev, block, nsect, sec, track, head, cyl;
block711drivers/block/hd.cblock = CURRENT->sector;
block713drivers/block/hd.cif (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects || ((block+nsect) > hd[dev].nr_sects)) {
block720drivers/block/hd.c(MINOR(CURRENT->rq_dev)>>6)+'a', block, nsect);
block725drivers/block/hd.cblock += hd[dev].start_sect;
block732drivers/block/hd.csec   = block % hd_info[dev].sect + 1;
block733drivers/block/hd.ctrack = block / hd_info[dev].sect;
block1156drivers/block/ide-cd.cstatic void cdrom_start_read (ide_drive_t *drive, unsigned int block)
block1164drivers/block/ide-cd.crq->sector = block;
block1413drivers/block/ide-cd.cvoid ide_do_rw_cdrom (ide_drive_t *drive, unsigned long block)
block1427drivers/block/ide-cd.ccdrom_start_read (drive, block);
block851drivers/block/ide-tape.cvoid idetape_create_locate_cmd (idetape_packet_command_t *pc,unsigned long block,byte partition);
block930drivers/block/ide-tape.cint idetape_position_tape (ide_drive_t *drive,unsigned long block);
block2478drivers/block/ide-tape.cvoid idetape_create_locate_cmd (idetape_packet_command_t *pc,unsigned long block,byte partition)
block2498drivers/block/ide-tape.c*ptr=idetape_swap_long (block);
block2895drivers/block/ide-tape.cvoid idetape_do_request (ide_drive_t *drive, struct request *rq, unsigned long block)
block4206drivers/block/ide-tape.cint idetape_position_tape (ide_drive_t *drive,unsigned long block)
block4212drivers/block/ide-tape.cidetape_create_locate_cmd (&pc,block,0);
block1245drivers/block/ide.cstatic inline void do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
block1268drivers/block/ide.cblock, rq->nr_sectors, (unsigned long) rq->buffer);
block1270drivers/block/ide.cOUT_BYTE(block,io_base+IDE_SECTOR_OFFSET);
block1271drivers/block/ide.cOUT_BYTE(block>>=8,io_base+IDE_LCYL_OFFSET);
block1272drivers/block/ide.cOUT_BYTE(block>>=8,io_base+IDE_HCYL_OFFSET);
block1273drivers/block/ide.cOUT_BYTE(((block>>8)&0x0f)|drive->select.all,io_base+IDE_SELECT_OFFSET);
block1276drivers/block/ide.ctrack = block / drive->sect;
block1277drivers/block/ide.csect  = block % drive->sect + 1;
block1366drivers/block/ide.cunsigned long block, blockend;
block1387drivers/block/ide.cblock    = rq->sector;
block1388drivers/block/ide.cblockend = block + rq->nr_sectors;
block1389drivers/block/ide.cif ((blockend < block) || (blockend > drive->part[minor&PARTN_MASK].nr_sects)) {
block1391drivers/block/ide.c(minor&PARTN_MASK)?'0'+(minor&PARTN_MASK):' ', block, rq->nr_sectors);
block1394drivers/block/ide.cblock += drive->part[minor&PARTN_MASK].start_sect + drive->sect0;
block1396drivers/block/ide.cif (block == 0 && drive->remap_0_to_1)
block1397drivers/block/ide.cblock = 1;  /* redirect MBR access to EZ-Drive partn table */
block1422drivers/block/ide.cdo_rw_disk (drive, rq, block);
block1426drivers/block/ide.cide_do_rw_cdrom (drive, block);
block1431drivers/block/ide.cidetape_do_request (drive, rq, block);
block1441drivers/block/ide.cdo_rw_disk (drive, rq, block); /* simpler and faster */
block645drivers/block/ide.hvoid idetape_do_request (ide_drive_t *drive, struct request *rq, unsigned long block);
block113drivers/block/linear.clong block, rblock;
block120drivers/block/linear.cblock=req->sector >> 1;
block121drivers/block/linear.chash=data->hash_table+(block/data->smallest->size);
block123drivers/block/linear.cif (block >= (hash->dev0->size + hash->dev0->offset))
block126drivers/block/linear.cprintk ("linear_map : hash->dev1==NULL for block %ld\n", block);
block132drivers/block/linear.cif (block >= (tmp_dev->size + tmp_dev->offset) || block < tmp_dev->offset)
block133drivers/block/linear.cprintk ("Block %ld out of bounds on dev %04x size %d offset %d\n", block, tmp_dev->dev, tmp_dev->size, tmp_dev->offset);
block135drivers/block/linear.crblock=(block-(tmp_dev->offset));
block148drivers/block/loop.cint  real_block, block, offset, len, blksize, size;
block171drivers/block/loop.cblock = CURRENT->sector * (512/blksize);
block174drivers/block/loop.cblock = CURRENT->sector / (blksize >> 9);
block177drivers/block/loop.cblock += lo->lo_offset / blksize;
block180drivers/block/loop.cblock++;
block192drivers/block/loop.creal_block = block;
block194drivers/block/loop.creal_block = bmap(lo->lo_inode, block);
block196drivers/block/loop.cprintk("loop: block %d not present\n", block);
block204drivers/block/loop.cblock, blksize);
block222drivers/block/loop.cprintk("loop: transfer error block %d\n", block);
block232drivers/block/loop.cblock++;
block189drivers/block/raid0.clong block, rblock;
block197drivers/block/raid0.cblock=req->sector >> 1;
block198drivers/block/raid0.chash=data->hash_table+(block/data->smallest->size);
block200drivers/block/raid0.cif (block >= (hash->zone0->size +
block204drivers/block/raid0.cprintk ("raid0_map : hash->zone1==NULL for block %ld\n", block);
block210drivers/block/raid0.cblk_in_chunk=block & ((1UL << FACTOR_SHIFT(factor)) - 1);
block211drivers/block/raid0.cchunk=(block - zone->zone_offset) / (zone->nb_dev<<FACTOR_SHIFT(factor));
block212drivers/block/raid0.ctmp_dev=zone->dev[(block >> FACTOR_SHIFT(factor)) % zone->nb_dev];
block212drivers/block/xd.cu_int block,count,retry;
block222drivers/block/xd.cblock = CURRENT->sector + xd[MINOR(CURRENT->rq_dev)].start_sect;
block229drivers/block/xd.ccode = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
block334drivers/block/xd.cstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count)
block341drivers/block/xd.cprintk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
block348drivers/block/xd.ctrack = block / xd_info[drive].sectors;
block351drivers/block/xd.csector = block % xd_info[drive].sectors;
block378drivers/block/xd.ccount -= temp, buffer += temp * 0x200, block += temp;
block1268drivers/cdrom/cdu31a.cunsigned int  block,
block1287drivers/cdrom/cdu31a.cif (((block % 4) * 512) != ((2048 - readahead_dataleft) % 2048))
block1289drivers/cdrom/cdu31a.csony_next_block += block % 4;
block1290drivers/cdrom/cdu31a.csony_blocks_left -= block % 4;
block1291drivers/cdrom/cdu31a.cskip = (block % 4) * 512;
block1475drivers/cdrom/cdu31a.cint block;
block1559drivers/cdrom/cdu31a.cblock = CURRENT->sector;
block1573drivers/cdrom/cdu31a.cif (block < 80)
block1576drivers/cdrom/cdu31a.cblock += (sony_toc.start_track_lba * 4);
block1587drivers/cdrom/cdu31a.cif ((block / 4) < sony_toc.start_track_lba)
block1594drivers/cdrom/cdu31a.cif ((block / 4) >= sony_toc.lead_out_start_lba)
block1600drivers/cdrom/cdu31a.cif (((block + nblock) / 4) >= sony_toc.lead_out_start_lba)
block1624drivers/cdrom/cdu31a.cif (start_request(block / 4, CDU31A_READAHEAD / 4, 0))
block1633drivers/cdrom/cdu31a.celse if (block != sony_next_block)
block1637drivers/cdrom/cdu31a.cblock,
block1647drivers/cdrom/cdu31a.cif (start_request(block / 4, CDU31A_READAHEAD / 4, 0))
block1655drivers/cdrom/cdu31a.cread_data_block(CURRENT->buffer, block, nblock, res_reg, &res_size);
block261drivers/cdrom/gscd.cunsigned int block,dev;
block268drivers/cdrom/gscd.cblock = CURRENT->sector;
block299drivers/cdrom/gscd.cprintk ("GSCD: dev %d, block %d, nsect %d\n", dev, block, nsect );
block315drivers/cdrom/gscd.clong   block;
block337drivers/cdrom/gscd.cblock = CURRENT -> sector / 4;
block338drivers/cdrom/gscd.cgscd_hsg2msf(block, &gscdcmd.start);  /* cvt to msf format */
block2752drivers/cdrom/sbpcd.cint block, checksum;
block2764drivers/cdrom/sbpcd.cfor (block=CD_MSF_OFFSET+1;block<CD_MSF_OFFSET+200;block++)
block2772drivers/cdrom/sbpcd.cdrvcmd[1]=(block>>16)&0xFF;
block2773drivers/cdrom/sbpcd.cdrvcmd[2]=(block>>8)&0xFF;
block2774drivers/cdrom/sbpcd.cdrvcmd[3]=block&0xFF;
block2783drivers/cdrom/sbpcd.cdrvcmd[2]=(block>>16)&0xFF;
block2784drivers/cdrom/sbpcd.cdrvcmd[3]=(block>>8)&0xFF;
block2785drivers/cdrom/sbpcd.cdrvcmd[4]=block&0xFF;
block4146drivers/cdrom/sbpcd.cint i=0, j=0, frame, block;
block4171drivers/cdrom/sbpcd.cblock=msf2lba(&read_audio.addr.msf.minute);
block4173drivers/cdrom/sbpcd.cblock=read_audio.addr.lba;
block4180drivers/cdrom/sbpcd.cblock, blk2msf(block));
block4212drivers/cdrom/sbpcd.cdrvcmd[1]=(block>>16)&0x000000ff;
block4213drivers/cdrom/sbpcd.cdrvcmd[2]=(block>>8)&0x000000ff;
block4214drivers/cdrom/sbpcd.cdrvcmd[3]=block&0x000000ff;
block4222drivers/cdrom/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bin format required */
block4230drivers/cdrom/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bin format required */
block4412drivers/cdrom/sbpcd.cu_int block;
block4442drivers/cdrom/sbpcd.cblock = CURRENT->sector; /* always numbered as 512-byte-pieces */
block4445drivers/cdrom/sbpcd.cmsg(DBG_BSZ,"read sector %d (%d sectors)\n", block, nsect);
block4447drivers/cdrom/sbpcd.cmsg(DBG_MUL,"read LBA %d\n", block/4);
block4506drivers/cdrom/sbpcd.cint block;
block4510drivers/cdrom/sbpcd.cblock=CURRENT->sector/4;
block4511drivers/cdrom/sbpcd.cif (block+D_S[d].sbp_bufsiz <= D_S[d].CDsize_frm)
block4515drivers/cdrom/sbpcd.cD_S[d].sbp_read_frames=D_S[d].CDsize_frm-block;
block4520drivers/cdrom/sbpcd.cblock, D_S[d].CDsize_frm);
block4530drivers/cdrom/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bcd format required */
block4545drivers/cdrom/sbpcd.cdrvcmd[1]=(block>>16)&0x0ff;
block4546drivers/cdrom/sbpcd.cdrvcmd[2]=(block>>8)&0x0ff;
block4547drivers/cdrom/sbpcd.cdrvcmd[3]=block&0x0ff;
block4556drivers/cdrom/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bcd format required */
block4563drivers/cdrom/sbpcd.cdrvcmd[1]=(block>>16)&0x0ff;
block4564drivers/cdrom/sbpcd.cdrvcmd[2]=(block>>8)&0x0ff;
block4565drivers/cdrom/sbpcd.cdrvcmd[3]=block&0x0ff;
block4575drivers/cdrom/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bin format required */
block4582drivers/cdrom/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bin format required */
block4590drivers/cdrom/sbpcd.cdrvcmd[2]=(block>>24)&0x0ff;
block4591drivers/cdrom/sbpcd.cdrvcmd[3]=(block>>16)&0x0ff;
block4592drivers/cdrom/sbpcd.cdrvcmd[4]=(block>>8)&0x0ff;
block4593drivers/cdrom/sbpcd.cdrvcmd[5]=block&0x0ff;
block787drivers/cdrom/sonycd535.cint  block;
block808drivers/cdrom/sonycd535.cblock = CURRENT->sector;
block821drivers/cdrom/sonycd535.cif (sony_toc->lead_out_start_lba <= (block / 4)) {
block825drivers/cdrom/sonycd535.cif (sony_toc->lead_out_start_lba <= ((block + nsect) / 4)) {
block834drivers/cdrom/sonycd535.cif ((block < sony_first_block) || (sony_last_block < block)) {
block835drivers/cdrom/sonycd535.csony_first_block = (block / 4) * 4;
block836drivers/cdrom/sonycd535.clog_to_msf(block / 4, params);
block842drivers/cdrom/sonycd535.cif (sony_toc->lead_out_start_lba <= ((block / 4) + sony_buffer_sectors)) {
block844drivers/cdrom/sonycd535.cread_size = sony_toc->lead_out_start_lba - (block / 4);
block909drivers/cdrom/sonycd535.ccopyoff = block - sony_first_block;
block913drivers/cdrom/sonycd535.cblock += 1;
block52drivers/char/ftape/ftape-eof.hextern int ftape_file_no(daddr_t * file, daddr_t * block);
block4773drivers/scsi/advansys.c(unsigned) s->hostt, (unsigned) s->block);
block302drivers/scsi/hosts.cretval->block = NULL;
block267drivers/scsi/hosts.hstruct Scsi_Host * block;
block107drivers/scsi/scsi.c#define SCSI_BLOCK(HOST) ((HOST->block && host_active && HOST != host_active) \
block353drivers/scsi/scsi.cif (block_count == 1) sh[0]->block = NULL;
block358drivers/scsi/scsi.csh[index]->block = sh[index + 1];
block363drivers/scsi/scsi.csh[block_count - 1]->block = sh[0];
block1323drivers/scsi/scsi.cif (host->block) host_active = host;
block1778drivers/scsi/scsi.cif (host->block && host->host_busy == 0) {
block1786drivers/scsi/scsi.cfor (next = host->block; next != host; next = next->block)
block2064drivers/scsi/scsi.cif (!host->block) host->host_busy++;
block2070drivers/scsi/scsi.cif (!host->block) host->host_busy--;
block530drivers/scsi/scsi.hif (SCpnt->host->block) {
block533drivers/scsi/scsi.hfor (next = SCpnt->host->block; next != SCpnt->host;
block534drivers/scsi/scsi.hnext = next->block)
block87drivers/scsi/scsi_debug.cif ((bh->b_blocknr << 1) + start != block)          \
block88drivers/scsi/scsi_debug.c{   printk("Wrong bh block# %d %d ",bh->b_blocknr, block);  \
block101drivers/scsi/scsi_debug.cif (SCpnt->request.sector + start != block) panic("Wrong block.");  \
block105drivers/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
block106drivers/scsi/scsi_debug.c{   printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
block177drivers/scsi/scsi_debug.cint block, start;
block266drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
block268drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
block302drivers/scsi/scsi_debug.cif(block == 0 && target == 0) {
block318drivers/scsi/scsi_debug.cif (SCpnt->use_sg) printk("Block %x (%d %d)\n",block, SCpnt->request.nr_sectors,
block324drivers/scsi/scsi_debug.cif(block == 0xfff0) {
block347drivers/scsi/scsi_debug.cmemcpy(buff+60, &block, sizeof(block));
block355drivers/scsi/scsi_debug.cblock += bufflen >> 9;
block379drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
block381drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
block391drivers/scsi/scsi_debug.cif (block != *((unsigned long *) (buff+60))) {
block392drivers/scsi/scsi_debug.cprintk("%x %x :",block,  *((unsigned long *) (buff+60)));
block508drivers/scsi/sd.cint dev, devm, block, this_count;
block525drivers/scsi/sd.cblock = SCpnt->request.sector;
block529drivers/scsi/sd.cprintk("Doing sd request, dev = %d, block = %d\n", devm, block);
block534drivers/scsi/sd.cblock + SCpnt->request.nr_sectors > sd[devm].nr_sects)
block540drivers/scsi/sd.cblock += sd[devm].start_sect;
block555drivers/scsi/sd.c'a' + devm, dev, block);
block570drivers/scsi/sd.cif((block & 1) || (SCpnt->request.nr_sectors & 1)) {
block844drivers/scsi/sd.cif(block & 1) panic("sd.c:Bad block number requested");
block846drivers/scsi/sd.cblock = block >> 1;
block851drivers/scsi/sd.cblock = block << 1;
block855drivers/scsi/sd.cif (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
block861drivers/scsi/sd.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
block862drivers/scsi/sd.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
block863drivers/scsi/sd.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
block864drivers/scsi/sd.ccmd[5] = (unsigned char) block & 0xff;
block874drivers/scsi/sd.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
block875drivers/scsi/sd.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
block876drivers/scsi/sd.ccmd[3] = (unsigned char) block & 0xff;
block646drivers/scsi/sr.cunsigned int dev, block, realcount;
block659drivers/scsi/sr.cblock = SCpnt->request.sector;  
block838drivers/scsi/sr.cstart = block % 4;
block860drivers/scsi/sr.cblock = block >> 2; /* These are the sectors that the cdrom uses */
block862drivers/scsi/sr.cblock = block & 0xfffffffc;
block868drivers/scsi/sr.cif (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) 
block877drivers/scsi/sr.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
block878drivers/scsi/sr.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
block879drivers/scsi/sr.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
block880drivers/scsi/sr.ccmd[5] = (unsigned char) block & 0xff;
block893drivers/scsi/sr.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
block894drivers/scsi/sr.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
block895drivers/scsi/sr.ccmd[3] = (unsigned char) block & 0xff;
block903drivers/scsi/sr.cprintk("ReadCD: %d %d %d %d\n",block, realcount, buffer, this_count);
block90drivers/sound/opl3.cstatic void     freq_to_fnum (int freq, int *block, int *fnum);
block529drivers/sound/opl3.cint             block, fnum, freq, voice_mode;
block706drivers/sound/opl3.cfreq_to_fnum (freq, &block, &fnum);
block717drivers/sound/opl3.cdata = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
block727drivers/sound/opl3.cfreq_to_fnum (int freq, int *block, int *fnum)
block765drivers/sound/opl3.c*block = octave;
block995drivers/sound/opl3.cint             block, fnum, freq;
block1014drivers/sound/opl3.cfreq_to_fnum (freq, &block, &fnum);
block1021drivers/sound/opl3.cdata = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);  /*
block240drivers/sound/pss.cpss_download_boot (pss_config * devc, unsigned char *block, int size, int flags)
block255drivers/sound/pss.coutw (*block++, REG (PSS_DATA));
block285drivers/sound/pss.coutw (*block++, REG (PSS_DATA));
block438drivers/sound/sscape.csscape_download_boot (struct sscape_info *devc, unsigned char *block, int size, int flag)
block484drivers/sound/sscape.cmemcpy (audio_devs[devc->my_audiodev]->dmap_out->raw_buf, block, size);
block26fs/block_dev.cint block, blocks;
block56fs/block_dev.cblock = filp->f_pos >> blocksize_bits;
block64fs/block_dev.cif (block >= size)
block72fs/block_dev.cbh = getblk(dev, block, blocksize);
block74fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
block77fs/block_dev.cfor(i=0; i<blocks_per_cluster; i++) cluster_list[i] = block+i;
block78fs/block_dev.cif((block % blocks_per_cluster) == 0)
block80fs/block_dev.cbh = getblk(dev, block, blocksize);
block87fs/block_dev.cbh = bread(dev,block,blocksize);
block91fs/block_dev.cif (block + blocks > size) blocks = size - block;
block93fs/block_dev.cexcess = (block + blocks) % blocks_per_cluster;
block98fs/block_dev.cif(((i+block) % blocks_per_cluster) == 0) {
block99fs/block_dev.cfor(j=0; j<blocks_per_cluster; j++) cluster_list[j] = block+i+j;
block102fs/block_dev.cbhlist[i] = getblk (dev, block+i, blocksize);
block115fs/block_dev.cblock++;
block162fs/block_dev.cunsigned int block;
block210fs/block_dev.cblock = offset >> blocksize_bits;
block218fs/block_dev.cexcess = (block + blocks) % blocks_per_cluster;
block225fs/block_dev.cif (block + blocks > size)
block226fs/block_dev.cblocks = size - block;
block244fs/block_dev.cif((block % blocks_per_cluster) == 0) {
block245fs/block_dev.cfor(i=0; i<blocks_per_cluster; i++) cluster_list[i] = block+i;
block249fs/block_dev.c*bhb = getblk(dev, block++, blocksize);
block314fs/buffer.c#define _hashfn(dev,block) (((unsigned)(HASHDEV(dev)^block))%nr_hash)
block315fs/buffer.c#define hash(dev,block) hash_table[_hashfn(dev,block)]
block463fs/buffer.cstatic inline struct buffer_head * find_buffer(kdev_t dev, int block, int size)
block467fs/buffer.cfor (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
block468fs/buffer.cif (tmp->b_blocknr == block && tmp->b_dev == dev)
block486fs/buffer.cstruct buffer_head * get_hash_table(kdev_t dev, int block, int size)
block491fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
block495fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block
block748fs/buffer.cstruct buffer_head * getblk(kdev_t dev, int block, int size)
block760fs/buffer.cbh = get_hash_table(dev, block, size);
block773fs/buffer.cif (find_buffer(dev,block,size))
block785fs/buffer.cbh->b_blocknr=block;
block883fs/buffer.cstruct buffer_head * bread(kdev_t dev, int block, int size)
block887fs/buffer.cif (!(bh = getblk(dev, block, size))) {
block910fs/buffer.cstruct buffer_head * breada(kdev_t dev, int block, int bufsize,
block922fs/buffer.cif (block < 0 || !(bh = getblk(dev,block,bufsize)))
block940fs/buffer.cbh = getblk(dev,block+i,bufsize);
block1138fs/buffer.cint block, nr;
block1160fs/buffer.cblock = *(b++);
block1165fs/buffer.cnext->b_blocknr = block;
block1175fs/buffer.cif (bmap && !block) {
block1180fs/buffer.ctmp = get_hash_table(dev, block, size);
block1294fs/buffer.cunsigned long block, address;
block1304fs/buffer.cblock = page->offset >> inode->i_sb->s_blocksize_bits;
block1307fs/buffer.c*p = inode->i_op->bmap(inode, block);
block1309fs/buffer.cblock++;
block1727fs/buffer.cstatic unsigned long try_to_generate_cluster(kdev_t dev, int block, int size)
block1743fs/buffer.cnblock = block;
block1757fs/buffer.cbh->b_blocknr = block++;
block78fs/ext/file.cint block, blocks, offset;
block104fs/ext/file.cblock = offset >> BLOCK_SIZE_BITS;
block112fs/ext/file.cif (block + blocks > size)
block113fs/ext/file.cblocks = size - block;
block131fs/ext/file.c*bhb = ext_getblk(inode, block++, 0);
block40fs/ext/freelists.cvoid ext_free_block(struct super_block * sb, int block)
block50fs/ext/freelists.cif (block < sb->u.ext_sb.s_firstdatazone ||
block51fs/ext/freelists.cblock >= sb->u.ext_sb.s_nzones) {
block55fs/ext/freelists.cbh = get_hash_table(sb->s_dev, block, sb->s_blocksize);
block63fs/ext/freelists.cprintk("ext_free_block: block full, skipping to %d\n", block);
block68fs/ext/freelists.cblock, sb->s_blocksize)))
block73fs/ext/freelists.csb->u.ext_sb.s_firstfreeblocknumber = block;
block75fs/ext/freelists.cefb->free[efb->count++] = block;
block145fs/ext/freelists.cunsigned long count, block;
block153fs/ext/freelists.cblock = efb->next;
block154fs/ext/freelists.cwhile (block) {
block155fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
block157fs/ext/freelists.cblock = 0;
block161fs/ext/freelists.cblock = efb->next;
block180fs/ext/freelists.cunsigned long block;
block221fs/ext/freelists.cblock = 2 + (ino - 1) / EXT_INODES_PER_BLOCK;
block222fs/ext/freelists.cif (!(bh = bread(dev, block, sb->s_blocksize)))
block244fs/ext/freelists.cunsigned long block;
block270fs/ext/freelists.cblock = 2 + (((unsigned long) efi->next) - 1) / EXT_INODES_PER_BLOCK;
block276fs/ext/freelists.cbread(sb->s_dev, block, sb->s_blocksize)))
block305fs/ext/freelists.cunsigned long count, block, ino;
block321fs/ext/freelists.cblock = 2 + ((ino - 1) / EXT_INODES_PER_BLOCK);
block322fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
block324fs/ext/freelists.cblock = 0;
block30fs/ext/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
block35fs/ext/fsync.cif (!*block)
block37fs/ext/fsync.ctmp = *block;
block38fs/ext/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
block41fs/ext/fsync.cif (*block != tmp) {
block66fs/ext/inode.cint block;
block115fs/ext/inode.cblock = 2 + (s->u.ext_sb.s_firstfreeinodenumber - 1) / EXT_INODES_PER_BLOCK;
block116fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
block185fs/ext/inode.cint ext_bmap(struct inode * inode,int block)
block189fs/ext/inode.cif (block<0) {
block193fs/ext/inode.cif (block >= 9+256+256*256+256*256*256) {
block197fs/ext/inode.cif (block<9)
block198fs/ext/inode.creturn inode_bmap(inode,block);
block199fs/ext/inode.cblock -= 9;
block200fs/ext/inode.cif (block<256) {
block204fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
block206fs/ext/inode.cblock -= 256;
block207fs/ext/inode.cif (block<256*256) {
block211fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8);
block214fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block216fs/ext/inode.cblock -= 256*256;
block220fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16);
block223fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255);
block226fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block312fs/ext/inode.cstruct buffer_head * ext_getblk(struct inode * inode, int block, int create)
block316fs/ext/inode.cif (block<0) {
block320fs/ext/inode.cif (block >= 9+256+256*256+256*256*256) {
block324fs/ext/inode.cif (block<9)
block325fs/ext/inode.creturn inode_getblk(inode,block,create);
block326fs/ext/inode.cblock -= 9;
block327fs/ext/inode.cif (block<256) {
block329fs/ext/inode.creturn block_getblk(inode,bh,block,create);
block331fs/ext/inode.cblock -= 256;
block332fs/ext/inode.cif (block<256*256) {
block334fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
block335fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
block337fs/ext/inode.cblock -= 256*256;
block339fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
block340fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
block341fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
block344fs/ext/inode.cstruct buffer_head * ext_bread(struct inode * inode, int block, int create)
block348fs/ext/inode.cbh = ext_getblk(inode,block,create);
block363fs/ext/inode.cint block;
block365fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
block366fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
block379fs/ext/inode.celse for (block = 0; block < 12; block++)
block380fs/ext/inode.cinode->u.ext_i.i_data[block] = raw_inode->i_zone[block];
block401fs/ext/inode.cint block;
block403fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
block404fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
block416fs/ext/inode.celse for (block = 0; block < 12; block++)
block417fs/ext/inode.craw_inode->i_zone[block] = inode->u.ext_i.i_data[block];
block168fs/ext2/balloc.cvoid ext2_free_blocks (const struct inode * inode, unsigned long block,
block188fs/ext2/balloc.cif (block < es->s_first_data_block || 
block189fs/ext2/balloc.c(block + count) > es->s_blocks_count) {
block192fs/ext2/balloc.c"block = %lu, count = %lu", block, count);
block197fs/ext2/balloc.cext2_debug ("freeing block %lu\n", block);
block199fs/ext2/balloc.cblock_group = (block - es->s_first_data_block) /
block201fs/ext2/balloc.cbit = (block - es->s_first_data_block) % EXT2_BLOCKS_PER_GROUP(sb);
block206fs/ext2/balloc.cblock, count);
block212fs/ext2/balloc.c(in_range (gdp->bg_block_bitmap, block, count) ||
block213fs/ext2/balloc.cin_range (gdp->bg_inode_bitmap, block, count) ||
block214fs/ext2/balloc.cin_range (block, gdp->bg_inode_table,
block216fs/ext2/balloc.cin_range (block + count - 1, gdp->bg_inode_table,
block221fs/ext2/balloc.cblock, count);
block227fs/ext2/balloc.cblock);
block530fs/ext2/balloc.cstatic inline int block_in_use (unsigned long block,
block534fs/ext2/balloc.creturn test_bit ((block - sb->u.ext2_sb.s_es->s_first_data_block) %
block89fs/ext2/file.clong block;
block127fs/ext2/file.cblock = pos2 >> EXT2_BLOCK_SIZE_BITS(sb);
block137fs/ext2/file.cbh = ext2_getblk (inode, block, 1, &err);
block180fs/ext2/file.cblock++;
block30fs/ext2/fsync.cstatic int sync_block (struct inode * inode, u32 * block, int wait)
block35fs/ext2/fsync.cif (!*block)
block37fs/ext2/fsync.ctmp = *block;
block38fs/ext2/fsync.cbh = get_hash_table (inode->i_dev, *block, blocksize);
block41fs/ext2/fsync.cif (*block != tmp) {
block127fs/ext2/inode.cint ext2_bmap (struct inode * inode, int block)
block133fs/ext2/inode.cif (block < 0) {
block137fs/ext2/inode.cif (block >= EXT2_NDIR_BLOCKS + addr_per_block +
block143fs/ext2/inode.cif (block < EXT2_NDIR_BLOCKS)
block144fs/ext2/inode.creturn inode_bmap (inode, block);
block145fs/ext2/inode.cblock -= EXT2_NDIR_BLOCKS;
block146fs/ext2/inode.cif (block < addr_per_block) {
block151fs/ext2/inode.cinode->i_sb->s_blocksize), block);
block153fs/ext2/inode.cblock -= addr_per_block;
block154fs/ext2/inode.cif (block < (1 << (addr_per_block_bits * 2))) {
block160fs/ext2/inode.cblock >> addr_per_block_bits);
block165fs/ext2/inode.cblock & (addr_per_block - 1));
block167fs/ext2/inode.cblock -= (1 << (addr_per_block_bits * 2));
block172fs/ext2/inode.cblock >> (addr_per_block_bits * 2));
block176fs/ext2/inode.c(block >> addr_per_block_bits) & (addr_per_block - 1));
block180fs/ext2/inode.cblock & (addr_per_block - 1));
block361fs/ext2/inode.cstruct buffer_head * ext2_getblk (struct inode * inode, long block,
block370fs/ext2/inode.cif (block < 0) {
block374fs/ext2/inode.cif (block > EXT2_NDIR_BLOCKS + addr_per_block +
block386fs/ext2/inode.cext2_debug ("block %lu, next %lu, goal %lu.\n", block, 
block390fs/ext2/inode.cif (block == inode->u.ext2_i.i_next_alloc_block + 1) {
block396fs/ext2/inode.cb = block;
block397fs/ext2/inode.cif (block < EXT2_NDIR_BLOCKS)
block398fs/ext2/inode.creturn inode_getblk (inode, block, create, b, err);
block399fs/ext2/inode.cblock -= EXT2_NDIR_BLOCKS;
block400fs/ext2/inode.cif (block < addr_per_block) {
block402fs/ext2/inode.creturn block_getblk (inode, bh, block, create,
block405fs/ext2/inode.cblock -= addr_per_block;
block406fs/ext2/inode.cif (block < (1 << (addr_per_block_bits * 2))) {
block408fs/ext2/inode.cbh = block_getblk (inode, bh, block >> addr_per_block_bits,
block410fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1),
block413fs/ext2/inode.cblock -= (1 << (addr_per_block_bits * 2));
block415fs/ext2/inode.cbh = block_getblk (inode, bh, block >> (addr_per_block_bits * 2),
block417fs/ext2/inode.cbh = block_getblk (inode, bh, (block >> addr_per_block_bits) & (addr_per_block - 1),
block419fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1), create,
block423fs/ext2/inode.cint ext2_getcluster (struct inode * inode, long block)
block433fs/ext2/inode.cif (block < 0) {
block437fs/ext2/inode.cif (block > EXT2_NDIR_BLOCKS + addr_per_block +
block445fs/ext2/inode.cb = block;
block446fs/ext2/inode.cif (block < EXT2_NDIR_BLOCKS) return 0;
block448fs/ext2/inode.cblock -= EXT2_NDIR_BLOCKS;
block450fs/ext2/inode.cif (block < addr_per_block) {
block452fs/ext2/inode.creturn block_getcluster (inode, bh, block, 
block455fs/ext2/inode.cblock -= addr_per_block;
block456fs/ext2/inode.cif (block < (1 << (addr_per_block_bits * 2))) {
block458fs/ext2/inode.cbh = block_getblk (inode, bh, block >> addr_per_block_bits,
block460fs/ext2/inode.creturn block_getcluster (inode, bh, block & (addr_per_block - 1),
block463fs/ext2/inode.cblock -= (1 << (addr_per_block_bits * 2));
block465fs/ext2/inode.cbh = block_getblk (inode, bh, block >> (addr_per_block_bits * 2),
block467fs/ext2/inode.cbh = block_getblk (inode, bh, (block >> addr_per_block_bits) & (addr_per_block - 1),
block469fs/ext2/inode.creturn block_getcluster (inode, bh, block & (addr_per_block - 1),
block473fs/ext2/inode.cstruct buffer_head * ext2_bread (struct inode * inode, int block, 
block478fs/ext2/inode.cbh = ext2_getblk (inode, block, create, err);
block497fs/ext2/inode.cunsigned long block;
block518fs/ext2/inode.cblock = gdp[desc].bg_inode_table +
block521fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
block524fs/ext2/inode.c"inode=%lu, block=%lu", inode->i_ino, block);
block555fs/ext2/inode.celse for (block = 0; block < EXT2_N_BLOCKS; block++)
block556fs/ext2/inode.cinode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
block589fs/ext2/inode.cunsigned long block;
block609fs/ext2/inode.cblock = gdp[desc].bg_inode_table +
block612fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
block615fs/ext2/inode.c"inode=%lu, block=%lu", inode->i_ino, block);
block637fs/ext2/inode.celse for (block = 0; block < EXT2_N_BLOCKS; block++)
block638fs/ext2/inode.craw_inode->i_block[block] = inode->u.ext2_i.i_data[block];
block76fs/ext2/namei.cint block, toread, i, err;
block93fs/ext2/namei.cfor (block = 0; block < NAMEI_RA_SIZE; ++block) {
block96fs/ext2/namei.cif ((block << EXT2_BLOCK_SIZE_BITS (sb)) >= dir->i_size)
block98fs/ext2/namei.cbh = ext2_getblk (dir, block, 0, &err);
block99fs/ext2/namei.cbh_use[block] = bh;
block104fs/ext2/namei.cfor (block = 0, offset = 0; offset < dir->i_size; block++) {
block109fs/ext2/namei.cif ((block % NAMEI_RA_BLOCKS) == 0 && toread) {
block113fs/ext2/namei.cbh = bh_use[block % NAMEI_RA_SIZE];
block149fs/ext2/namei.cif (((block + NAMEI_RA_SIZE) << EXT2_BLOCK_SIZE_BITS (sb)) >=
block153fs/ext2/namei.cbh = ext2_getblk (dir, block + NAMEI_RA_SIZE, 0, &err);
block154fs/ext2/namei.cbh_use[block % NAMEI_RA_SIZE] = bh;
block320fs/ext2/super.cunsigned long block = sb->u.ext2_sb.s_es->s_first_data_block;
block329fs/ext2/super.cif (gdp->bg_block_bitmap < block ||
block330fs/ext2/super.cgdp->bg_block_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
block338fs/ext2/super.cif (gdp->bg_inode_bitmap < block ||
block339fs/ext2/super.cgdp->bg_inode_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
block347fs/ext2/super.cif (gdp->bg_inode_table < block ||
block349fs/ext2/super.cblock + EXT2_BLOCKS_PER_GROUP(sb))
block357fs/ext2/super.cblock += EXT2_BLOCKS_PER_GROUP(sb);
block15fs/fat/buffer.cint block)
block19fs/fat/buffer.cret = bread (sb->s_dev,block,512);
block21fs/fat/buffer.cstruct buffer_head *real = bread (sb->s_dev,block>>1,1024);
block57fs/fat/buffer.cif (block & 1) ret->b_data += 512;
block68fs/fat/buffer.cint block)
block72fs/fat/buffer.cret = getblk (sb->s_dev,block,512);
block80fs/fat/buffer.cret = fat_bread (sb,block);
block336fs/fat/inode.cint fat_bmap(struct inode *inode,int block)
block343fs/fat/inode.creturn sb->dir_start + block;
block345fs/fat/inode.ccluster = block/sb->cluster_size;
block346fs/fat/inode.coffset = block % sb->cluster_size;
block2fs/fat/msbuffer.hstruct buffer_head *fat_bread (struct super_block *sb, int block);
block3fs/fat/msbuffer.hstruct buffer_head *fat_getblk (struct super_block *sb, int block);
block886fs/hpfs/hpfs_fs.cchar *block;
block917fs/hpfs/hpfs_fs.cblock = map_sector(inode->i_dev, hpfs_bmap(inode, q), &bh);
block918fs/hpfs/hpfs_fs.cif (!block)
block926fs/hpfs/hpfs_fs.cinode->i_hpfs_conv = choose_conv(block + r, n);
block933fs/hpfs/hpfs_fs.cmemcpy_tofs(buf, block + r, n);
block940fs/hpfs/hpfs_fs.cn0 = convcpy_tofs(buf, block + r, n);
block375fs/inode.cint bmap(struct inode * inode, int block)
block378fs/inode.creturn inode->i_op->bmap(inode,block);
block20fs/ioctl.cint block;
block31fs/ioctl.cblock = get_fs_long((long *) arg);
block32fs/ioctl.cblock = filp->f_inode->i_op->bmap(filp->f_inode,block);
block33fs/ioctl.cput_fs_long(block,(long *) arg);
block114fs/isofs/dir.cunsigned int block, offset;
block123fs/isofs/dir.cblock = isofs_bmap(inode, filp->f_pos >> bufbits);
block125fs/isofs/dir.cif (!block)
block128fs/isofs/dir.cif (!(bh = breada(inode->i_dev, block, bufsize, filp->f_pos, inode->i_size)))
block135fs/isofs/dir.cblock, offset, filp->f_pos);
block141fs/isofs/dir.cblock = isofs_bmap(inode, (filp->f_pos) >> bufbits);
block142fs/isofs/dir.cif (!block)
block144fs/isofs/dir.cbh = breada(inode->i_dev, block, bufsize, filp->f_pos, inode->i_size);
block151fs/isofs/dir.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
block164fs/isofs/dir.cblock = isofs_bmap(inode, (filp->f_pos) >> bufbits);
block165fs/isofs/dir.cif (!block)
block167fs/isofs/dir.cbh = breada(inode->i_dev, block, bufsize, filp->f_pos, inode->i_size);
block181fs/isofs/dir.cblock = isofs_bmap(inode, (filp->f_pos + de_len) >> bufbits);
block182fs/isofs/dir.cif (!block)
block184fs/isofs/dir.cbh = breada(inode->i_dev, block, bufsize, filp->f_pos+de_len, inode->i_size);
block444fs/isofs/inode.cint isofs_bmap(struct inode * inode,int block)
block447fs/isofs/inode.cif (block<0) {
block451fs/isofs/inode.creturn (inode->u.isofs_i.i_first_extent >> ISOFS_BUFFER_BITS(inode)) + block;
block462fs/isofs/inode.cint block;
block466fs/isofs/inode.cblock = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
block467fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
block490fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
block562fs/isofs/inode.cprintk("Get inode %d: %d %d: %d\n",inode->i_ino, block, 
block675fs/isofs/inode.cunsigned int block,offset;
block685fs/isofs/inode.cblock = extent << (ISOFS_ZONE_BITS(parent) - bufbits);
block686fs/isofs/inode.cif (!(bh = bread(parent->i_dev, block, bufsize)))  return -1;
block723fs/isofs/inode.cblock = parent_dir << (ISOFS_ZONE_BITS(parent) - bufbits);
block724fs/isofs/inode.cif (!block || !(bh = bread(parent->i_dev,block, bufsize)))
block732fs/isofs/inode.cinode_number = (block << bufbits)+(offset & (bufsize - 1));
block742fs/isofs/inode.cblock++;
block745fs/isofs/inode.cif((block & 1) && (ISOFS_ZONE_BITS(parent) - bufbits) == 1)
block749fs/isofs/inode.cif((block & 3) && (ISOFS_ZONE_BITS(parent) - bufbits) == 2)
block753fs/isofs/inode.cif (!block
block754fs/isofs/inode.c|| !(bh = bread(parent->i_dev,block, bufsize)))
block784fs/isofs/inode.cblock++;
block785fs/isofs/inode.cif(!(bh = bread(parent->i_dev,block,bufsize))) {
block836fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
block838fs/isofs/inode.creturn bread(dev, block, size);
block66fs/isofs/namei.cunsigned int block, i, f_pos, offset, inode_number;
block79fs/isofs/namei.cif (!(block = dir->u.isofs_i.i_first_extent)) return NULL;
block84fs/isofs/namei.cblock = isofs_bmap(dir,f_pos >> bufbits);
block86fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) return NULL;
block91fs/isofs/namei.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
block101fs/isofs/namei.cblock = isofs_bmap(dir,f_pos>>bufbits);
block102fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize)))
block123fs/isofs/namei.cblock = isofs_bmap(dir,f_pos>>bufbits);
block124fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) {
block56fs/isofs/rock.cint block, offset, offset1; \
block60fs/isofs/rock.cblock = cont_extent; \
block64fs/isofs/rock.cblock <<= 1;    \
block65fs/isofs/rock.cif (offset >= 1024) block++; \
block68fs/isofs/rock.cbh = bread(DEV->i_dev, block++, ISOFS_BUFFER_SIZE(DEV)); \
block79fs/isofs/rock.cbh = bread(DEV->i_dev, block, ISOFS_BUFFER_SIZE(DEV)); \
block414fs/isofs/rock.cint block;
block426fs/isofs/rock.cblock = inode->i_ino >> bufbits;
block427fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
block445fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
block128fs/locks.cstatic inline void locks_insert_block(struct file_lock **block, 
block133fs/locks.cwhile ((bfl = *block) != NULL) {
block134fs/locks.cblock = &bfl->fl_block;
block137fs/locks.c*block = fl;
block143fs/locks.cstatic inline void locks_delete_block(struct file_lock **block,
block148fs/locks.cwhile ((bfl = *block) != NULL) {
block150fs/locks.c*block = fl->fl_block;
block154fs/locks.cblock = &bfl->fl_block;
block34fs/minix/bitmap.cvoid minix_free_block(struct super_block * sb, int block)
block43fs/minix/bitmap.cif (block < sb->u.minix_sb.s_firstdatazone ||
block44fs/minix/bitmap.cblock >= sb->u.minix_sb.s_nzones) {
block48fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
block52fs/minix/bitmap.czone = block - sb->u.minix_sb.s_firstdatazone + 1;
block62fs/minix/bitmap.ckdevname(sb->s_dev), block);
block114fs/minix/bitmap.cint ino, block;
block122fs/minix/bitmap.cblock = (2 + inode->i_sb->u.minix_sb.s_imap_blocks +
block125fs/minix/bitmap.cbh = bread(inode->i_dev, block, BLOCK_SIZE);
block142fs/minix/bitmap.cint ino, block;
block150fs/minix/bitmap.cblock = (2 + inode->i_sb->u.minix_sb.s_imap_blocks +
block153fs/minix/bitmap.cbh = bread(inode->i_dev, block, BLOCK_SIZE);
block31fs/minix/fsync.cstatic int V1_sync_block (struct inode * inode, unsigned short * block, int wait)
block36fs/minix/fsync.cif (!*block)
block38fs/minix/fsync.ctmp = *block;
block39fs/minix/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
block42fs/minix/fsync.cif (*block != tmp) {
block168fs/minix/fsync.cstatic int V2_sync_block (struct inode * inode, unsigned long * block, int wait)
block173fs/minix/fsync.cif (!*block)
block175fs/minix/fsync.ctmp = *block;
block176fs/minix/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
block179fs/minix/fsync.cif (*block != tmp) {
block169fs/minix/inode.cint i, block;
block243fs/minix/inode.cblock=2;
block245fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
block246fs/minix/inode.cblock++;
block250fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
block251fs/minix/inode.cblock++;
block254fs/minix/inode.cif (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) {
block338fs/minix/inode.cstatic int V1_minix_bmap(struct inode * inode,int block)
block342fs/minix/inode.cif (block<0) {
block346fs/minix/inode.cif (block >= (inode->i_sb->u.minix_sb.s_max_size/BLOCK_SIZE)) {
block350fs/minix/inode.cif (block < 7)
block351fs/minix/inode.creturn V1_inode_bmap(inode,block);
block352fs/minix/inode.cblock -= 7;
block353fs/minix/inode.cif (block < 512) {
block357fs/minix/inode.creturn V1_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
block359fs/minix/inode.cblock -= 512;
block363fs/minix/inode.ci = V1_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9);
block366fs/minix/inode.creturn V1_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511);
block384fs/minix/inode.cstatic int V2_minix_bmap(struct inode * inode,int block)
block388fs/minix/inode.cif (block<0) {
block392fs/minix/inode.cif (block >= (inode->i_sb->u.minix_sb.s_max_size/BLOCK_SIZE)) {
block396fs/minix/inode.cif (block < 7)
block397fs/minix/inode.creturn V2_inode_bmap(inode,block);
block398fs/minix/inode.cblock -= 7;
block399fs/minix/inode.cif (block < 256) {
block403fs/minix/inode.creturn V2_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
block405fs/minix/inode.cblock -= 256;
block406fs/minix/inode.cif (block < 256*256) {
block410fs/minix/inode.ci = V2_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block >> 8);
block413fs/minix/inode.creturn V2_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block415fs/minix/inode.cblock -= 256*256;
block419fs/minix/inode.ci = V2_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block >> 16);
block422fs/minix/inode.ci = V2_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block >> 8) & 255);
block425fs/minix/inode.creturn V2_block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block431fs/minix/inode.cint minix_bmap(struct inode * inode,int block)
block434fs/minix/inode.creturn V1_minix_bmap(inode, block);
block436fs/minix/inode.creturn V2_minix_bmap(inode, block);
block526fs/minix/inode.cstatic struct buffer_head * V1_minix_getblk(struct inode * inode, int block, 
block531fs/minix/inode.cif (block<0) {
block535fs/minix/inode.cif (block >= inode->i_sb->u.minix_sb.s_max_size/BLOCK_SIZE) {
block539fs/minix/inode.cif (block < 7)
block540fs/minix/inode.creturn V1_inode_getblk(inode,block,create);
block541fs/minix/inode.cblock -= 7;
block542fs/minix/inode.cif (block < 512) {
block544fs/minix/inode.creturn V1_block_getblk(inode, bh, block, create);
block546fs/minix/inode.cblock -= 512;
block548fs/minix/inode.cbh = V1_block_getblk(inode, bh, (block>>9) & 511, create);
block549fs/minix/inode.creturn V1_block_getblk(inode, bh, block & 511, create);
block639fs/minix/inode.cstatic struct buffer_head * V2_minix_getblk(struct inode * inode, int block, 
block644fs/minix/inode.cif (block<0) {
block648fs/minix/inode.cif (block >= inode->i_sb->u.minix_sb.s_max_size/BLOCK_SIZE) {
block652fs/minix/inode.cif (block < 7)
block653fs/minix/inode.creturn V2_inode_getblk(inode,block,create);
block654fs/minix/inode.cblock -= 7;
block655fs/minix/inode.cif (block < 256) {
block657fs/minix/inode.creturn V2_block_getblk(inode, bh, block, create);
block659fs/minix/inode.cblock -= 256;
block660fs/minix/inode.cif (block < 256*256) {
block662fs/minix/inode.cbh = V2_block_getblk(inode, bh, (block>>8) & 255, create);
block663fs/minix/inode.creturn V2_block_getblk(inode, bh, block & 255, create);
block665fs/minix/inode.cblock -= 256*256;
block667fs/minix/inode.cbh = V2_block_getblk(inode, bh, (block >> 16) & 255, create);
block668fs/minix/inode.cbh = V2_block_getblk(inode, bh, (block >> 8) & 255, create);
block669fs/minix/inode.creturn V2_block_getblk(inode, bh, block & 255, create);
block675fs/minix/inode.cstruct buffer_head * minix_getblk(struct inode * inode, int block, int create)
block678fs/minix/inode.creturn V1_minix_getblk(inode,block,create);
block680fs/minix/inode.creturn V2_minix_getblk(inode,block,create);
block683fs/minix/inode.cstruct buffer_head * minix_bread(struct inode * inode, int block, int create)
block687fs/minix/inode.cbh = minix_getblk(inode,block,create);
block705fs/minix/inode.cint block, ino;
block716fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
block719fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
block735fs/minix/inode.celse for (block = 0; block < 9; block++)
block736fs/minix/inode.cinode->u.minix_i.u.i1_data[block] = raw_inode->i_zone[block];
block759fs/minix/inode.cint block, ino;
block770fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
block773fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
block791fs/minix/inode.celse for (block = 0; block < 10; block++)
block792fs/minix/inode.cinode->u.minix_i.u.i2_data[block] = raw_inode->i_zone[block];
block826fs/minix/inode.cint ino, block;
block836fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
block838fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
block853fs/minix/inode.celse for (block = 0; block < 9; block++)
block854fs/minix/inode.craw_inode->i_zone[block] = inode->u.minix_i.u.i1_data[block];
block867fs/minix/inode.cint ino, block;
block877fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
block879fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
block896fs/minix/inode.celse for (block = 0; block < 10; block++)
block897fs/minix/inode.craw_inode->i_zone[block] = inode->u.minix_i.u.i2_data[block];
block67fs/minix/namei.cunsigned long block, offset;
block83fs/minix/namei.cblock = offset = 0;
block84fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < dir->i_size) {
block86fs/minix/namei.cbh = minix_bread(dir,block,0);
block88fs/minix/namei.cblock++;
block100fs/minix/namei.cblock++;
block151fs/minix/namei.cunsigned long block, offset;
block171fs/minix/namei.cblock = offset = 0;
block174fs/minix/namei.cbh = minix_bread(dir,block,1);
block180fs/minix/namei.cif (block*bh->b_size + offset > dir->i_size) {
block182fs/minix/namei.cdir->i_size = block*bh->b_size + offset;
block205fs/minix/namei.cblock++;
block376fs/minix/namei.cunsigned int block, offset;
block384fs/minix/namei.cblock = 0;
block400fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < inode->i_size) {
block402fs/minix/namei.cbh = minix_bread(inode,block,0);
block404fs/minix/namei.cblock++;
block419fs/minix/namei.cblock++;
block32fs/sysv/balloc.cvoid sysv_free_block(struct super_block * sb, unsigned int block)
block41fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
block58fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
block95fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
block109fs/sysv/balloc.cbh = sv_get_hash_table(sb, sb->s_dev, block);
block115fs/sysv/balloc.cblock = to_coh_ulong(block);
block116fs/sysv/balloc.csb->sv_sb_flc_blocks[(*sb->sv_sb_flc_count)++] = block;
block130fs/sysv/balloc.cunsigned int block;
block143fs/sysv/balloc.cblock = sb->sv_sb_flc_blocks[(*sb->sv_sb_flc_count)-1];
block145fs/sysv/balloc.cblock = from_coh_ulong(block);
block146fs/sysv/balloc.cif (block == 0) { /* Applies only to Xenix FS, SystemV FS */
block151fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
block152fs/sysv/balloc.cprintk("sysv_new_block: new block %d is not in data zone\n",block);
block160fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
block198fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
block222fs/sysv/balloc.creturn block;
block229fs/sysv/balloc.cunsigned int block;
block239fs/sysv/balloc.cblock = sb->sv_sb_flc_blocks[--i];
block241fs/sysv/balloc.cblock = from_coh_ulong(block);
block242fs/sysv/balloc.cif (block == 0) /* block 0 terminates list */
block253fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
block254fs/sysv/balloc.cprintk("sysv_count_free_blocks: new block %d is not in data zone\n",block);
block257fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
block291fs/sysv/balloc.cblock = flc_blocks[--i];
block293fs/sysv/balloc.cblock = from_coh_ulong(block);
block294fs/sysv/balloc.cif (block == 0) /* block 0 terminates list */
block302fs/sysv/balloc.cif (block == 0) /* Applies only to Xenix FS and SystemV FS */
block79fs/sysv/file.cunsigned int block;
block106fs/sysv/file.cblock = offset >> sb->sv_block_size_bits;
block113fs/sysv/file.cif (block + blocks > size)
block114fs/sysv/file.cblocks = size - block;
block133fs/sysv/file.c*bhb = sysv_getblk(inode, block++, 0);
block32fs/sysv/fsync.cunsigned long tmp, block;
block35fs/sysv/fsync.cblock = tmp = *blockp;
block37fs/sysv/fsync.cblock = from_coh_ulong(block);
block38fs/sysv/fsync.cif (!block)
block41fs/sysv/fsync.cbh = sv_get_hash_table(sb, inode->i_dev, block);
block66fs/sysv/fsync.cunsigned long tmp, block;
block69fs/sysv/fsync.cblock = tmp = *iblockp;
block71fs/sysv/fsync.cblock = from_coh_ulong(block);
block72fs/sysv/fsync.cif (!block)
block77fs/sysv/fsync.c*bh = sv_bread(inode->i_sb, inode->i_dev, block);
block109fs/sysv/ialloc.cint i,j,ino,block;
block127fs/sysv/ialloc.cfor (i = 0, ino = SYSV_ROOT_INO+1, block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; i < sb->sv_fic_size && block < sb->sv_firstdatazone ; block++, j = 0) {
block128fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
block182fs/sysv/ialloc.cint j,block,count;
block193fs/sysv/ialloc.cfor (block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; block < sb->sv_firstdatazone ; block++, j = 0) {
block194fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
block579fs/sysv/inode.cunsigned int block = block_nr;
block585fs/sysv/inode.cif (block < 10)
block586fs/sysv/inode.creturn inode_bmap(sb,inode,block);
block587fs/sysv/inode.cblock -= 10;
block589fs/sysv/inode.cif (block < sb->sv_ind_per_block) {
block594fs/sysv/inode.creturn block_bmap(sb, bh, block, convert);
block596fs/sysv/inode.cblock -= sb->sv_ind_per_block;
block597fs/sysv/inode.cif (block < sb->sv_ind_per_block_2) {
block602fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_bits, convert);
block606fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
block608fs/sysv/inode.cblock -= sb->sv_ind_per_block_2;
block609fs/sysv/inode.cif (block < sb->sv_ind_per_block_3) {
block614fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_2_bits, convert);
block618fs/sysv/inode.ci = block_bmap(sb, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1,convert);
block622fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
block624fs/sysv/inode.cif ((int)block<0) {
block676fs/sysv/inode.cunsigned long tmp, block;
block693fs/sysv/inode.cblock = tmp = *p;
block695fs/sysv/inode.cblock = from_coh_ulong(block);
block697fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
block709fs/sysv/inode.cblock = sysv_new_block(sb);
block710fs/sysv/inode.cif (!block) {
block714fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
block716fs/sysv/inode.csysv_free_block(sb,block);
block720fs/sysv/inode.c*p = (sb->sv_convert ? to_coh_ulong(block) : block);
block726fs/sysv/inode.cstruct buffer_head * sysv_getblk(struct inode * inode, unsigned int block, int create)
block731fs/sysv/inode.cif (block < 10)
block732fs/sysv/inode.creturn inode_getblk(inode,block,create);
block733fs/sysv/inode.cblock -= 10;
block734fs/sysv/inode.cif (block < sb->sv_ind_per_block) {
block736fs/sysv/inode.creturn block_getblk(inode, bh, block, create);
block738fs/sysv/inode.cblock -= sb->sv_ind_per_block;
block739fs/sysv/inode.cif (block < sb->sv_ind_per_block_2) {
block741fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_bits, create);
block742fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
block744fs/sysv/inode.cblock -= sb->sv_ind_per_block_2;
block745fs/sysv/inode.cif (block < sb->sv_ind_per_block_3) {
block747fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_2_bits, create);
block748fs/sysv/inode.cbh = block_getblk(inode, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1, create);
block749fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
block751fs/sysv/inode.cif ((int)block<0) {
block759fs/sysv/inode.cstruct buffer_head * sysv_file_bread(struct inode * inode, int block, int create)
block763fs/sysv/inode.cbh = sysv_getblk(inode,block,create);
block804fs/sysv/inode.cunsigned int block, ino;
block816fs/sysv/inode.cblock = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
block817fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
block848fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block849fs/sysv/inode.cinode->u.sysv_i.i_data[block] =
block850fs/sysv/inode.ccoh_read3byte(&raw_inode->i_a.i_addb[3*block]);
block852fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block853fs/sysv/inode.cinode->u.sysv_i.i_data[block] =
block854fs/sysv/inode.cread3byte(&raw_inode->i_a.i_addb[3*block]);
block893fs/sysv/inode.cunsigned int ino, block;
block904fs/sysv/inode.cblock = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
block905fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
block933fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block934fs/sysv/inode.ccoh_write3byte(&raw_inode->i_a.i_addb[3*block],inode->u.sysv_i.i_data[block]);
block936fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block937fs/sysv/inode.cwrite3byte(&raw_inode->i_a.i_addb[3*block],inode->u.sysv_i.i_data[block]);
block64fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
block77fs/sysv/namei.cpos = block = offset = 0;
block80fs/sysv/namei.cbh = sysv_file_bread(dir,block,0);
block82fs/sysv/namei.c/* offset = 0; */ block++;
block96fs/sysv/namei.coffset = 0; block++;
block148fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
block165fs/sysv/namei.cpos = block = offset = 0;
block168fs/sysv/namei.cbh = sysv_file_bread(dir,block,1);
block198fs/sysv/namei.coffset = 0; block++;
block368fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
block374fs/sysv/namei.cblock = 0;
block393fs/sysv/namei.cbh = sysv_file_bread(inode,block,0);
block395fs/sysv/namei.c/* offset = 0; */ block++;
block411fs/sysv/namei.coffset = 0; block++;
block45fs/sysv/truncate.cunsigned long block;
block53fs/sysv/truncate.cblock = *p;
block54fs/sysv/truncate.cif (!block)
block56fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
block61fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (block != *p)) {
block69fs/sysv/truncate.csysv_free_block(sb,block);
block81fs/sysv/truncate.cunsigned long tmp, block;
block108fs/sysv/truncate.cblock = tmp = *ind;
block110fs/sysv/truncate.cblock = from_coh_ulong(block);
block111fs/sysv/truncate.cif (!block)
block113fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
block126fs/sysv/truncate.csysv_free_block(sb,block);
block150fs/sysv/truncate.cunsigned long tmp, block;
block176fs/sysv/truncate.cblock = tmp = *ind;
block178fs/sysv/truncate.cblock = from_coh_ulong(block);
block179fs/sysv/truncate.cif (!block)
block207fs/sysv/truncate.cunsigned long tmp, block;
block233fs/sysv/truncate.cblock = tmp = *ind;
block235fs/sysv/truncate.cblock = from_coh_ulong(block);
block236fs/sysv/truncate.cif (!block)
block29fs/xiafs/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
block34fs/xiafs/fsync.cif (!*block)
block36fs/xiafs/fsync.ctmp = *block;
block37fs/xiafs/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
block40fs/xiafs/fsync.cif (*block != tmp) {
block38include/linux/blk.h#define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0)
block441include/linux/ext2_fs.hextern int ext2_getcluster (struct inode * inode, long block);
block82include/linux/ext_fs.hextern void ext_free_block(struct super_block * sb, int block);
block595include/linux/fs.hextern int bmap(struct inode * inode,int block);
block614include/linux/fs.hextern struct buffer_head * get_hash_table(kdev_t dev, int block, int size);
block615include/linux/fs.hextern struct buffer_head * getblk(kdev_t dev, int block, int size);
block633include/linux/fs.hextern struct buffer_head * bread(kdev_t dev, int block, int size);
block634include/linux/fs.hextern struct buffer_head * breada(kdev_t dev,int block, int size, 
block174include/linux/iso_fs.hextern int isofs_free_block(int dev, int block);
block203include/linux/iso_fs.hextern struct buffer_head * leak_check_bread(int dev, int block, int size);
block108include/linux/minix_fs.hextern void minix_free_block(struct super_block * sb, int block);
block201include/linux/msdos_fs.hextern int fat_bmap(struct inode *inode,int block);
block340include/linux/sysv_fs.hsv_get_hash_table (struct super_block *sb, kdev_t dev, unsigned int block)
block342include/linux/sysv_fs.hreturn get_hash_table (dev, block + sb->sv_block_base, sb->sv_block_size);
block347include/linux/sysv_fs.hsv_getblk (struct super_block *sb, kdev_t dev, unsigned int block)
block349include/linux/sysv_fs.hreturn getblk (dev, block + sb->sv_block_base, sb->sv_block_size);
block354include/linux/sysv_fs.hsv_bread (struct super_block *sb, kdev_t dev, unsigned int block)
block356include/linux/sysv_fs.hreturn bread (dev, block + sb->sv_block_base, sb->sv_block_size);
block381include/linux/sysv_fs.hextern void sysv_free_block(struct super_block * sb, unsigned int block);
block117include/linux/xd.hstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count);
block87include/linux/xia_fs.hextern void xiafs_free_zone(struct super_block * sb, int block);
block110mm/page_io.cunsigned int block = offset << 3;
block113mm/page_io.cif (!(zones[i] = swapf->i_op->smap(swapf,block++))) {
block120mm/page_io.cunsigned int block = offset
block124mm/page_io.cif (!(zones[i] = bmap(swapf,block++))) {
block165mm/page_io.cint block = page;
block182mm/page_io.cbrw_page(rw, (unsigned long) buffer, dev, &block, PAGE_SIZE, 0);