taglinefilesource code
bh761drivers/block/aztcd.cif (CURRENT->bh) {
bh762drivers/block/aztcd.cif (!CURRENT->bh->b_lock)
bh265drivers/block/blk.hif (CURRENT->bh) { \
bh266drivers/block/blk.hif (!CURRENT->bh->b_lock) \
bh283drivers/block/blk.hstruct buffer_head * bh;
bh295drivers/block/blk.hif ((bh = req->bh) != NULL) {
bh296drivers/block/blk.hreq->bh = bh->b_reqnext;
bh297drivers/block/blk.hbh->b_reqnext = NULL;
bh298drivers/block/blk.hbh->b_uptodate = uptodate;    
bh299drivers/block/blk.hif (!uptodate) bh->b_req = 0; /* So no "Weird" errors */
bh300drivers/block/blk.hunlock_buffer(bh);
bh301drivers/block/blk.hif ((bh = req->bh) != NULL) {
bh302drivers/block/blk.hreq->current_nr_sectors = bh->b_size >> 9;
bh307drivers/block/blk.hreq->buffer = bh->b_data;
bh1412drivers/block/cdu31a.cif (CURRENT->bh)
bh1414drivers/block/cdu31a.cif (!CURRENT->bh->b_lock)
bh2052drivers/block/floppy.cstruct buffer_head *bh;
bh2058drivers/block/floppy.cbh = CURRENT->bh;
bh2060drivers/block/floppy.cif (bh){
bh2061drivers/block/floppy.cbh = bh->b_reqnext;
bh2062drivers/block/floppy.cwhile ( bh && bh->b_data == base + size ){
bh2063drivers/block/floppy.csize += bh->b_size;
bh2064drivers/block/floppy.cbh = bh->b_reqnext;
bh2091drivers/block/floppy.cstruct buffer_head *bh;
bh2126drivers/block/floppy.cbh = CURRENT->bh;
bh2161drivers/block/floppy.cbh = bh->b_reqnext;
bh2163drivers/block/floppy.cif ( !bh){
bh2168drivers/block/floppy.csize = bh->b_size;
bh2169drivers/block/floppy.cbuffer = bh->b_data;
bh2436drivers/block/floppy.cif (CURRENT->bh && !CURRENT->bh->b_lock)
bh2439drivers/block/floppy.cif (!CURRENT->bh->b_count && 
bh3098drivers/block/floppy.cstruct buffer_head * bh;
bh3122drivers/block/floppy.cif (!(bh = getblk(dev,0,size))){
bh3126drivers/block/floppy.cif ( bh && ! bh->b_uptodate)
bh3127drivers/block/floppy.cll_rw_block(READ, 1, &bh);
bh3129drivers/block/floppy.cwait_on_buffer(bh);
bh3130drivers/block/floppy.cbrelse(bh);
bh51drivers/block/genhd.cstruct buffer_head *bh;
bh62drivers/block/genhd.cif (!(bh = bread(dev,0,1024)))
bh68drivers/block/genhd.cbh->b_dirt = 0;
bh69drivers/block/genhd.cbh->b_uptodate = 0;
bh70drivers/block/genhd.cbh->b_req = 0;
bh71drivers/block/genhd.cif (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
bh72drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
bh95drivers/block/genhd.cbrelse(bh);
bh100drivers/block/genhd.cbrelse(bh);
bh107drivers/block/genhd.cstruct buffer_head *bh;
bh126drivers/block/genhd.cif (!(bh = bread(dev,0,1024))) {
bh132drivers/block/genhd.cif (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
bh133drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
bh149drivers/block/genhd.cif (*(unsigned short *) (bh->b_data+0xfc) == 0x55AA) {
bh150drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
bh163drivers/block/genhd.cbrelse(bh);
bh539drivers/block/hd.cWCURRENT.bh = WCURRENT.bh->b_reqnext;
bh540drivers/block/hd.cif (WCURRENT.bh == NULL)
bh542drivers/block/hd.cWCURRENT.current_nr_sectors = WCURRENT.bh->b_size>>9;
bh543drivers/block/hd.cWCURRENT.buffer             = WCURRENT.bh->b_data;
bh607drivers/block/hd.cif (!i || (CURRENT->bh && !SUBSECTOR(i)))
bh159drivers/block/ide-cd.cif (!uptodate && rq->bh != 0)
bh471drivers/block/ide-cd.cnskip = MIN ((int)(rq->current_nr_sectors - (rq->bh->b_size >> SECTOR_BITS)),
bh577drivers/block/ide-cd.cif (rq->current_nr_sectors < (rq->bh->b_size >> SECTOR_BITS) &&
bh620drivers/block/ide-cd.cif (rq->current_nr_sectors != (rq->bh->b_size >> SECTOR_BITS))
bh683drivers/block/ide-cd.cif (rq->buffer != rq->bh->b_data)
bh685drivers/block/ide-cd.cint n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
bh686drivers/block/ide-cd.crq->buffer = rq->bh->b_data;
bh692drivers/block/ide-cd.cif (rq->current_nr_sectors > (rq->bh->b_size >> SECTOR_BITS))
bh693drivers/block/ide-cd.crq->current_nr_sectors = rq->bh->b_size;
bh882drivers/block/ide-cd.creq.bh = NULL;
bh737drivers/block/ide.cif ((rq->bh = rq->bh->b_reqnext) != NULL) {
bh738drivers/block/ide.crq->current_nr_sectors = rq->bh->b_size>>9;
bh739drivers/block/ide.crq->buffer             = rq->bh->b_data;
bh1065drivers/block/ide.cif (rq->bh && !rq->bh->b_lock) {
bh1360drivers/block/ide.crq.bh = NULL;
bh198drivers/block/ll_rw_blk.cif (req->bh)
bh199drivers/block/ll_rw_blk.cmark_buffer_clean(req->bh);
bh222drivers/block/ll_rw_blk.cstatic void make_request(int major,int rw, struct buffer_head * bh)
bh232drivers/block/ll_rw_blk.cif (bh->b_lock)
bh243drivers/block/ll_rw_blk.ccount = bh->b_size >> 9;
bh244drivers/block/ll_rw_blk.csector = bh->b_blocknr * count;
bh246drivers/block/ll_rw_blk.cif (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
bh247drivers/block/ll_rw_blk.cbh->b_dirt = bh->b_uptodate = 0;
bh248drivers/block/ll_rw_blk.cbh->b_req = 0;
bh252drivers/block/ll_rw_blk.cif (bh->b_lock)
bh255drivers/block/ll_rw_blk.clock_buffer(bh);
bh256drivers/block/ll_rw_blk.cif ((rw == WRITE && !bh->b_dirt) || (rw == READ && bh->b_uptodate)) {
bh257drivers/block/ll_rw_blk.cunlock_buffer(bh);
bh290drivers/block/ll_rw_blk.cif (req->dev == bh->b_dev &&
bh296drivers/block/ll_rw_blk.creq->bhtail->b_reqnext = bh;
bh297drivers/block/ll_rw_blk.creq->bhtail = bh;
bh299drivers/block/ll_rw_blk.cmark_buffer_clean(bh);
bh304drivers/block/ll_rw_blk.cif (req->dev == bh->b_dev &&
bh311drivers/block/ll_rw_blk.cbh->b_reqnext = req->bh;
bh312drivers/block/ll_rw_blk.creq->buffer = bh->b_data;
bh315drivers/block/ll_rw_blk.cmark_buffer_clean(bh);
bh316drivers/block/ll_rw_blk.creq->bh = bh;
bh326drivers/block/ll_rw_blk.creq = get_request(max_req, bh->b_dev);
bh332drivers/block/ll_rw_blk.cunlock_buffer(bh);
bh349drivers/block/ll_rw_blk.creq->buffer = bh->b_data;
bh351drivers/block/ll_rw_blk.creq->bh = bh;
bh352drivers/block/ll_rw_blk.creq->bhtail = bh;
bh384drivers/block/ll_rw_blk.creq->bh = NULL;
bh394drivers/block/ll_rw_blk.cvoid ll_rw_block(int rw, int nr, struct buffer_head * bh[])
bh404drivers/block/ll_rw_blk.cwhile (!*bh) {
bh405drivers/block/ll_rw_blk.cbh++;
bh411drivers/block/ll_rw_blk.cif ((major = MAJOR(bh[0]->b_dev)) < MAX_BLKDEV)
bh416drivers/block/ll_rw_blk.c(unsigned long) bh[0]->b_dev, bh[0]->b_blocknr);
bh423drivers/block/ll_rw_blk.ci = blksize_size[major][MINOR(bh[0]->b_dev)];
bh430drivers/block/ll_rw_blk.cif (bh[i] && bh[i]->b_size != correct_size) {
bh433drivers/block/ll_rw_blk.ccorrect_size, bh[i]->b_size);
bh438drivers/block/ll_rw_blk.cif ((rw == WRITE || rw == WRITEA) && is_read_only(bh[0]->b_dev)) {
bh439drivers/block/ll_rw_blk.cprintk("Can't write to read-only device 0x%X\n",bh[0]->b_dev);
bh458drivers/block/ll_rw_blk.cif (bh[i]) {
bh459drivers/block/ll_rw_blk.cbh[i]->b_req = 1;
bh460drivers/block/ll_rw_blk.cmake_request(major, rw, bh[i]);
bh477drivers/block/ll_rw_blk.cif (bh[i])
bh478drivers/block/ll_rw_blk.cbh[i]->b_dirt = bh[i]->b_uptodate = 0;
bh519drivers/block/ll_rw_blk.creq->bh = NULL;
bh615drivers/block/mcd.cif (CURRENT->bh) {
bh616drivers/block/mcd.cif (!CURRENT->bh->b_lock)
bh102drivers/block/ramdisk.cstruct buffer_head *bh;
bh129drivers/block/ramdisk.cbh = breada(ROOT_DEV,block+1,BLOCK_SIZE, 0,  PAGE_SIZE);
bh130drivers/block/ramdisk.cif (!bh) {
bh137drivers/block/ramdisk.c*((struct super_block *) bh->b_data);
bh138drivers/block/ramdisk.cbrelse(bh);
bh177drivers/block/ramdisk.cbh = breada(ROOT_DEV, block, BLOCK_SIZE, 0,  PAGE_SIZE);
bh179drivers/block/ramdisk.cbh = bread(ROOT_DEV, block, BLOCK_SIZE);
bh180drivers/block/ramdisk.cif (!bh) {
bh185drivers/block/ramdisk.c(void) memcpy(cp, bh->b_data, BLOCK_SIZE);
bh186drivers/block/ramdisk.cbrelse(bh);
bh692drivers/scsi/scsi.cstruct buffer_head * bh, *bhp;
bh715drivers/scsi/scsi.cbhp = bh = req->bh;
bh716drivers/scsi/scsi.cif(!tablesize) bh = NULL;
bh719drivers/scsi/scsi.cwhile(req->nr_sectors && bh){
bh721drivers/scsi/scsi.cif(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
bh722drivers/scsi/scsi.creq->nr_sectors -= bh->b_size >> 9;
bh723drivers/scsi/scsi.creq->sector += bh->b_size >> 9;
bh725drivers/scsi/scsi.cbh = bhp;
bh727drivers/scsi/scsi.cif(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
bh728drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
bh729drivers/scsi/scsi.creq->bh = bh->b_reqnext; /* Divide request */
bh730drivers/scsi/scsi.cbh->b_reqnext = NULL;
bh731drivers/scsi/scsi.cbh = req->bh;
bh735drivers/scsi/scsi.creq->current_nr_sectors = bh->b_size >> 9;
bh736drivers/scsi/scsi.creq->buffer = bh->b_data;
bh771drivers/scsi/scsi.cstruct buffer_head * bh, *bhp;
bh820drivers/scsi/scsi.cbhp = bh = req->bh;
bh821drivers/scsi/scsi.cif(!tablesize) bh = NULL;
bh824drivers/scsi/scsi.cwhile(req->nr_sectors && bh){
bh826drivers/scsi/scsi.cif(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
bh827drivers/scsi/scsi.creq->nr_sectors -= bh->b_size >> 9;
bh828drivers/scsi/scsi.creq->sector += bh->b_size >> 9;
bh830drivers/scsi/scsi.cbh = bhp;
bh832drivers/scsi/scsi.cif(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
bh833drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
bh834drivers/scsi/scsi.creq->bh = bh->b_reqnext; /* Divide request */
bh835drivers/scsi/scsi.cbh->b_reqnext = NULL;
bh836drivers/scsi/scsi.cbh = req->bh;
bh839drivers/scsi/scsi.creq->current_nr_sectors = bh->b_size >> 9;
bh840drivers/scsi/scsi.creq->buffer = bh->b_data;
bh536drivers/scsi/scsi.hstruct buffer_head * bh;
bh546drivers/scsi/scsi.hif ((bh = req->bh) != NULL) {
bh547drivers/scsi/scsi.hreq->bh = bh->b_reqnext;
bh548drivers/scsi/scsi.hreq->nr_sectors -= bh->b_size >> 9;
bh549drivers/scsi/scsi.hreq->sector += bh->b_size >> 9;
bh550drivers/scsi/scsi.hbh->b_reqnext = NULL;
bh551drivers/scsi/scsi.hbh->b_uptodate = uptodate;
bh552drivers/scsi/scsi.hunlock_buffer(bh);
bh553drivers/scsi/scsi.hsectors -= bh->b_size >> 9;
bh554drivers/scsi/scsi.hif ((bh = req->bh) != NULL) {
bh555drivers/scsi/scsi.hreq->current_nr_sectors = bh->b_size >> 9;
bh562drivers/scsi/scsi.h} while(sectors && bh);
bh563drivers/scsi/scsi.hif (req->bh){
bh564drivers/scsi/scsi.hreq->buffer = bh->b_data;
bh599drivers/scsi/scsi.hif (CURRENT->bh) { \
bh600drivers/scsi/scsi.hif (!CURRENT->bh->b_lock) \
bh68drivers/scsi/scsi_debug.cif (bh){              \
bh69drivers/scsi/scsi_debug.cif (bh->b_size != 1024) panic ("Wrong bh size");  \
bh70drivers/scsi/scsi_debug.cif ((bh->b_blocknr << 1) + start != block)           \
bh71drivers/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",bh->b_blocknr, block);  \
bh73drivers/scsi/scsi_debug.cif (bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
bh93drivers/scsi/scsi_debug.cif (SCpnt->request.bh){              \
bh94drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_size != 1024) panic ("Wrong bh size");  \
bh95drivers/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
bh96drivers/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
bh98drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
bh160drivers/scsi/scsi_debug.cstruct buffer_head * bh = NULL;
bh263drivers/scsi/scsi_debug.cbh = SCpnt->request.bh;
bh323drivers/scsi/scsi_debug.cmemcpy(buff+128, bh, sizeof(struct buffer_head));
bh326drivers/scsi/scsi_debug.cbh = bh->b_reqnext;
bh329drivers/scsi/scsi_debug.cif(!bh) panic("Too few blocks for linked request.");
bh341drivers/scsi/scsi_debug.cif(bh) scsi_dump(SCpnt, 0);
bh21drivers/scsi/scsicam.cstatic int partsize(struct buffer_head *bh, unsigned long capacity,
bh40drivers/scsi/scsicam.cstruct buffer_head *bh;
bh44drivers/scsi/scsicam.cif (!(bh = bread(dev & ~0xf,0,1024)))
bh50drivers/scsi/scsicam.cret_code = partsize (bh, (unsigned long) size, (unsigned int *) ip + 2, 
bh52drivers/scsi/scsicam.cbrelse (bh);
bh76drivers/scsi/scsicam.cstatic int partsize(struct buffer_head *bh, unsigned long capacity,
bh84drivers/scsi/scsicam.cif (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
bh86drivers/scsi/scsicam.c(0x1BE + bh->b_data), i = 0; i < 4; ++i, ++p) {
bh238drivers/scsi/sd.cif (!SCpnt->request.bh)
bh431drivers/scsi/sd.cstruct buffer_head * bh, *bhp;
bh522drivers/scsi/sd.cif (contiguous && SCpnt->request.bh &&
bh523drivers/scsi/sd.c((long) SCpnt->request.bh->b_data) + (SCpnt->request.nr_sectors << 9) - 1 > 
bh525drivers/scsi/sd.cif(((long) SCpnt->request.bh->b_data) > ISA_DMA_THRESHOLD)
bh530drivers/scsi/sd.cif(contiguous && SCpnt->request.bh && SCpnt->request.bh->b_reqnext)
bh531drivers/scsi/sd.cfor(bh = SCpnt->request.bh, bhp = bh->b_reqnext; bhp; bh = bhp, 
bh533drivers/scsi/sd.cif(!CONTIGUOUS_BUFFERS(bh,bhp)) { 
bh539drivers/scsi/sd.cif (!SCpnt->request.bh || contiguous) {
bh573drivers/scsi/sd.cbh = SCpnt->request.bh;
bh578drivers/scsi/sd.cwhile(bh) {
bh579drivers/scsi/sd.cif ((this_count + (bh->b_size >> 9)) > this_count_max) break;
bh580drivers/scsi/sd.cif(!bhp || !CONTIGUOUS_BUFFERS(bhp,bh) ||
bh583drivers/scsi/sd.c((unsigned long) bh->b_data-1) == ISA_DMA_THRESHOLD)) {
bh587drivers/scsi/sd.cthis_count += (bh->b_size >> 9);
bh588drivers/scsi/sd.cbhp = bh;
bh589drivers/scsi/sd.cbh = bh->b_reqnext;
bh593drivers/scsi/sd.c((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
bh612drivers/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
bh613drivers/scsi/sd.ccount < SCpnt->use_sg && bh; 
bh614drivers/scsi/sd.ccount++, bh = bhp) {
bh616drivers/scsi/sd.cbhp = bh->b_reqnext;
bh618drivers/scsi/sd.cif(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
bh619drivers/scsi/sd.csgpnt[count].length += bh->b_size;
bh620drivers/scsi/sd.ccounted += bh->b_size >> 9;
bh652drivers/scsi/sd.cthis_count = counted -= bh->b_size >> 9;
bh662drivers/scsi/sd.cif(bhp && CONTIGUOUS_BUFFERS(bh,bhp) && CLUSTERABLE_DEVICE(SCpnt)) {
bh694drivers/scsi/sd.cbh = SCpnt->request.bh;
bh697drivers/scsi/sd.cwhile(bh){
bh698drivers/scsi/sd.cprintk("[%p %lx] ", bh->b_data, bh->b_size);
bh699drivers/scsi/sd.cbh = bh->b_reqnext;
bh146drivers/scsi/sr.cprintk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
bh164drivers/scsi/sr.cSCpnt->request.bh &&
bh165drivers/scsi/sr.cSCpnt->request.bh->b_reqnext &&
bh166drivers/scsi/sr.cSCpnt->request.bh->b_reqnext->b_size == 1024) {
bh167drivers/scsi/sr.cmemcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
bh195drivers/scsi/sr.cprintk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, 
bh201drivers/scsi/sr.cif (!SCpnt->request.bh)
bh626drivers/scsi/sr.cstruct buffer_head * bh;
bh629drivers/scsi/sr.cbh = SCpnt->request.bh;
bh637drivers/scsi/sr.cwhile(bh && count < SCpnt->host->sg_tablesize) {
bh638drivers/scsi/sr.cif ((this_count + (bh->b_size >> 9)) > this_count_max) break;
bh639drivers/scsi/sr.cthis_count += (bh->b_size >> 9);
bh641drivers/scsi/sr.cbh = bh->b_reqnext;
bh667drivers/scsi/sr.cbh = SCpnt->request.bh;
bh676drivers/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
bh677drivers/scsi/sr.ccount++, bh = bh->b_reqnext) {
bh678drivers/scsi/sr.cif (bh) { /* Need a placeholder at the end of the record? */
bh679drivers/scsi/sr.csgpnt[count].address = bh->b_data;
bh680drivers/scsi/sr.csgpnt[count].length = bh->b_size;
bh734drivers/scsi/sr.cif (!SCpnt->request.bh)    
bh737drivers/scsi/sr.cthis_count = (SCpnt->request.bh->b_size >> 9);
bh35fs/block_dev.cstruct buffer_head * bh, *bufferlist[NBUF];
bh72fs/block_dev.cbh = getblk(dev, block, blocksize);
bh74fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
bh80fs/block_dev.cbh = getblk(dev, block, blocksize);
bh82fs/block_dev.cif (chars != blocksize && !bh->b_uptodate) {
bh86fs/block_dev.cbrelse(bh);
bh87fs/block_dev.cbh = bread(dev,block,blocksize);
bh96fs/block_dev.cbhlist[0] = bh;
bh110fs/block_dev.cwait_on_buffer(bh);
bh116fs/block_dev.cif (!bh)
bh118fs/block_dev.cp = offset + bh->b_data;
bh126fs/block_dev.cbh->b_uptodate = 1;
bh127fs/block_dev.cmark_buffer_dirty(bh, 0);
bh129fs/block_dev.cbufferlist[buffercount++] = bh;
bh131fs/block_dev.cbrelse(bh);
bh110fs/buffer.cvoid __wait_on_buffer(struct buffer_head * bh)
bh114fs/buffer.cbh->b_count++;
bh115fs/buffer.cadd_wait_queue(&bh->b_wait, &wait);
bh118fs/buffer.cif (bh->b_lock) {
bh122fs/buffer.cremove_wait_queue(&bh->b_wait, &wait);
bh123fs/buffer.cbh->b_count--;
bh141fs/buffer.cstruct buffer_head * bh, *next;
bh156fs/buffer.cbh = lru_list[nlist];
bh157fs/buffer.cif(!bh) continue;
bh158fs/buffer.cfor (i = nr_buffers_type[nlist]*2 ; i-- > 0 ; bh = next) {
bh159fs/buffer.cif(bh->b_list != nlist) goto repeat1;
bh160fs/buffer.cnext = bh->b_next_free;
bh162fs/buffer.cif (dev && bh->b_dev != dev)
bh164fs/buffer.cif (bh->b_lock)
bh172fs/buffer.cwait_on_buffer (bh);
bh177fs/buffer.cif (wait && bh->b_req && !bh->b_lock &&
bh178fs/buffer.c!bh->b_dirt && !bh->b_uptodate) {
bh180fs/buffer.cprintk("Weird - unlocked, clean and not uptodate buffer on list %d %x %lu\n", nlist, bh->b_dev, bh->b_blocknr);
bh185fs/buffer.cif (!bh->b_dirt || pass>=2)
bh188fs/buffer.cif (bh->b_lock)
bh190fs/buffer.cbh->b_count++;
bh191fs/buffer.cbh->b_flushtime = 0;
bh192fs/buffer.cll_rw_block(WRITE, 1, &bh);
bh195fs/buffer.cprintk("[%d %x %ld] ", nlist, bh->b_dev, bh->b_blocknr);
bh198fs/buffer.cbh->b_count--;
bh258fs/buffer.cstruct buffer_head * bh;
bh261fs/buffer.cbh = lru_list[nlist];
bh262fs/buffer.cfor (i = nr_buffers_type[nlist]*2 ; --i > 0 ; bh = bh->b_next_free) {
bh263fs/buffer.cif (bh->b_dev != dev)
bh265fs/buffer.cwait_on_buffer(bh);
bh266fs/buffer.cif (bh->b_dev != dev)
bh268fs/buffer.cif (bh->b_count)
bh270fs/buffer.cbh->b_flushtime = bh->b_uptodate = 
bh271fs/buffer.cbh->b_dirt = bh->b_req = 0;
bh279fs/buffer.cstatic inline void remove_from_hash_queue(struct buffer_head * bh)
bh281fs/buffer.cif (bh->b_next)
bh282fs/buffer.cbh->b_next->b_prev = bh->b_prev;
bh283fs/buffer.cif (bh->b_prev)
bh284fs/buffer.cbh->b_prev->b_next = bh->b_next;
bh285fs/buffer.cif (hash(bh->b_dev,bh->b_blocknr) == bh)
bh286fs/buffer.chash(bh->b_dev,bh->b_blocknr) = bh->b_next;
bh287fs/buffer.cbh->b_next = bh->b_prev = NULL;
bh290fs/buffer.cstatic inline void remove_from_lru_list(struct buffer_head * bh)
bh292fs/buffer.cif (!(bh->b_prev_free) || !(bh->b_next_free))
bh294fs/buffer.cif (bh->b_dev == 0xffff) panic("LRU list corrupted");
bh295fs/buffer.cbh->b_prev_free->b_next_free = bh->b_next_free;
bh296fs/buffer.cbh->b_next_free->b_prev_free = bh->b_prev_free;
bh298fs/buffer.cif (lru_list[bh->b_list] == bh)
bh299fs/buffer.clru_list[bh->b_list] = bh->b_next_free;
bh300fs/buffer.cif(lru_list[bh->b_list] == bh)
bh301fs/buffer.clru_list[bh->b_list] = NULL;
bh302fs/buffer.cbh->b_next_free = bh->b_prev_free = NULL;
bh305fs/buffer.cstatic inline void remove_from_free_list(struct buffer_head * bh)
bh307fs/buffer.cint isize = BUFSIZE_INDEX(bh->b_size);
bh308fs/buffer.cif (!(bh->b_prev_free) || !(bh->b_next_free))
bh310fs/buffer.cif(bh->b_dev != 0xffff) panic("Free list corrupted");
bh314fs/buffer.cif(bh->b_next_free == bh)
bh317fs/buffer.cbh->b_prev_free->b_next_free = bh->b_next_free;
bh318fs/buffer.cbh->b_next_free->b_prev_free = bh->b_prev_free;
bh319fs/buffer.cif (free_list[isize] == bh)
bh320fs/buffer.cfree_list[isize] = bh->b_next_free;
bh322fs/buffer.cbh->b_next_free = bh->b_prev_free = NULL;
bh325fs/buffer.cstatic inline void remove_from_queues(struct buffer_head * bh)
bh327fs/buffer.cif(bh->b_dev == 0xffff) {
bh328fs/buffer.cremove_from_free_list(bh); /* Free list entries should not be
bh332fs/buffer.cnr_buffers_type[bh->b_list]--;
bh333fs/buffer.cnr_buffers_st[BUFSIZE_INDEX(bh->b_size)][bh->b_list]--;
bh334fs/buffer.cremove_from_hash_queue(bh);
bh335fs/buffer.cremove_from_lru_list(bh);
bh338fs/buffer.cstatic inline void put_last_lru(struct buffer_head * bh)
bh340fs/buffer.cif (!bh)
bh342fs/buffer.cif (bh == lru_list[bh->b_list]) {
bh343fs/buffer.clru_list[bh->b_list] = bh->b_next_free;
bh346fs/buffer.cif(bh->b_dev == 0xffff) panic("Wrong block for lru list");
bh347fs/buffer.cremove_from_lru_list(bh);
bh350fs/buffer.cif(!lru_list[bh->b_list]) {
bh351fs/buffer.clru_list[bh->b_list] = bh;
bh352fs/buffer.clru_list[bh->b_list]->b_prev_free = bh;
bh355fs/buffer.cbh->b_next_free = lru_list[bh->b_list];
bh356fs/buffer.cbh->b_prev_free = lru_list[bh->b_list]->b_prev_free;
bh357fs/buffer.clru_list[bh->b_list]->b_prev_free->b_next_free = bh;
bh358fs/buffer.clru_list[bh->b_list]->b_prev_free = bh;
bh361fs/buffer.cstatic inline void put_last_free(struct buffer_head * bh)
bh364fs/buffer.cif (!bh)
bh367fs/buffer.cisize = BUFSIZE_INDEX(bh->b_size);  
bh368fs/buffer.cbh->b_dev = 0xffff;  /* So it is obvious we are on the free list */
bh372fs/buffer.cfree_list[isize] = bh;
bh373fs/buffer.cbh->b_prev_free = bh;
bh377fs/buffer.cbh->b_next_free = free_list[isize];
bh378fs/buffer.cbh->b_prev_free = free_list[isize]->b_prev_free;
bh379fs/buffer.cfree_list[isize]->b_prev_free->b_next_free = bh;
bh380fs/buffer.cfree_list[isize]->b_prev_free = bh;
bh383fs/buffer.cstatic inline void insert_into_queues(struct buffer_head * bh)
bh387fs/buffer.cif(bh->b_dev == 0xffff) {
bh388fs/buffer.cput_last_free(bh);
bh391fs/buffer.cif(!lru_list[bh->b_list]) {
bh392fs/buffer.clru_list[bh->b_list] = bh;
bh393fs/buffer.cbh->b_prev_free = bh;
bh395fs/buffer.cif (bh->b_next_free) panic("VFS: buffer LRU pointers corrupted");
bh396fs/buffer.cbh->b_next_free = lru_list[bh->b_list];
bh397fs/buffer.cbh->b_prev_free = lru_list[bh->b_list]->b_prev_free;
bh398fs/buffer.clru_list[bh->b_list]->b_prev_free->b_next_free = bh;
bh399fs/buffer.clru_list[bh->b_list]->b_prev_free = bh;
bh400fs/buffer.cnr_buffers_type[bh->b_list]++;
bh401fs/buffer.cnr_buffers_st[BUFSIZE_INDEX(bh->b_size)][bh->b_list]++;
bh403fs/buffer.cbh->b_prev = NULL;
bh404fs/buffer.cbh->b_next = NULL;
bh405fs/buffer.cif (!bh->b_dev)
bh407fs/buffer.cbh->b_next = hash(bh->b_dev,bh->b_blocknr);
bh408fs/buffer.chash(bh->b_dev,bh->b_blocknr) = bh;
bh409fs/buffer.cif (bh->b_next)
bh410fs/buffer.cbh->b_next->b_prev = bh;
bh438fs/buffer.cstruct buffer_head * bh;
bh441fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
bh443fs/buffer.cbh->b_count++;
bh444fs/buffer.cwait_on_buffer(bh);
bh445fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
bh446fs/buffer.creturn bh;
bh447fs/buffer.cbh->b_count--;
bh454fs/buffer.cstruct buffer_head * bh, *bhnext;
bh477fs/buffer.cbh = lru_list[nlist];
bh478fs/buffer.cfor (i = nr_buffers_type[nlist]*2 ; --i > 0 ; bh = bhnext) {
bh479fs/buffer.cif(!bh) break;
bh480fs/buffer.cbhnext = bh->b_next_free; 
bh481fs/buffer.cif (bh->b_dev != dev)
bh483fs/buffer.cif (bh->b_size == size)
bh486fs/buffer.cwait_on_buffer(bh);
bh487fs/buffer.cif (bh->b_dev == dev && bh->b_size != size) {
bh488fs/buffer.cbh->b_uptodate = bh->b_dirt = bh->b_req =
bh489fs/buffer.cbh->b_flushtime = 0;
bh491fs/buffer.cremove_from_hash_queue(bh);
bh496fs/buffer.c#define BADNESS(bh) (((bh)->b_dirt<<1)+(bh)->b_lock)
bh500fs/buffer.cstruct buffer_head * bh, * tmp;
bh554fs/buffer.cfor (bh = lru_list[i]; buffers[i] > 0; bh = tmp, buffers[i]--)
bh557fs/buffer.ctmp = bh->b_next_free;
bh558fs/buffer.cif (!bh) break;
bh560fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)] != 1 ||
bh561fs/buffer.cbh->b_dirt) {
bh562fs/buffer.crefile_buffer(bh);
bh566fs/buffer.cif (bh->b_count || bh->b_size != size)
bh573fs/buffer.cif(bh->b_lock && (i == BUF_LOCKED || i == BUF_LOCKED1)) {
bh578fs/buffer.cif (BADNESS(bh)) continue;
bh582fs/buffer.celse candidate[i] = bh;
bh603fs/buffer.cbh = candidate[i];
bh604fs/buffer.ccandidate[i] = bh->b_next_free;
bh605fs/buffer.cif(candidate[i] == bh) candidate[i] = NULL;  /* Got last one */
bh606fs/buffer.cif (bh->b_count || bh->b_size != size)
bh608fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)] != 1)
bh610fs/buffer.cif (BADNESS(bh)) panic("Buffer in candidate list with BADNESS != 0\n");
bh612fs/buffer.cif(bh->b_dev == 0xffff) panic("Wrong list");
bh613fs/buffer.cremove_from_queues(bh);
bh614fs/buffer.cbh->b_dev = 0xffff;
bh615fs/buffer.cput_last_free(bh);
bh616fs/buffer.cneeded -= bh->b_size;
bh626fs/buffer.cfor (bh = candidate[i]; buffers[i] > 0; bh = tmp, buffers[i]--) {
bh628fs/buffer.ctmp = bh->b_next_free;
bh629fs/buffer.cif (!bh) break;
bh631fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)] != 1 ||
bh632fs/buffer.cbh->b_dirt) {
bh633fs/buffer.crefile_buffer(bh);
bh637fs/buffer.cif (bh->b_count || bh->b_size != size)
bh644fs/buffer.cif(bh->b_lock && (i == BUF_LOCKED || i == BUF_LOCKED1)) {
bh649fs/buffer.cif (BADNESS(bh)) continue;
bh653fs/buffer.celse candidate[i] = bh;
bh691fs/buffer.cstruct buffer_head * bh;
bh701fs/buffer.cbh = get_hash_table(dev, block, size);
bh702fs/buffer.cif (bh) {
bh703fs/buffer.cif (bh->b_uptodate && !bh->b_dirt)
bh704fs/buffer.cput_last_lru(bh);
bh705fs/buffer.cif(!bh->b_dirt) bh->b_flushtime = 0;
bh706fs/buffer.creturn bh;
bh714fs/buffer.cbh = free_list[isize];
bh715fs/buffer.cremove_from_free_list(bh);
bh719fs/buffer.cbh->b_count=1;
bh720fs/buffer.cbh->b_dirt=0;
bh721fs/buffer.cbh->b_lock=0;
bh722fs/buffer.cbh->b_uptodate=0;
bh723fs/buffer.cbh->b_flushtime = 0;
bh724fs/buffer.cbh->b_req=0;
bh725fs/buffer.cbh->b_dev=dev;
bh726fs/buffer.cbh->b_blocknr=block;
bh727fs/buffer.cinsert_into_queues(bh);
bh728fs/buffer.creturn bh;
bh802fs/buffer.cstruct buffer_head * bh;
bh804fs/buffer.cif (!(bh = getblk(dev, block, size))) {
bh809fs/buffer.cif (bh->b_uptodate)
bh810fs/buffer.creturn bh;
bh811fs/buffer.cll_rw_block(READ, 1, &bh);
bh812fs/buffer.cwait_on_buffer(bh);
bh813fs/buffer.cif (bh->b_uptodate)
bh814fs/buffer.creturn bh;
bh815fs/buffer.cbrelse(bh);
bh832fs/buffer.cstruct buffer_head * bh;
bh839fs/buffer.cif (block < 0 || !(bh = getblk(dev,block,bufsize)))
bh842fs/buffer.cindex = BUFSIZE_INDEX(bh->b_size);
bh844fs/buffer.cif (bh->b_uptodate)
bh845fs/buffer.creturn bh;
bh854fs/buffer.cbhlist[0] = bh;
bh857fs/buffer.cbh = getblk(dev,block+i,bufsize);
bh858fs/buffer.cif (bh->b_uptodate) {
bh859fs/buffer.cbrelse(bh);
bh862fs/buffer.cbhlist[j++] = bh;
bh872fs/buffer.cbh = bhlist[0];
bh873fs/buffer.cwait_on_buffer(bh);
bh874fs/buffer.cif (bh->b_uptodate)
bh875fs/buffer.creturn bh;
bh876fs/buffer.cbrelse(bh);
bh883fs/buffer.cstatic void put_unused_buffer_head(struct buffer_head * bh)
bh887fs/buffer.cwait = ((volatile struct buffer_head *) bh)->b_wait;
bh888fs/buffer.cmemset(bh,0,sizeof(*bh));
bh889fs/buffer.c((volatile struct buffer_head *) bh)->b_wait = wait;
bh890fs/buffer.cbh->b_next_free = unused_list;
bh891fs/buffer.cunused_list = bh;
bh897fs/buffer.cstruct buffer_head * bh;
bh902fs/buffer.cif (!(bh = (struct buffer_head*) get_free_page(GFP_BUFFER)))
bh905fs/buffer.cfor (nr_buffer_heads+=i=PAGE_SIZE/sizeof*bh ; i>0; i--) {
bh906fs/buffer.cbh->b_next_free = unused_list;  /* only make link */
bh907fs/buffer.cunused_list = bh++;
bh913fs/buffer.cstruct buffer_head * bh;
bh918fs/buffer.cbh = unused_list;
bh919fs/buffer.cunused_list = bh->b_next_free;
bh920fs/buffer.cbh->b_next_free = NULL;
bh921fs/buffer.cbh->b_data = NULL;
bh922fs/buffer.cbh->b_size = 0;
bh923fs/buffer.cbh->b_req = 0;
bh924fs/buffer.creturn bh;
bh935fs/buffer.cstruct buffer_head *bh, *head;
bh941fs/buffer.cbh = get_unused_buffer_head();
bh942fs/buffer.cif (!bh)
bh944fs/buffer.cbh->b_this_page = head;
bh945fs/buffer.chead = bh;
bh946fs/buffer.cbh->b_data = (char *) (page+offset);
bh947fs/buffer.cbh->b_size = size;
bh948fs/buffer.cbh->b_dev = 0xffff;  /* Flag as unused */
bh955fs/buffer.cbh = head;
bh956fs/buffer.cwhile (bh) {
bh957fs/buffer.chead = bh;
bh958fs/buffer.cbh = bh->b_this_page;
bh964fs/buffer.cstatic void read_buffers(struct buffer_head * bh[], int nrbuf)
bh971fs/buffer.cif (bh[i] && !bh[i]->b_uptodate)
bh972fs/buffer.cbhr[bhnum++] = bh[i];
bh977fs/buffer.cif (bh[i]) {
bh978fs/buffer.cwait_on_buffer(bh[i]);
bh991fs/buffer.cstatic unsigned long try_to_align(struct buffer_head ** bh, int nrbuf,
bh995fs/buffer.cbrelse(bh[nrbuf]);
bh1002fs/buffer.cstruct buffer_head * bh[MAX_BUF_PER_PAGE];
bh1009fs/buffer.cbh[0] = first;
bh1021fs/buffer.cbh[nrbuf++] = first;
bh1026fs/buffer.creturn try_to_align(bh, nrbuf, address);
bh1028fs/buffer.cread_buffers(bh,nrbuf);    /* make sure they are actually read correctly */
bh1030fs/buffer.cbrelse(bh[nrbuf]);
bh1036fs/buffer.cbrelse(bh[nrbuf]);
bh1043fs/buffer.cstruct buffer_head * bh, * tmp, * arr[MAX_BUF_PER_PAGE];
bh1049fs/buffer.cbh = create_buffers(address, size);
bh1050fs/buffer.cif (!bh)
bh1061fs/buffer.ctmp = bh;
bh1065fs/buffer.carr[block++] = bh;
bh1066fs/buffer.cbh->b_count = 1;
bh1067fs/buffer.cbh->b_dirt = 0;
bh1068fs/buffer.cbh->b_flushtime = 0;
bh1069fs/buffer.cbh->b_uptodate = 0;
bh1070fs/buffer.cbh->b_req = 0;
bh1071fs/buffer.cbh->b_dev = dev;
bh1072fs/buffer.cbh->b_blocknr = *(p++);
bh1073fs/buffer.cbh->b_list = BUF_CLEAN;
bh1076fs/buffer.cinsert_into_queues(bh);
bh1077fs/buffer.cif (bh->b_this_page)
bh1078fs/buffer.cbh = bh->b_this_page;
bh1083fs/buffer.cbh->b_this_page = tmp;
bh1085fs/buffer.cbuffer_pages[MAP_NR(address)] = bh;
bh1092fs/buffer.cwhile ((tmp = bh) != NULL) {
bh1093fs/buffer.cbh = bh->b_this_page;
bh1113fs/buffer.cstruct buffer_head * bh;
bh1119fs/buffer.cbh = get_hash_table(dev, block, size);
bh1120fs/buffer.cif (bh)
bh1121fs/buffer.creturn check_aligned(bh, address, dev, b, size);
bh1134fs/buffer.cstruct buffer_head * bh[MAX_BUF_PER_PAGE];
bh1145fs/buffer.cbh[i] = NULL;
bh1147fs/buffer.cbh[i] = getblk(dev, b[i], size);
bh1149fs/buffer.cread_buffers(bh,i);
bh1152fs/buffer.cif (bh[i]) {
bh1153fs/buffer.cif (bh[i]->b_uptodate)
bh1154fs/buffer.cmemcpy((void *) where, bh[i]->b_data, size);
bh1155fs/buffer.cbrelse(bh[i]);
bh1168fs/buffer.cstruct buffer_head *bh, *tmp;
bh1181fs/buffer.cbh = create_buffers(page, size);
bh1182fs/buffer.cif (!bh) {
bh1189fs/buffer.ctmp = bh;
bh1208fs/buffer.cfree_list[isize] = bh;
bh1209fs/buffer.cbuffer_pages[MAP_NR(page)] = bh;
bh1210fs/buffer.ctmp->b_this_page = bh;
bh1223fs/buffer.cstatic int try_to_free(struct buffer_head * bh, struct buffer_head ** bhp)
bh1227fs/buffer.cint isize = BUFSIZE_INDEX(bh->b_size);
bh1229fs/buffer.c*bhp = bh;
bh1230fs/buffer.cpage = (unsigned long) bh->b_data;
bh1232fs/buffer.ctmp = bh;
bh1239fs/buffer.c} while (tmp != bh);
bh1240fs/buffer.ctmp = bh;
bh1254fs/buffer.c} while (tmp != bh);
bh1334fs/buffer.cstruct buffer_head *bh;
bh1347fs/buffer.cbh = free_list[isize];
bh1348fs/buffer.cif(!bh) continue;
bh1349fs/buffer.cfor (i=0 ; !i || bh != free_list[isize]; bh = bh->b_next_free, i++) {
bh1350fs/buffer.cif (bh->b_count || !bh->b_this_page)
bh1352fs/buffer.cif (try_to_free(bh, &bh))
bh1354fs/buffer.cif(!bh) break; /* Some interrupt must have used it after we
bh1364fs/buffer.cbh = lru_list[nlist];
bh1365fs/buffer.cif(!bh) continue;
bh1367fs/buffer.cfor ( ; i-- > 0 ; bh = bh->b_next_free) {
bh1369fs/buffer.cif(bh->b_list != nlist) goto repeat1;
bh1370fs/buffer.cif (bh->b_count || !bh->b_this_page)
bh1372fs/buffer.cif(size && bh->b_size != size) continue;
bh1373fs/buffer.cif (bh->b_lock)
bh1377fs/buffer.cwait_on_buffer(bh);
bh1378fs/buffer.cif (bh->b_dirt) {
bh1379fs/buffer.cbh->b_count++;
bh1380fs/buffer.cbh->b_flushtime = 0;
bh1381fs/buffer.cll_rw_block(WRITEA, 1, &bh);
bh1382fs/buffer.cbh->b_count--;
bh1385fs/buffer.cif (try_to_free(bh, &bh))
bh1387fs/buffer.cif(!bh) break;
bh1398fs/buffer.cstruct buffer_head * bh;
bh1409fs/buffer.cbh = lru_list[nlist];
bh1410fs/buffer.cif(!bh) continue;
bh1413fs/buffer.cif (bh->b_lock)
bh1415fs/buffer.cif (bh->b_dirt)
bh1417fs/buffer.cif(mem_map[MAP_NR(((unsigned long) bh->b_data))] !=1) shared++;
bh1418fs/buffer.cif (bh->b_count)
bh1420fs/buffer.cbh = bh->b_next_free;
bh1421fs/buffer.c} while (bh != lru_list[nlist]);
bh1442fs/buffer.cstatic inline int try_to_reassign(struct buffer_head * bh, struct buffer_head ** bhp,
bh1448fs/buffer.c*bhp = bh;
bh1449fs/buffer.cpage = (unsigned long) bh->b_data;
bh1452fs/buffer.ctmp = bh;
bh1460fs/buffer.c} while (tmp != bh);
bh1461fs/buffer.ctmp = bh;
bh1467fs/buffer.cbh = tmp;
bh1477fs/buffer.c} while (tmp != bh);
bh1498fs/buffer.cstruct buffer_head *bh;
bh1508fs/buffer.cbh = free_list[isize];
bh1509fs/buffer.cif(bh)
bh1510fs/buffer.cfor (i=0 ; !i || bh != free_list[isize] ; bh = bh->b_next_free, i++) {
bh1511fs/buffer.cif (!bh->b_this_page)  continue;
bh1512fs/buffer.cif (try_to_reassign(bh, &bh, dev, starting_block))
bh1524fs/buffer.cstruct buffer_head * bh, * tmp, * arr[MAX_BUF_PER_PAGE];
bh1533fs/buffer.cbh = create_buffers(page, size);
bh1534fs/buffer.cif (!bh) {
bh1543fs/buffer.ctmp = bh;
bh1546fs/buffer.carr[nblock++] = bh;
bh1547fs/buffer.cbh->b_count = 1;
bh1548fs/buffer.cbh->b_dirt = 0;
bh1549fs/buffer.cbh->b_flushtime = 0;
bh1550fs/buffer.cbh->b_lock = 0;
bh1551fs/buffer.cbh->b_uptodate = 0;
bh1552fs/buffer.cbh->b_req = 0;
bh1553fs/buffer.cbh->b_dev = dev;
bh1554fs/buffer.cbh->b_list = BUF_CLEAN;
bh1555fs/buffer.cbh->b_blocknr = block++;
bh1558fs/buffer.cinsert_into_queues(bh);
bh1559fs/buffer.cif (bh->b_this_page)
bh1560fs/buffer.cbh = bh->b_this_page;
bh1565fs/buffer.cbuffer_pages[MAP_NR(page)] = bh;
bh1566fs/buffer.cbh->b_this_page = tmp;
bh1571fs/buffer.cwhile ((tmp = bh) != NULL) {
bh1572fs/buffer.cbh = bh->b_this_page;
bh1689fs/buffer.cstruct buffer_head * bh, *next;
bh1704fs/buffer.cbh = lru_list[nlist];
bh1705fs/buffer.cif(bh) 
bh1706fs/buffer.cfor (i = nr_buffers_type[nlist]; i-- > 0; bh = next) {
bh1708fs/buffer.cif(bh->b_list != nlist) goto repeat;
bh1709fs/buffer.cnext = bh->b_next_free;
bh1716fs/buffer.cif (nlist == BUF_DIRTY && !bh->b_dirt && !bh->b_lock)
bh1718fs/buffer.crefile_buffer(bh);
bh1722fs/buffer.cif (bh->b_lock || !bh->b_dirt)
bh1725fs/buffer.cif(bh->b_flushtime > jiffies) continue;
bh1727fs/buffer.cbh->b_count++;
bh1728fs/buffer.cbh->b_flushtime = 0;
bh1732fs/buffer.cll_rw_block(WRITE, 1, &bh);
bh1733fs/buffer.cbh->b_count--;
bh1764fs/buffer.cstruct buffer_head * bh, *next;
bh1810fs/buffer.cbh = lru_list[nlist];
bh1811fs/buffer.cif(bh) 
bh1813fs/buffer.cbh = next) {
bh1815fs/buffer.cif(bh->b_list != nlist) goto repeat;
bh1816fs/buffer.cnext = bh->b_next_free;
bh1823fs/buffer.cif (nlist == BUF_DIRTY && !bh->b_dirt && !bh->b_lock)
bh1825fs/buffer.crefile_buffer(bh);
bh1829fs/buffer.cif (bh->b_lock || !bh->b_dirt)
bh1833fs/buffer.cbh->b_count++;
bh1835fs/buffer.cbh->b_flushtime = 0;
bh1836fs/buffer.cll_rw_block(WRITE, 1, &bh);
bh1840fs/buffer.cbh->b_count--;
bh74fs/ext/dir.cstruct buffer_head * bh;
bh84fs/ext/dir.cbh = ext_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
bh85fs/ext/dir.cif (!bh) {
bh90fs/ext/dir.cde = (struct ext_dir_entry *) (bh->b_data + i);
bh96fs/ext/dir.cde = (struct ext_dir_entry *) (offset + bh->b_data);
bh128fs/ext/dir.cbrelse(bh);
bh201fs/ext/file.cstruct buffer_head * bh;
bh222fs/ext/file.cbh = ext_getblk(inode,pos/BLOCK_SIZE,1);
bh223fs/ext/file.cif (!bh) {
bh231fs/ext/file.cif (c != BLOCK_SIZE && !bh->b_uptodate) {
bh232fs/ext/file.cll_rw_block(READ, 1, &bh);
bh233fs/ext/file.cwait_on_buffer(bh);
bh234fs/ext/file.cif (!bh->b_uptodate) {
bh235fs/ext/file.cbrelse(bh);
bh241fs/ext/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
bh250fs/ext/file.cbh->b_uptodate = 1;
bh251fs/ext/file.cmark_buffer_dirty(bh, 0);
bh252fs/ext/file.cbrelse(bh);
bh42fs/ext/freelists.cstruct buffer_head * bh;
bh55fs/ext/freelists.cbh = get_hash_table(sb->s_dev, block, sb->s_blocksize);
bh56fs/ext/freelists.cif (bh)
bh57fs/ext/freelists.cbh->b_dirt=0;
bh58fs/ext/freelists.cbrelse(bh);
bh86fs/ext/freelists.cstruct buffer_head * bh;
bh125fs/ext/freelists.cif (!(bh=getblk(sb->s_dev, j, sb->s_blocksize))) {
bh129fs/ext/freelists.cmemset(bh->b_data, 0, BLOCK_SIZE);
bh130fs/ext/freelists.cbh->b_uptodate = 1;
bh131fs/ext/freelists.cmark_buffer_dirty(bh, 1);
bh132fs/ext/freelists.cbrelse(bh);
bh143fs/ext/freelists.cstruct buffer_head * bh;
bh155fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
bh159fs/ext/freelists.cefb = (struct ext_free_block *) bh->b_data;
bh162fs/ext/freelists.cbrelse (bh);
bh177fs/ext/freelists.cstruct buffer_head * bh;
bh222fs/ext/freelists.cif (!(bh = bread(dev, block, sb->s_blocksize)))
bh224fs/ext/freelists.cefi = ((struct ext_free_inode *) bh->b_data) +
bh229fs/ext/freelists.csb->u.ext_sb.s_firstfreeinodeblock = bh;
bh303fs/ext/freelists.cstruct buffer_head * bh;
bh322fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
bh326fs/ext/freelists.cefi = ((struct ext_free_inode *) bh->b_data) +
bh330fs/ext/freelists.cbrelse (bh);
bh32fs/ext/fsync.cstruct buffer_head * bh;
bh38fs/ext/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh39fs/ext/fsync.cif (!bh)
bh42fs/ext/fsync.cbrelse (bh);
bh45fs/ext/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh46fs/ext/fsync.cbrelse(bh);
bh49fs/ext/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt)
bh51fs/ext/fsync.cbrelse(bh);
bh54fs/ext/fsync.cll_rw_block(WRITE, 1, &bh);
bh55fs/ext/fsync.cbh->b_count--;
bh60fs/ext/fsync.cstruct buffer_head **bh, int wait) 
bh64fs/ext/fsync.c*bh = NULL;
bh71fs/ext/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh73fs/ext/fsync.cbrelse(*bh);
bh74fs/ext/fsync.c*bh = NULL;
bh77fs/ext/fsync.cif (!*bh)
bh60fs/ext/inode.cstruct buffer_head *bh;
bh66fs/ext/inode.cif (!(bh = bread(dev, 1, BLOCK_SIZE))) {
bh72fs/ext/inode.ces = (struct ext_super_block *) bh->b_data;
bh85fs/ext/inode.cbrelse(bh);
bh130fs/ext/inode.cstruct buffer_head * bh;
bh133fs/ext/inode.cif (!(bh = bread(sb->s_dev, 1, BLOCK_SIZE))) {
bh137fs/ext/inode.ces = (struct ext_super_block *) bh->b_data;
bh142fs/ext/inode.cmark_buffer_dirty(bh, 1);
bh143fs/ext/inode.cbrelse (bh);
bh166fs/ext/inode.cstatic int block_bmap(struct buffer_head * bh, int nr)
bh170fs/ext/inode.cif (!bh)
bh172fs/ext/inode.ctmp = ((unsigned long *) bh->b_data)[nr];
bh173fs/ext/inode.cbrelse(bh);
bh255fs/ext/inode.cstruct buffer_head * bh, int nr, int create)
bh261fs/ext/inode.cif (!bh)
bh263fs/ext/inode.cif (!bh->b_uptodate) {
bh264fs/ext/inode.cll_rw_block(READ, 1, &bh);
bh265fs/ext/inode.cwait_on_buffer(bh);
bh266fs/ext/inode.cif (!bh->b_uptodate) {
bh267fs/ext/inode.cbrelse(bh);
bh271fs/ext/inode.cp = nr + (unsigned long *) bh->b_data;
bh275fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh277fs/ext/inode.cbrelse(bh);
bh284fs/ext/inode.cbrelse(bh);
bh289fs/ext/inode.cbrelse(bh);
bh292fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh299fs/ext/inode.cmark_buffer_dirty(bh, 1);
bh300fs/ext/inode.cbrelse(bh);
bh306fs/ext/inode.cstruct buffer_head * bh;
bh320fs/ext/inode.cbh = inode_getblk(inode,9,create);
bh321fs/ext/inode.creturn block_getblk(inode,bh,block,create);
bh325fs/ext/inode.cbh = inode_getblk(inode,10,create);
bh326fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
bh327fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
bh330fs/ext/inode.cbh = inode_getblk(inode,11,create);
bh331fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
bh332fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
bh333fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
bh338fs/ext/inode.cstruct buffer_head * bh;
bh340fs/ext/inode.cbh = ext_getblk(inode,block,create);
bh341fs/ext/inode.cif (!bh || bh->b_uptodate) 
bh342fs/ext/inode.creturn bh;
bh343fs/ext/inode.cll_rw_block(READ, 1, &bh);
bh344fs/ext/inode.cwait_on_buffer(bh);
bh345fs/ext/inode.cif (bh->b_uptodate)
bh346fs/ext/inode.creturn bh;
bh347fs/ext/inode.cbrelse(bh);
bh353fs/ext/inode.cstruct buffer_head * bh;
bh358fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
bh360fs/ext/inode.craw_inode = ((struct ext_inode *) bh->b_data) +
bh373fs/ext/inode.cbrelse(bh);
bh391fs/ext/inode.cstruct buffer_head * bh;
bh396fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
bh398fs/ext/inode.craw_inode = ((struct ext_inode *)bh->b_data) +
bh410fs/ext/inode.cmark_buffer_dirty(bh, 1);
bh412fs/ext/inode.creturn bh;
bh417fs/ext/inode.cstruct buffer_head *bh;
bh418fs/ext/inode.cbh = ext_update_inode (inode);
bh419fs/ext/inode.cbrelse(bh);
bh425fs/ext/inode.cstruct buffer_head *bh;
bh427fs/ext/inode.cbh = ext_update_inode(inode);
bh428fs/ext/inode.cif (bh && bh->b_dirt)
bh430fs/ext/inode.cll_rw_block(WRITE, 1, &bh);
bh431fs/ext/inode.cwait_on_buffer(bh);
bh432fs/ext/inode.cif (bh->b_req && !bh->b_uptodate)
bh439fs/ext/inode.celse if (!bh)
bh441fs/ext/inode.cbrelse (bh);
bh84fs/ext/namei.cstruct buffer_head * bh;
bh97fs/ext/namei.cbh = ext_bread(dir,0,0);
bh98fs/ext/namei.cif (!bh)
bh105fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh107fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data) {
bh108fs/ext/namei.cbrelse(bh);
bh109fs/ext/namei.cbh = NULL;
bh110fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
bh111fs/ext/namei.cif (!bh)
bh113fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh119fs/ext/namei.c(((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) {
bh123fs/ext/namei.cde = (struct ext_dir_entry *) (bh->b_data+BLOCK_SIZE);
bh133fs/ext/namei.c((char *)de) + de->rec_len < BLOCK_SIZE+bh->b_data)
bh138fs/ext/namei.creturn bh;
bh145fs/ext/namei.cbrelse(bh);
bh154fs/ext/namei.cstruct buffer_head * bh;
bh163fs/ext/namei.cif (!(bh = ext_find_entry(dir,name,len,&de,NULL,NULL))) {
bh168fs/ext/namei.cbrelse(bh);
bh193fs/ext/namei.cstruct buffer_head * bh;
bh208fs/ext/namei.cbh = ext_bread(dir,0,0);
bh209fs/ext/namei.cif (!bh)
bh213fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh215fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) {
bh219fs/ext/namei.cbrelse(bh);
bh220fs/ext/namei.cbh = NULL;
bh221fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
bh222fs/ext/namei.cif (!bh)
bh224fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh244fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh246fs/ext/namei.cbrelse (bh);
bh247fs/ext/namei.cbh = NULL;
bh251fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,1);
bh252fs/ext/namei.cif (!bh)
bh254fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh267fs/ext/namei.c(((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) {
bh271fs/ext/namei.cbrelse (bh);
bh292fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh294fs/ext/namei.creturn bh;
bh299fs/ext/namei.cbrelse(bh);
bh307fs/ext/namei.cstruct buffer_head * bh;
bh321fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh322fs/ext/namei.cif (!bh) {
bh330fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh331fs/ext/namei.cbrelse(bh);
bh340fs/ext/namei.cstruct buffer_head * bh;
bh345fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh346fs/ext/namei.cif (bh) {
bh347fs/ext/namei.cbrelse(bh);
bh380fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh381fs/ext/namei.cif (!bh) {
bh389fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh390fs/ext/namei.cbrelse(bh);
bh399fs/ext/namei.cstruct buffer_head * bh, *dir_block;
bh402fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh403fs/ext/namei.cif (bh) {
bh404fs/ext/namei.cbrelse(bh);
bh447fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh448fs/ext/namei.cif (!bh) {
bh455fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh460fs/ext/namei.cbrelse(bh);
bh470fs/ext/namei.cstruct buffer_head * bh;
bh473fs/ext/namei.cif (inode->i_size < 2 * 12 || !(bh = ext_bread(inode,0,0))) {
bh477fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh487fs/ext/namei.cif ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) {
bh488fs/ext/namei.cbrelse(bh);
bh489fs/ext/namei.cbh = ext_bread(inode, offset >> BLOCK_SIZE_BITS,1);
bh490fs/ext/namei.cif (!bh) {
bh494fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh501fs/ext/namei.cbrelse (bh);
bh505fs/ext/namei.cbrelse(bh);
bh511fs/ext/namei.cbrelse(bh);
bh528fs/ext/namei.cstruct buffer_head * bh;
bh532fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
bh534fs/ext/namei.cif (!bh)
bh564fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh574fs/ext/namei.cbrelse(bh);
bh582fs/ext/namei.cstruct buffer_head * bh;
bh587fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
bh588fs/ext/namei.cif (!bh)
bh607fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh615fs/ext/namei.cbrelse(bh);
bh625fs/ext/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh651fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh652fs/ext/namei.cif (bh) {
bh656fs/ext/namei.cbrelse(bh);
bh660fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh661fs/ext/namei.cif (!bh) {
bh669fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh670fs/ext/namei.cbrelse(bh);
bh679fs/ext/namei.cstruct buffer_head * bh;
bh691fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh692fs/ext/namei.cif (bh) {
bh693fs/ext/namei.cbrelse(bh);
bh698fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh699fs/ext/namei.cif (!bh) {
bh705fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh706fs/ext/namei.cbrelse(bh);
bh51fs/ext/symlink.cstruct buffer_head * bh;
bh72fs/ext/symlink.cif (!(bh = ext_bread(inode, 0, 0))) {
bh79fs/ext/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh81fs/ext/symlink.cbrelse(bh);
bh87fs/ext/symlink.cstruct buffer_head * bh;
bh97fs/ext/symlink.cbh = ext_bread(inode, 0, 0);
bh99fs/ext/symlink.cif (!bh)
bh102fs/ext/symlink.cwhile (i<buflen && (c = bh->b_data[i])) {
bh106fs/ext/symlink.cbrelse(bh);
bh36fs/ext/truncate.cstruct buffer_head * bh;
bh45fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
bh47fs/ext/truncate.cbrelse(bh);
bh50fs/ext/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh52fs/ext/truncate.cbrelse(bh);
bh57fs/ext/truncate.cbrelse(bh);
bh66fs/ext/truncate.cstruct buffer_head * bh;
bh94fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
bh96fs/ext/truncate.cbrelse(bh);
bh99fs/ext/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh101fs/ext/truncate.cbrelse(bh);
bh106fs/ext/truncate.cbrelse(bh);
bh39fs/ext2/balloc.cstruct buffer_head ** bh)
bh60fs/ext2/balloc.cif (bh)
bh61fs/ext2/balloc.c*bh = sb->u.ext2_sb.s_group_desc[group_desc];
bh70fs/ext2/balloc.cstruct buffer_head * bh;
bh73fs/ext2/balloc.cbh = bread (sb->s_dev, gdp->bg_block_bitmap, sb->s_blocksize);
bh74fs/ext2/balloc.cif (!bh)
bh80fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[bitmap_nr] = bh;
bh170fs/ext2/balloc.cstruct buffer_head * bh;
bh205fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh221fs/ext2/balloc.cif (!clear_bit (bit + i, bh->b_data))
bh234fs/ext2/balloc.cmark_buffer_dirty(bh, 1);
bh236fs/ext2/balloc.cll_rw_block (WRITE, 1, &bh);
bh237fs/ext2/balloc.cwait_on_buffer (bh);
bh255fs/ext2/balloc.cstruct buffer_head * bh;
bh298fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh302fs/ext2/balloc.cif (!test_bit(j, bh->b_data)) {
bh314fs/ext2/balloc.clmap = ((((unsigned long *) bh->b_data)[j >> 5]) >>
bh317fs/ext2/balloc.clmap |= (((unsigned long *) bh->b_data)[(j >> 5) + 1]) <<
bh341fs/ext2/balloc.cp = ((char *) bh->b_data) + (j >> 3);
bh343fs/ext2/balloc.ck = (r - ((char *) bh->b_data)) << 3;
bh348fs/ext2/balloc.ck = find_next_zero_bit ((unsigned long *) bh->b_data, 
bh376fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh377fs/ext2/balloc.cr = memscan(bh->b_data, 0, EXT2_BLOCKS_PER_GROUP(sb) >> 3);
bh378fs/ext2/balloc.cj = (r - bh->b_data) << 3;
bh382fs/ext2/balloc.cj = find_first_zero_bit ((unsigned long *) bh->b_data,
bh397fs/ext2/balloc.cfor (k = 0; k < 7 && j > 0 && !test_bit (j - 1, bh->b_data); k++, j--);
bh413fs/ext2/balloc.cif (set_bit (j, bh->b_data)) {
bh430fs/ext2/balloc.cif (set_bit (j + k, bh->b_data))
bh443fs/ext2/balloc.cmark_buffer_dirty(bh, 1);
bh445fs/ext2/balloc.cll_rw_block (WRITE, 1, &bh);
bh446fs/ext2/balloc.cwait_on_buffer (bh);
bh456fs/ext2/balloc.cif (!(bh = getblk (sb->s_dev, j, sb->s_blocksize))) {
bh461fs/ext2/balloc.cmemset(bh->b_data, 0, sb->s_blocksize);
bh462fs/ext2/balloc.cbh->b_uptodate = 1;
bh463fs/ext2/balloc.cmark_buffer_dirty(bh, 1);
bh464fs/ext2/balloc.cbrelse (bh);
bh521fs/ext2/balloc.cstruct buffer_head * bh;
bh540fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh542fs/ext2/balloc.cif (!test_bit (0, bh->b_data))
bh547fs/ext2/balloc.cif (!test_bit (j + 1, bh->b_data))
bh552fs/ext2/balloc.cif (!block_in_use (gdp->bg_block_bitmap, sb, bh->b_data))
bh557fs/ext2/balloc.cif (!block_in_use (gdp->bg_inode_bitmap, sb, bh->b_data))
bh563fs/ext2/balloc.cif (!block_in_use (gdp->bg_inode_table + j, sb, bh->b_data))
bh568fs/ext2/balloc.cx = ext2_count_free (bh, sb->s_blocksize);
bh75fs/ext2/dir.cstruct ext2_dir_entry * de, struct buffer_head * bh,
bh86fs/ext2/dir.celse if (dir && ((char *) de - bh->b_data) + de->rec_len >
bh105fs/ext2/dir.cstruct buffer_head * bh, * tmp, * bha[16];
bh115fs/ext2/dir.cbh = NULL;
bh120fs/ext2/dir.cbh = ext2_bread (inode, blk, 0, &err);
bh121fs/ext2/dir.cif (!bh) {
bh153fs/ext2/dir.c(bh->b_data + i);
bh172fs/ext2/dir.cde = (struct ext2_dir_entry *) (bh->b_data + offset);
bh174fs/ext2/dir.cbh, offset)) {
bh179fs/ext2/dir.cbrelse (bh);
bh220fs/ext2/dir.cbrelse (bh);
bh237fs/ext2/file.cstruct buffer_head * bh, *bufferlist[NBUF];
bh281fs/ext2/file.cbh = ext2_getblk (inode, pos2 / sb->s_blocksize, 1, &err);
bh282fs/ext2/file.cif (!bh) {
bh290fs/ext2/file.cif (c != sb->s_blocksize && !bh->b_uptodate) {
bh291fs/ext2/file.cll_rw_block (READ, 1, &bh);
bh292fs/ext2/file.cwait_on_buffer (bh);
bh293fs/ext2/file.cif (!bh->b_uptodate) {
bh294fs/ext2/file.cbrelse (bh);
bh300fs/ext2/file.cp = (pos2 % sb->s_blocksize) + bh->b_data;
bh306fs/ext2/file.cbh->b_uptodate = 1;
bh307fs/ext2/file.cmark_buffer_dirty(bh, 0);
bh309fs/ext2/file.cbufferlist[buffercount++] = bh;
bh311fs/ext2/file.cbrelse(bh);
bh32fs/ext2/fsync.cstruct buffer_head * bh;
bh38fs/ext2/fsync.cbh = get_hash_table (inode->i_dev, *block, blocksize);
bh39fs/ext2/fsync.cif (!bh)
bh42fs/ext2/fsync.cbrelse (bh);
bh45fs/ext2/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh46fs/ext2/fsync.cbrelse (bh);
bh49fs/ext2/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt) {
bh50fs/ext2/fsync.cbrelse (bh);
bh53fs/ext2/fsync.cll_rw_block (WRITE, 1, &bh);
bh54fs/ext2/fsync.cbh->b_count--;
bh59fs/ext2/fsync.cstruct buffer_head ** bh, int wait) 
bh63fs/ext2/fsync.c*bh = NULL;
bh70fs/ext2/fsync.c*bh = bread (inode->i_dev, tmp, blocksize);
bh72fs/ext2/fsync.cbrelse (*bh);
bh73fs/ext2/fsync.c*bh = NULL;
bh76fs/ext2/fsync.cif (!*bh)
bh38fs/ext2/ialloc.cstruct buffer_head ** bh)
bh59fs/ext2/ialloc.cif (bh)
bh60fs/ext2/ialloc.c*bh = sb->u.ext2_sb.s_group_desc[group_desc];
bh69fs/ext2/ialloc.cstruct buffer_head * bh;
bh72fs/ext2/ialloc.cbh = bread (sb->s_dev, gdp->bg_inode_bitmap, sb->s_blocksize);
bh73fs/ext2/ialloc.cif (!bh)
bh79fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[bitmap_nr] = bh;
bh162fs/ext2/ialloc.cstruct buffer_head * bh;
bh168fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
bh169fs/ext2/ialloc.cif (!bh)
bh174fs/ext2/ialloc.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh180fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh182fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh183fs/ext2/ialloc.cwait_on_buffer (bh);
bh185fs/ext2/ialloc.cbrelse (bh);
bh191fs/ext2/ialloc.cstruct buffer_head * bh;
bh235fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
bh236fs/ext2/ialloc.cif (!clear_bit (bit, bh->b_data))
bh249fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh251fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh252fs/ext2/ialloc.cwait_on_buffer (bh);
bh270fs/ext2/ialloc.cstruct buffer_head * bh;
bh276fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
bh277fs/ext2/ialloc.cif (!bh) {
bh285fs/ext2/ialloc.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh291fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh292fs/ext2/ialloc.cbrelse (bh);
bh308fs/ext2/ialloc.cstruct buffer_head * bh;
bh407fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
bh408fs/ext2/ialloc.cif ((j = find_first_zero_bit ((unsigned long *) bh->b_data,
bh411fs/ext2/ialloc.cif (set_bit (j, bh->b_data)) {
bh416fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh418fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh419fs/ext2/ialloc.cwait_on_buffer (bh);
bh43fs/ext2/inode.cstatic int block_bmap (struct buffer_head * bh, int nr)
bh47fs/ext2/inode.cif (!bh)
bh49fs/ext2/inode.ctmp = ((unsigned long *) bh->b_data)[nr];
bh50fs/ext2/inode.cbrelse (bh);
bh80fs/ext2/inode.cstruct buffer_head * bh;
bh97fs/ext2/inode.cif (!(bh = getblk (inode->i_sb->s_dev, result,
bh103fs/ext2/inode.cmemset(bh->b_data, 0, inode->i_sb->s_blocksize);
bh104fs/ext2/inode.cbh->b_uptodate = 1;
bh105fs/ext2/inode.cmark_buffer_dirty(bh, 1);
bh106fs/ext2/inode.cbrelse (bh);
bh248fs/ext2/inode.cstruct buffer_head * bh, int nr,
bh257fs/ext2/inode.cif (!bh)
bh259fs/ext2/inode.cif (!bh->b_uptodate) {
bh260fs/ext2/inode.cll_rw_block (READ, 1, &bh);
bh261fs/ext2/inode.cwait_on_buffer (bh);
bh262fs/ext2/inode.cif (!bh->b_uptodate) {
bh263fs/ext2/inode.cbrelse (bh);
bh267fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr;
bh271fs/ext2/inode.cresult = getblk (bh->b_dev, tmp, blocksize);
bh273fs/ext2/inode.cbrelse (bh);
bh282fs/ext2/inode.cbrelse (bh);
bh290fs/ext2/inode.cif (((unsigned long *) bh->b_data)[tmp]) {
bh291fs/ext2/inode.cgoal = ((unsigned long *)bh->b_data)[tmp];
bh296fs/ext2/inode.cgoal = bh->b_blocknr;
bh300fs/ext2/inode.cbrelse (bh);
bh303fs/ext2/inode.cresult = getblk (bh->b_dev, tmp, blocksize);
bh310fs/ext2/inode.cmark_buffer_dirty(bh, 1);
bh312fs/ext2/inode.cll_rw_block (WRITE, 1, &bh);
bh313fs/ext2/inode.cwait_on_buffer (bh);
bh320fs/ext2/inode.cbrelse (bh);
bh324fs/ext2/inode.cstatic int block_getcluster (struct inode * inode, struct buffer_head * bh,
bh335fs/ext2/inode.cif(!bh) return 0;
bh341fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr + i;
bh351fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr;
bh352fs/ext2/inode.cresult = generate_cluster(bh->b_dev, (int *) p, blocksize);
bh355fs/ext2/inode.cbrelse(bh);
bh362fs/ext2/inode.cstruct buffer_head * bh;
bh398fs/ext2/inode.cbh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, err);
bh399fs/ext2/inode.creturn block_getblk (inode, bh, block, create,
bh404fs/ext2/inode.cbh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, err);
bh405fs/ext2/inode.cbh = block_getblk (inode, bh, block / addr_per_block, create,
bh407fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1),
bh411fs/ext2/inode.cbh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, err);
bh412fs/ext2/inode.cbh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
bh414fs/ext2/inode.cbh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
bh416fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1), create,
bh422fs/ext2/inode.cstruct buffer_head * bh;
bh447fs/ext2/inode.cbh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, &err);
bh448fs/ext2/inode.creturn block_getcluster (inode, bh, block, 
bh453fs/ext2/inode.cbh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, &err);
bh454fs/ext2/inode.cbh = block_getblk (inode, bh, block / addr_per_block, create,
bh456fs/ext2/inode.creturn block_getcluster (inode, bh, block & (addr_per_block - 1),
bh460fs/ext2/inode.cbh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, &err);
bh461fs/ext2/inode.cbh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
bh463fs/ext2/inode.cbh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
bh465fs/ext2/inode.creturn block_getcluster (inode, bh, block & (addr_per_block - 1),
bh472fs/ext2/inode.cstruct buffer_head * bh;
bh474fs/ext2/inode.cbh = ext2_getblk (inode, block, create, err);
bh475fs/ext2/inode.cif (!bh || bh->b_uptodate)
bh476fs/ext2/inode.creturn bh;
bh477fs/ext2/inode.cll_rw_block (READ, 1, &bh);
bh478fs/ext2/inode.cwait_on_buffer (bh);
bh479fs/ext2/inode.cif (bh->b_uptodate)
bh480fs/ext2/inode.creturn bh;
bh481fs/ext2/inode.cbrelse (bh);
bh488fs/ext2/inode.cstruct buffer_head * bh;
bh509fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
bh510fs/ext2/inode.cif (!bh)
bh513fs/ext2/inode.cgdp = (struct ext2_group_desc *) bh->b_data;
bh517fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
bh521fs/ext2/inode.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh553fs/ext2/inode.cbrelse (bh);
bh580fs/ext2/inode.cstruct buffer_head * bh;
bh600fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
bh601fs/ext2/inode.cif (!bh)
bh604fs/ext2/inode.cgdp = (struct ext2_group_desc *) bh->b_data;
bh608fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
bh612fs/ext2/inode.craw_inode = ((struct ext2_inode *)bh->b_data) +
bh635fs/ext2/inode.cmark_buffer_dirty(bh, 1);
bh637fs/ext2/inode.creturn bh;
bh642fs/ext2/inode.cstruct buffer_head * bh;
bh643fs/ext2/inode.cbh = ext2_update_inode (inode);
bh644fs/ext2/inode.cbrelse (bh);
bh650fs/ext2/inode.cstruct buffer_head *bh;
bh652fs/ext2/inode.cbh = ext2_update_inode (inode);
bh653fs/ext2/inode.cif (bh && bh->b_dirt)
bh655fs/ext2/inode.cll_rw_block (WRITE, 1, &bh);
bh656fs/ext2/inode.cwait_on_buffer (bh);
bh657fs/ext2/inode.cif (bh->b_req && !bh->b_uptodate)
bh664fs/ext2/inode.celse if (!bh)
bh666fs/ext2/inode.cbrelse (bh);
bh93fs/ext2/namei.cstruct buffer_head * bh;
bh97fs/ext2/namei.cbh = ext2_getblk (dir, block, 0, &err);
bh98fs/ext2/namei.cbh_use[block] = bh;
bh99fs/ext2/namei.cif (bh && !bh->b_uptodate)
bh100fs/ext2/namei.cbh_read[toread++] = bh;
bh106fs/ext2/namei.cstruct buffer_head * bh;
bh114fs/ext2/namei.cbh = bh_use[block % NAMEI_RA_SIZE];
bh115fs/ext2/namei.cif (!bh)
bh118fs/ext2/namei.cwait_on_buffer (bh);
bh119fs/ext2/namei.cif (!bh->b_uptodate) {
bh126fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh127fs/ext2/namei.cdlimit = bh->b_data + sb->s_blocksize;
bh130fs/ext2/namei.cde, bh, offset))
bh134fs/ext2/namei.cif (bh_use[i] != bh)
bh138fs/ext2/namei.creturn bh;
bh145fs/ext2/namei.cbrelse (bh);
bh148fs/ext2/namei.cbh = NULL;
bh150fs/ext2/namei.cbh = ext2_getblk (dir, block + NAMEI_RA_SIZE, 0, &err);
bh151fs/ext2/namei.cbh_use[block++ % NAMEI_RA_SIZE] = bh;
bh152fs/ext2/namei.cif (bh && !bh->b_uptodate)
bh153fs/ext2/namei.cbh_read[toread++] = bh;
bh167fs/ext2/namei.cstruct buffer_head * bh;
bh189fs/ext2/namei.cif (!(bh = ext2_find_entry (dir, name, len, &de))) {
bh197fs/ext2/namei.cbrelse (bh);
bh223fs/ext2/namei.cstruct buffer_head * bh;
bh249fs/ext2/namei.cbh = ext2_bread (dir, 0, 0, err);
bh250fs/ext2/namei.cif (!bh)
bh254fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh257fs/ext2/namei.cif ((char *)de >= sb->s_blocksize + bh->b_data) {
bh258fs/ext2/namei.cbrelse (bh);
bh259fs/ext2/namei.cbh = NULL;
bh260fs/ext2/namei.cbh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, err);
bh261fs/ext2/namei.cif (!bh)
bh271fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh280fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh283fs/ext2/namei.cif (!ext2_check_dir_entry ("ext2_add_entry", dir, de, bh,
bh286fs/ext2/namei.cbrelse (bh);
bh291fs/ext2/namei.cbrelse (bh);
bh322fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh325fs/ext2/namei.creturn bh;
bh330fs/ext2/namei.cbrelse (bh);
bh339fs/ext2/namei.cstruct buffer_head * bh)
bh346fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh347fs/ext2/namei.cwhile (i < bh->b_size) {
bh349fs/ext2/namei.cde, bh, i))
bh368fs/ext2/namei.cstruct buffer_head * bh;
bh383fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh384fs/ext2/namei.cif (!bh) {
bh394fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh396fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh397fs/ext2/namei.cwait_on_buffer (bh);
bh399fs/ext2/namei.cbrelse (bh);
bh409fs/ext2/namei.cstruct buffer_head * bh;
bh415fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh416fs/ext2/namei.cif (bh) {
bh417fs/ext2/namei.cbrelse (bh);
bh447fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh448fs/ext2/namei.cif (!bh) {
bh458fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh460fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh461fs/ext2/namei.cwait_on_buffer (bh);
bh463fs/ext2/namei.cbrelse (bh);
bh472fs/ext2/namei.cstruct buffer_head * bh, * dir_block;
bh478fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh479fs/ext2/namei.cif (bh) {
bh480fs/ext2/namei.cbrelse (bh);
bh521fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh522fs/ext2/namei.cif (!bh) {
bh532fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh534fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh535fs/ext2/namei.cwait_on_buffer (bh);
bh541fs/ext2/namei.cbrelse (bh);
bh551fs/ext2/namei.cstruct buffer_head * bh;
bh558fs/ext2/namei.c!(bh = ext2_bread (inode, 0, 0, &err))) {
bh563fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh574fs/ext2/namei.cif ((void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
bh575fs/ext2/namei.cbrelse (bh);
bh576fs/ext2/namei.cbh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, &err);
bh577fs/ext2/namei.cif (!bh) {
bh581fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh583fs/ext2/namei.cif (!ext2_check_dir_entry ("empty_dir", inode, de, bh,
bh585fs/ext2/namei.cbrelse (bh);
bh589fs/ext2/namei.cbrelse (bh);
bh595fs/ext2/namei.cbrelse (bh);
bh603fs/ext2/namei.cstruct buffer_head * bh;
bh610fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh612fs/ext2/namei.cif (!bh)
bh621fs/ext2/namei.cbrelse(bh);
bh652fs/ext2/namei.cretval = ext2_delete_entry (de, bh);
bh658fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh660fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh661fs/ext2/namei.cwait_on_buffer (bh);
bh676fs/ext2/namei.cbrelse (bh);
bh684fs/ext2/namei.cstruct buffer_head * bh;
bh692fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh693fs/ext2/namei.cif (!bh)
bh704fs/ext2/namei.cbrelse(bh);
bh719fs/ext2/namei.cretval = ext2_delete_entry (de, bh);
bh723fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh725fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh726fs/ext2/namei.cwait_on_buffer (bh);
bh735fs/ext2/namei.cbrelse (bh);
bh746fs/ext2/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh790fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh791fs/ext2/namei.cif (bh) {
bh795fs/ext2/namei.cbrelse (bh);
bh799fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh800fs/ext2/namei.cif (!bh) {
bh810fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh812fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh813fs/ext2/namei.cwait_on_buffer (bh);
bh815fs/ext2/namei.cbrelse (bh);
bh825fs/ext2/namei.cstruct buffer_head * bh;
bh843fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh844fs/ext2/namei.cif (bh) {
bh845fs/ext2/namei.cbrelse (bh);
bh850fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh851fs/ext2/namei.cif (!bh) {
bh859fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh861fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh862fs/ext2/namei.cwait_on_buffer (bh);
bh864fs/ext2/namei.cbrelse (bh);
bh133fs/ext2/super.cstruct buffer_head * bh)
bh142fs/ext2/super.ces = (struct ext2_super_block *) bh->b_data;
bh165fs/ext2/super.cmark_buffer_dirty(bh, 1);
bh394fs/ext2/super.cstruct buffer_head * bh;
bh416fs/ext2/super.cif (!(bh = bread (dev, sb_block, BLOCK_SIZE))) {
bh426fs/ext2/super.ces = (struct ext2_super_block *) bh->b_data;
bh436fs/ext2/super.cbrelse (bh);
bh449fs/ext2/super.cbrelse (bh);
bh453fs/ext2/super.cbh = bread (dev, logic_sb_block, sb->s_blocksize);
bh454fs/ext2/super.cif(!bh)
bh456fs/ext2/super.ces = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
bh461fs/ext2/super.cbrelse (bh);
bh482fs/ext2/super.csb->u.ext2_sb.s_sbh = bh;
bh503fs/ext2/super.cbrelse (bh);
bh513fs/ext2/super.cbrelse (bh);
bh517fs/ext2/super.cif (!convert_pre_02b_fs (sb, bh)) {
bh520fs/ext2/super.cbrelse (bh);
bh531fs/ext2/super.cbrelse (bh);
bh537fs/ext2/super.cif (sb->s_blocksize != bh->b_size) {
bh540fs/ext2/super.cbrelse (bh);
bh550fs/ext2/super.cbrelse (bh);
bh566fs/ext2/super.cbrelse (bh);
bh580fs/ext2/super.cbrelse (bh);
bh592fs/ext2/super.cbrelse (bh);
bh618fs/ext2/super.cbrelse (bh);
bh55fs/ext2/symlink.cstruct buffer_head * bh = NULL;
bh78fs/ext2/symlink.cif (!(bh = ext2_bread (inode, 0, 0, &error))) {
bh83fs/ext2/symlink.clink = bh->b_data;
bh90fs/ext2/symlink.cif (bh)
bh91fs/ext2/symlink.cbrelse (bh);
bh97fs/ext2/symlink.cstruct buffer_head * bh = NULL;
bh109fs/ext2/symlink.cbh = ext2_bread (inode, 0, 0, &err);
bh110fs/ext2/symlink.cif (!bh) {
bh114fs/ext2/symlink.clink = bh->b_data;
bh124fs/ext2/symlink.cif (bh)
bh125fs/ext2/symlink.cbrelse (bh);
bh50fs/ext2/truncate.cstruct buffer_head * bh;
bh66fs/ext2/truncate.cbh = getblk (inode->i_dev, tmp,
bh69fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp,
bh72fs/ext2/truncate.cbrelse (bh);
bh75fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh77fs/ext2/truncate.cbrelse (bh);
bh84fs/ext2/truncate.cmemset(bh->b_data, RANDOM_INT, inode->i_sb->s_blocksize);
bh85fs/ext2/truncate.cmark_buffer_dirty(bh, 1);
bh87fs/ext2/truncate.cbrelse (bh);
bh108fs/ext2/truncate.cstruct buffer_head * bh;
bh142fs/ext2/truncate.cbh = getblk (inode->i_dev, tmp,
bh145fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp,
bh148fs/ext2/truncate.cbrelse (bh);
bh151fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh153fs/ext2/truncate.cbrelse (bh);
bh159fs/ext2/truncate.cmemset(bh->b_data, RANDOM_INT, inode->i_sb->s_blocksize);
bh160fs/ext2/truncate.cmark_buffer_dirty(bh, 1);
bh162fs/ext2/truncate.cbrelse (bh);
bh229fs/hpfs/hpfs_fs.cstruct buffer_head *bh[4];
bh871fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh903fs/hpfs/hpfs_fs.cblock = map_sector(inode->i_dev, hpfs_bmap(inode, q), &bh);
bh931fs/hpfs/hpfs_fs.cbrelse(bh);
bh1002fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1018fs/hpfs/hpfs_fs.cfnode = map_fnode(inode->i_dev, inode->i_ino, &bh);
bh1022fs/hpfs/hpfs_fs.cfile_secno, &bh);
bh1023fs/hpfs/hpfs_fs.cbrelse(bh);
bh1570fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1574fs/hpfs/hpfs_fs.cfnode = map_fnode(dev, ino, &bh);
bh1579fs/hpfs/hpfs_fs.cbrelse(bh);
bh1652fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1654fs/hpfs/hpfs_fs.cif ((*bhp = bh = bread(dev, secno, 512)) != 0)
bh1655fs/hpfs/hpfs_fs.creturn bh->b_data;
bh1667fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1679fs/hpfs/hpfs_fs.cqbh->bh[0] = bh = breada(dev, secno, 512, 0, UINT_MAX);
bh1680fs/hpfs/hpfs_fs.cif (!bh)
bh1682fs/hpfs/hpfs_fs.cmemcpy(data, bh->b_data, 512);
bh1684fs/hpfs/hpfs_fs.cqbh->bh[1] = bh = bread(dev, secno + 1, 512);
bh1685fs/hpfs/hpfs_fs.cif (!bh)
bh1687fs/hpfs/hpfs_fs.cmemcpy(data + 512, bh->b_data, 512);
bh1689fs/hpfs/hpfs_fs.cqbh->bh[2] = bh = bread(dev, secno + 2, 512);
bh1690fs/hpfs/hpfs_fs.cif (!bh)
bh1692fs/hpfs/hpfs_fs.cmemcpy(data + 2 * 512, bh->b_data, 512);
bh1694fs/hpfs/hpfs_fs.cqbh->bh[3] = bh = bread(dev, secno + 3, 512);
bh1695fs/hpfs/hpfs_fs.cif (!bh)
bh1697fs/hpfs/hpfs_fs.cmemcpy(data + 3 * 512, bh->b_data, 512);
bh1702fs/hpfs/hpfs_fs.cbrelse(qbh->bh[2]);
bh1704fs/hpfs/hpfs_fs.cbrelse(qbh->bh[1]);
bh1706fs/hpfs/hpfs_fs.cbrelse(qbh->bh[0]);
bh1718fs/hpfs/hpfs_fs.cbrelse(qbh->bh[3]);
bh1719fs/hpfs/hpfs_fs.cbrelse(qbh->bh[2]);
bh1720fs/hpfs/hpfs_fs.cbrelse(qbh->bh[1]);
bh1721fs/hpfs/hpfs_fs.cbrelse(qbh->bh[0]);
bh75fs/isofs/dir.cstruct buffer_head * bh;
bh92fs/isofs/dir.cif(!(bh = breada(inode->i_dev, block, bufsize, filp->f_pos, inode->i_size)))
bh100fs/isofs/dir.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh108fs/isofs/dir.cbrelse(bh);
bh114fs/isofs/dir.c|| !(bh = breada(inode->i_dev, block, bufsize, filp->f_pos, 
bh134fs/isofs/dir.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
bh136fs/isofs/dir.cbrelse(bh);
bh140fs/isofs/dir.c|| !(bh = breada(inode->i_dev, block, bufsize,
bh145fs/isofs/dir.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh248fs/isofs/dir.cbrelse(bh);
bh257fs/isofs/dir.cbrelse(bh);
bh102fs/isofs/file.cstruct buffer_head * bh;
bh106fs/isofs/file.cif (block && (bh = bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode)))) {
bh107fs/isofs/file.cpnt = (unsigned char *) bh->b_data;
bh118fs/isofs/file.cbrelse(bh);
bh188fs/isofs/inode.cstruct buffer_head *bh=NULL;
bh243fs/isofs/inode.cif (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits), opt.blocksize))) {
bh252fs/isofs/inode.cvdp = (struct iso_volume_descriptor *)bh->b_data;
bh253fs/isofs/inode.chdp = (struct hs_volume_descriptor *)bh->b_data;
bh279fs/isofs/inode.cbrelse(bh);
bh338fs/isofs/inode.cbrelse(bh);
bh379fs/isofs/inode.cbrelse(bh);
bh412fs/isofs/inode.cstruct buffer_head * bh;
bh421fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
bh426fs/isofs/inode.cpnt = ((unsigned char *) bh->b_data
bh439fs/isofs/inode.cbrelse(bh);
bh442fs/isofs/inode.cmemcpy(cpnt, bh->b_data + offset, frag1);
bh443fs/isofs/inode.cbrelse(bh);
bh444fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
bh450fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh552fs/isofs/inode.cbrelse(bh);
bh628fs/isofs/inode.cstruct buffer_head * bh;
bh633fs/isofs/inode.cif (!(bh = bread(parent->i_dev, block, bufsize)))  return -1;
bh636fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh639fs/isofs/inode.cbrelse(bh);
bh649fs/isofs/inode.cbrelse(bh);
bh657fs/isofs/inode.cbrelse(bh);
bh670fs/isofs/inode.cif (!block || !(bh = bread(parent->i_dev,block, bufsize)))
bh675fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh684fs/isofs/inode.cbrelse(bh);
bh692fs/isofs/inode.c|| !(bh = bread(parent->i_dev,block, bufsize)))
bh710fs/isofs/inode.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
bh712fs/isofs/inode.cbrelse(bh);
bh717fs/isofs/inode.cif(!(bh = bread(parent->i_dev,block,bufsize))) {
bh721fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh743fs/isofs/inode.cbrelse(bh);
bh773fs/isofs/inode.cvoid leak_check_brelse(struct buffer_head * bh){
bh775fs/isofs/inode.creturn brelse(bh);
bh71fs/isofs/namei.cstruct buffer_head * bh;
bh91fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) return NULL;
bh94fs/isofs/namei.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh102fs/isofs/namei.cbrelse(bh);
bh107fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize)))
bh123fs/isofs/namei.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
bh126fs/isofs/namei.cbrelse(bh);
bh129fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) {
bh133fs/isofs/namei.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh213fs/isofs/namei.creturn bh;
bh219fs/isofs/namei.cbrelse(bh);
bh227fs/isofs/namei.cstruct buffer_head * bh;
bh246fs/isofs/namei.cif (!(bh = isofs_find_entry(dir,name,len, &ino, &ino_back))) {
bh252fs/isofs/namei.cbrelse(bh);
bh60fs/isofs/rock.cstruct buffer_head * bh; \
bh71fs/isofs/rock.cbh = bread(DEV->i_dev, block++, ISOFS_BUFFER_SIZE(DEV)); \
bh72fs/isofs/rock.cif(!bh) {printk("Unable to read continuation Rock Ridge record\n"); \
bh75fs/isofs/rock.cmemcpy(buffer, bh->b_data + offset, 1024 - offset); \
bh76fs/isofs/rock.cbrelse(bh); \
bh82fs/isofs/rock.cbh = bread(DEV->i_dev, block, ISOFS_BUFFER_SIZE(DEV)); \
bh83fs/isofs/rock.cif(bh){       \
bh84fs/isofs/rock.cmemcpy(buffer + offset1, bh->b_data + offset, cont_size - offset1); \
bh85fs/isofs/rock.cbrelse(bh); \
bh398fs/isofs/rock.cstruct buffer_head * bh;
bh417fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
bh422fs/isofs/rock.cpnt = ((unsigned char *) bh->b_data) + (inode->i_ino & (bufsize - 1));
bh433fs/isofs/rock.cmemcpy(cpnt, bh->b_data + offset, frag1);
bh434fs/isofs/rock.cbrelse(bh);
bh435fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
bh441fs/isofs/rock.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh509fs/isofs/rock.cbrelse(bh);
bh27fs/minix/bitmap.cstruct buffer_head *bh;
bh30fs/minix/bitmap.cif (!(bh=map[i])) 
bh39fs/minix/bitmap.ctmp = bh->b_data[end] & ((1<<numbits)-1);
bh44fs/minix/bitmap.csum += nibblemap[bh->b_data[j] & 0xf] 
bh45fs/minix/bitmap.c+ nibblemap[(bh->b_data[j]>>4)&0xf];
bh52fs/minix/bitmap.cstruct buffer_head * bh;
bh64fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
bh65fs/minix/bitmap.cif (bh)
bh66fs/minix/bitmap.cbh->b_dirt=0;
bh67fs/minix/bitmap.cbrelse(bh);
bh71fs/minix/bitmap.cbh = sb->u.minix_sb.s_zmap[zone];
bh72fs/minix/bitmap.cif (!bh) {
bh76fs/minix/bitmap.cif (!clear_bit(bit,bh->b_data))
bh78fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh84fs/minix/bitmap.cstruct buffer_head * bh;
bh94fs/minix/bitmap.cif ((bh=sb->u.minix_sb.s_zmap[i]) != NULL)
bh95fs/minix/bitmap.cif ((j=find_first_zero_bit(bh->b_data, 8192)) < 8192)
bh97fs/minix/bitmap.cif (i>=8 || !bh || j>=8192)
bh99fs/minix/bitmap.cif (set_bit(j,bh->b_data)) {
bh103fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh108fs/minix/bitmap.cif (!(bh = getblk(sb->s_dev,j,BLOCK_SIZE))) {
bh112fs/minix/bitmap.cmemset(bh->b_data, 0, BLOCK_SIZE);
bh113fs/minix/bitmap.cbh->b_uptodate = 1;
bh114fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh115fs/minix/bitmap.cbrelse(bh);
bh127fs/minix/bitmap.cstruct buffer_head * bh;
bh153fs/minix/bitmap.cif (!(bh=inode->i_sb->u.minix_sb.s_imap[ino >> 13])) {
bh158fs/minix/bitmap.cif (!clear_bit(ino & 8191, bh->b_data))
bh160fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh167fs/minix/bitmap.cstruct buffer_head * bh;
bh177fs/minix/bitmap.cif ((bh = inode->i_sb->u.minix_sb.s_imap[i]) != NULL)
bh178fs/minix/bitmap.cif ((j=find_first_zero_bit(bh->b_data, 8192)) < 8192)
bh180fs/minix/bitmap.cif (!bh || j >= 8192) {
bh184fs/minix/bitmap.cif (set_bit(j,bh->b_data)) {  /* shouldn't happen */
bh189fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh70fs/minix/dir.cstruct buffer_head * bh;
bh82fs/minix/dir.cbh = minix_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
bh83fs/minix/dir.cif (!bh) {
bh88fs/minix/dir.cde = (struct minix_dir_entry *) (offset + bh->b_data);
bh109fs/minix/dir.cbrelse(bh);
bh197fs/minix/file.cstruct buffer_head * bh;
bh215fs/minix/file.cbh = minix_getblk(inode,pos/BLOCK_SIZE,1);
bh216fs/minix/file.cif (!bh) {
bh224fs/minix/file.cif (c != BLOCK_SIZE && !bh->b_uptodate) {
bh225fs/minix/file.cll_rw_block(READ, 1, &bh);
bh226fs/minix/file.cwait_on_buffer(bh);
bh227fs/minix/file.cif (!bh->b_uptodate) {
bh228fs/minix/file.cbrelse(bh);
bh234fs/minix/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
bh239fs/minix/file.cbh->b_uptodate = 1;
bh240fs/minix/file.cmark_buffer_dirty(bh, 0);
bh241fs/minix/file.cbrelse(bh);
bh33fs/minix/fsync.cstruct buffer_head * bh;
bh39fs/minix/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh40fs/minix/fsync.cif (!bh)
bh43fs/minix/fsync.cbrelse (bh);
bh46fs/minix/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh47fs/minix/fsync.cbrelse(bh);
bh50fs/minix/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt)
bh52fs/minix/fsync.cbrelse(bh);
bh55fs/minix/fsync.cll_rw_block(WRITE, 1, &bh);
bh56fs/minix/fsync.cbh->b_count--;
bh61fs/minix/fsync.cstruct buffer_head **bh, int wait) 
bh66fs/minix/fsync.c*bh = NULL;
bh73fs/minix/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh75fs/minix/fsync.cbrelse(*bh);
bh76fs/minix/fsync.c*bh = NULL;
bh79fs/minix/fsync.cif (!*bh)
bh127fs/minix/inode.cstruct buffer_head *bh;
bh136fs/minix/inode.cif (!(bh = bread(dev,1,BLOCK_SIZE))) {
bh143fs/minix/inode.cms = (struct minix_super_block *) bh->b_data;
bh145fs/minix/inode.cs->u.minix_sb.s_sbh = bh;
bh166fs/minix/inode.cbrelse(bh);
bh194fs/minix/inode.cbrelse(bh);
bh208fs/minix/inode.cbrelse(bh);
bh215fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh247fs/minix/inode.cstatic int block_bmap(struct buffer_head * bh, int nr)
bh251fs/minix/inode.cif (!bh)
bh253fs/minix/inode.ctmp = ((unsigned short *) bh->b_data)[nr];
bh254fs/minix/inode.cbrelse(bh);
bh323fs/minix/inode.cstruct buffer_head * bh, int nr, int create)
bh329fs/minix/inode.cif (!bh)
bh331fs/minix/inode.cif (!bh->b_uptodate) {
bh332fs/minix/inode.cll_rw_block(READ, 1, &bh);
bh333fs/minix/inode.cwait_on_buffer(bh);
bh334fs/minix/inode.cif (!bh->b_uptodate) {
bh335fs/minix/inode.cbrelse(bh);
bh339fs/minix/inode.cp = nr + (unsigned short *) bh->b_data;
bh343fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh345fs/minix/inode.cbrelse(bh);
bh352fs/minix/inode.cbrelse(bh);
bh357fs/minix/inode.cbrelse(bh);
bh360fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh367fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh368fs/minix/inode.cbrelse(bh);
bh374fs/minix/inode.cstruct buffer_head * bh;
bh388fs/minix/inode.cbh = inode_getblk(inode,7,create);
bh389fs/minix/inode.creturn block_getblk(inode, bh, block, create);
bh392fs/minix/inode.cbh = inode_getblk(inode,8,create);
bh393fs/minix/inode.cbh = block_getblk(inode, bh, block>>9, create);
bh394fs/minix/inode.creturn block_getblk(inode, bh, block & 511, create);
bh399fs/minix/inode.cstruct buffer_head * bh;
bh401fs/minix/inode.cbh = minix_getblk(inode,block,create);
bh402fs/minix/inode.cif (!bh || bh->b_uptodate)
bh403fs/minix/inode.creturn bh;
bh404fs/minix/inode.cll_rw_block(READ, 1, &bh);
bh405fs/minix/inode.cwait_on_buffer(bh);
bh406fs/minix/inode.cif (bh->b_uptodate)
bh407fs/minix/inode.creturn bh;
bh408fs/minix/inode.cbrelse(bh);
bh414fs/minix/inode.cstruct buffer_head * bh;
bh429fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
bh434fs/minix/inode.craw_inode = ((struct minix_inode *) bh->b_data) +
bh447fs/minix/inode.cbrelse(bh);
bh464fs/minix/inode.cstruct buffer_head * bh;
bh477fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
bh482fs/minix/inode.craw_inode = ((struct minix_inode *)bh->b_data) +
bh495fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh496fs/minix/inode.creturn bh;
bh501fs/minix/inode.cstruct buffer_head *bh;
bh502fs/minix/inode.cbh = minix_update_inode(inode);
bh503fs/minix/inode.cbrelse(bh);
bh509fs/minix/inode.cstruct buffer_head *bh;
bh511fs/minix/inode.cbh = minix_update_inode(inode);
bh512fs/minix/inode.cif (bh && bh->b_dirt)
bh514fs/minix/inode.cll_rw_block(WRITE, 1, &bh);
bh515fs/minix/inode.cwait_on_buffer(bh);
bh516fs/minix/inode.cif (bh->b_req && !bh->b_uptodate)
bh523fs/minix/inode.celse if (!bh)
bh525fs/minix/inode.cbrelse (bh);
bh45fs/minix/namei.cstruct buffer_head * bh, unsigned long * offset,
bh50fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + *offset);
bh72fs/minix/namei.cstruct buffer_head * bh;
bh86fs/minix/namei.cbh = NULL;
bh89fs/minix/namei.cif (!bh) {
bh90fs/minix/namei.cbh = minix_bread(dir,block,0);
bh91fs/minix/namei.cif (!bh) {
bh96fs/minix/namei.c*res_dir = (struct minix_dir_entry *) (bh->b_data + offset);
bh97fs/minix/namei.cif (minix_match(namelen,name,bh,&offset,info))
bh98fs/minix/namei.creturn bh;
bh99fs/minix/namei.cif (offset < bh->b_size)
bh101fs/minix/namei.cbrelse(bh);
bh102fs/minix/namei.cbh = NULL;
bh106fs/minix/namei.cbrelse(bh);
bh116fs/minix/namei.cstruct buffer_head * bh;
bh125fs/minix/namei.cif (!(bh = minix_find_entry(dir,name,len,&de))) {
bh130fs/minix/namei.cbrelse(bh);
bh156fs/minix/namei.cstruct buffer_head * bh;
bh174fs/minix/namei.cbh = NULL;
bh177fs/minix/namei.cif (!bh) {
bh178fs/minix/namei.cbh = minix_bread(dir,block,1);
bh179fs/minix/namei.cif (!bh)
bh182fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
bh184fs/minix/namei.cif (block*bh->b_size + offset > dir->i_size) {
bh186fs/minix/namei.cdir->i_size = block*bh->b_size + offset;
bh191fs/minix/namei.cbrelse(bh);
bh200fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh204fs/minix/namei.cif (offset < bh->b_size)
bh206fs/minix/namei.cbrelse(bh);
bh207fs/minix/namei.cbh = NULL;
bh211fs/minix/namei.c*res_buf = bh;
bh220fs/minix/namei.cstruct buffer_head * bh;
bh234fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
bh243fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh244fs/minix/namei.cbrelse(bh);
bh254fs/minix/namei.cstruct buffer_head * bh;
bh259fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh260fs/minix/namei.cif (bh) {
bh261fs/minix/namei.cbrelse(bh);
bh291fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh300fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh301fs/minix/namei.cbrelse(bh);
bh311fs/minix/namei.cstruct buffer_head * bh, *dir_block;
bh320fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh321fs/minix/namei.cif (bh) {
bh322fs/minix/namei.cbrelse(bh);
bh358fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh366fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh371fs/minix/namei.cbrelse(bh);
bh381fs/minix/namei.cstruct buffer_head * bh;
bh389fs/minix/namei.cbh = NULL;
bh395fs/minix/namei.cbh = minix_bread(inode,0,0);
bh396fs/minix/namei.cif (!bh)
bh398fs/minix/namei.cde = (struct minix_dir_entry *) bh->b_data;
bh401fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + info->s_dirsize);
bh405fs/minix/namei.cif (!bh) {
bh406fs/minix/namei.cbh = minix_bread(inode,block,0);
bh407fs/minix/namei.cif (!bh) {
bh412fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
bh415fs/minix/namei.cbrelse(bh);
bh418fs/minix/namei.cif (offset < bh->b_size)
bh420fs/minix/namei.cbrelse(bh);
bh421fs/minix/namei.cbh = NULL;
bh425fs/minix/namei.cbrelse(bh);
bh428fs/minix/namei.cbrelse(bh);
bh437fs/minix/namei.cstruct buffer_head * bh;
bh441fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh443fs/minix/namei.cif (!bh)
bh476fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh486fs/minix/namei.cbrelse(bh);
bh494fs/minix/namei.cstruct buffer_head * bh;
bh500fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh501fs/minix/namei.cif (!bh)
bh510fs/minix/namei.cbrelse(bh);
bh530fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh538fs/minix/namei.cbrelse(bh);
bh548fs/minix/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh574fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh575fs/minix/namei.cif (bh) {
bh579fs/minix/namei.cbrelse(bh);
bh583fs/minix/namei.ci = minix_add_entry(dir, name, len, &bh, &de);
bh592fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh593fs/minix/namei.cbrelse(bh);
bh603fs/minix/namei.cstruct buffer_head * bh;
bh615fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh616fs/minix/namei.cif (bh) {
bh617fs/minix/namei.cbrelse(bh);
bh622fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh629fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh630fs/minix/namei.cbrelse(bh);
bh49fs/minix/symlink.cstruct buffer_head * bh;
bh70fs/minix/symlink.cif (!(bh = minix_bread(inode, 0, 0))) {
bh77fs/minix/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh79fs/minix/symlink.cbrelse(bh);
bh85fs/minix/symlink.cstruct buffer_head * bh;
bh95fs/minix/symlink.cbh = minix_bread(inode, 0, 0);
bh97fs/minix/symlink.cif (!bh)
bh100fs/minix/symlink.cwhile (i<buflen && (c = bh->b_data[i])) {
bh104fs/minix/symlink.cbrelse(bh);
bh33fs/minix/truncate.cstruct buffer_head * bh;
bh43fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh45fs/minix/truncate.cbrelse(bh);
bh48fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh50fs/minix/truncate.cbrelse(bh);
bh55fs/minix/truncate.cbrelse(bh);
bh63fs/minix/truncate.cstruct buffer_head * bh;
bh92fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh94fs/minix/truncate.cbrelse(bh);
bh97fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh99fs/minix/truncate.cbrelse(bh);
bh104fs/minix/truncate.cbrelse(bh);
bh85fs/msdos/buffer.cstruct buffer_head *bh)
bh87fs/msdos/buffer.cif (bh != NULL){
bh89fs/msdos/buffer.cbrelse (bh);
bh91fs/msdos/buffer.cbrelse (bh->b_next);
bh95fs/msdos/buffer.ckfree (bh);
bh102fs/msdos/buffer.cstruct buffer_head *bh,
bh106fs/msdos/buffer.cbh = bh->b_next;
bh108fs/msdos/buffer.cmark_buffer_dirty (bh,dirty_val);
bh113fs/msdos/buffer.cstruct buffer_head *bh,
bh117fs/msdos/buffer.cbh = bh->b_next;
bh119fs/msdos/buffer.cbh->b_uptodate = val;
bh123fs/msdos/buffer.cstruct buffer_head *bh)
bh126fs/msdos/buffer.cbh = bh->b_next;
bh128fs/msdos/buffer.creturn bh->b_uptodate;
bh135fs/msdos/buffer.cstruct buffer_head *bh[32])
bh138fs/msdos/buffer.cll_rw_block(opr,nbreq,bh);
bh143fs/msdos/buffer.ctmp[i] = bh[i]->b_next;
bh74fs/msdos/dir.cstruct buffer_head *bh;
bh92fs/msdos/dir.cbh = NULL;
bh93fs/msdos/dir.cwhile ((ino = msdos_get_entry(inode,&filp->f_pos,&bh,&de)) > -1) {
bh125fs/msdos/dir.cbrelse(bh);
bh131fs/msdos/dir.cif (bh) brelse(bh);
bh26fs/msdos/fat.cstruct buffer_head *bh,*bh2,*c_bh,*c_bh2;
bh36fs/msdos/fat.cif (!(bh = bread(sb->s_dev,MSDOS_SB(sb)->fat_start+(first >>
bh42fs/msdos/fat.cbh2 = bh;
bh46fs/msdos/fat.cbrelse(bh);
bh53fs/msdos/fat.cnext = CF_LE_W(((unsigned short *) bh->b_data)[(first &
bh58fs/msdos/fat.cp_first = &((unsigned char *) bh->b_data)[first & (SECTOR_SIZE-1)];
bh67fs/msdos/fat.c((unsigned short *) bh->b_data)[(first & (SECTOR_SIZE-1)) >>
bh80fs/msdos/fat.cmark_buffer_dirty(bh, 1);
bh85fs/msdos/fat.cmemcpy(c_bh->b_data,bh->b_data,SECTOR_SIZE);
bh87fs/msdos/fat.cif (bh != bh2) {
bh101fs/msdos/fat.cbrelse(bh);
bh102fs/msdos/fat.cif (bh != bh2) brelse(bh2);
bh135fs/msdos/file.cstruct buffer_head *bh;
bh138fs/msdos/file.cbh = getblk(inode->i_dev,sector,SECTOR_SIZE);
bh139fs/msdos/file.cif (bh == NULL)  break;
bh140fs/msdos/file.cpre->bhlist[pre->nblist++] = bh;
bh141fs/msdos/file.cif (!msdos_is_uptodate(sb,bh)) bhreq[nbreq++] = bh;
bh214fs/msdos/file.cstruct buffer_head *bh = pre.bhlist[pre.nolist];
bh217fs/msdos/file.cif (bh == NULL) break;
bh228fs/msdos/file.cwait_on_buffer(bh);
bh229fs/msdos/file.cif (!msdos_is_uptodate(sb,bh)){
bh231fs/msdos/file.cbrelse (bh);
bh235fs/msdos/file.cdata = bh->b_data + offset;
bh254fs/msdos/file.cbrelse(bh);
bh277fs/msdos/file.cstruct buffer_head *bh;
bh312fs/msdos/file.cif (!(bh = getblk(inode->i_dev,sector,SECTOR_SIZE))){
bh316fs/msdos/file.c}else if (!(bh = bread(inode->i_dev,sector,SECTOR_SIZE))) {
bh321fs/msdos/file.cmemcpy_fromfs(bh->b_data+offset,buf,written = size);
bh326fs/msdos/file.cto = (char *) bh->b_data+(filp->f_pos & (SECTOR_SIZE-1));
bh350fs/msdos/file.cmsdos_set_uptodate(sb,bh,1);
bh351fs/msdos/file.cmark_buffer_dirty(bh, 0);
bh352fs/msdos/file.cbrelse(bh);
bh171fs/msdos/inode.cstruct buffer_head *bh;
bh200fs/msdos/inode.cbh = bread(sb->s_dev, 0, 1024);
bh202fs/msdos/inode.cif (bh == NULL || !msdos_is_uptodate(sb,bh)) {
bh203fs/msdos/inode.cbrelse (bh);
bh209fs/msdos/inode.cb = (struct msdos_boot_sector *) bh->b_data;
bh257fs/msdos/inode.cbrelse(bh);
bh356fs/msdos/inode.cstruct buffer_head *bh;
bh383fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
bh388fs/msdos/inode.craw_entry = &((struct msdos_dir_entry *) (bh->b_data))
bh435fs/msdos/inode.cbrelse(bh);
bh442fs/msdos/inode.cstruct buffer_head *bh;
bh447fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
bh452fs/msdos/inode.craw_entry = &((struct msdos_dir_entry *) (bh->b_data))
bh468fs/msdos/inode.cmark_buffer_dirty(bh, 1);
bh469fs/msdos/inode.cbrelse(bh);
bh121fs/msdos/misc.cstruct buffer_head *bh;
bh178fs/msdos/misc.cif (!(bh = getblk(inode->i_dev,sector,SECTOR_SIZE)))
bh181fs/msdos/misc.cmemset(bh->b_data,0,SECTOR_SIZE);
bh182fs/msdos/misc.cmsdos_set_uptodate(sb,bh,1);
bh183fs/msdos/misc.cmark_buffer_dirty(bh, 1);
bh184fs/msdos/misc.cbrelse(bh);
bh261fs/msdos/misc.cint msdos_get_entry(struct inode *dir, loff_t *pos,struct buffer_head **bh,
bh272fs/msdos/misc.cPRINTK (("get_entry sector %d %p\n",sector,*bh));
bh276fs/msdos/misc.cif (*bh)
bh277fs/msdos/misc.cbrelse(*bh);
bh279fs/msdos/misc.cif (!(*bh = bread(dir->i_dev,sector,SECTOR_SIZE))) {
bh284fs/msdos/misc.c*de = (struct msdos_dir_entry *) ((*bh)->b_data+(offset &
bh348fs/msdos/misc.cstruct buffer_head *bh;
bh353fs/msdos/misc.cif (!(bh = bread(sb->s_dev,sector,SECTOR_SIZE))) return -EIO;
bh354fs/msdos/misc.cdata = (struct msdos_dir_entry *) bh->b_data;
bh367fs/msdos/misc.cif (!res_bh) brelse(bh);
bh369fs/msdos/misc.c*res_bh = bh;
bh375fs/msdos/misc.cbrelse(bh);
bh4fs/msdos/msbuffer.hvoid msdos_brelse (struct super_block *sb, struct buffer_head *bh);
bh6fs/msdos/msbuffer.hstruct buffer_head *bh,
bh9fs/msdos/msbuffer.hstruct buffer_head *bh,
bh11fs/msdos/msbuffer.hint msdos_is_uptodate (struct super_block *sb, struct buffer_head *bh);
bh13fs/msdos/msbuffer.hint nbreq, struct buffer_head *bh[32]);
bh102fs/msdos/namei.cstruct buffer_head **bh,struct msdos_dir_entry **de,int *ino)
bh109fs/msdos/namei.creturn msdos_scan(dir,msdos_name,bh,de,ino);
bh119fs/msdos/namei.cstruct buffer_head *bh;
bh143fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
bh148fs/msdos/namei.cif (bh) brelse(bh);
bh184fs/msdos/namei.cstruct buffer_head *bh;
bh188fs/msdos/namei.cif ((res = msdos_scan(dir,NULL,&bh,&de,&ino)) < 0) {
bh192fs/msdos/namei.cif ((res = msdos_scan(dir,NULL,&bh,&de,&ino)) < 0) return res;
bh205fs/msdos/namei.cmark_buffer_dirty(bh, 1);
bh208fs/msdos/namei.cbrelse(bh);
bh221fs/msdos/namei.cstruct buffer_head *bh;
bh233fs/msdos/namei.cif (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) {
bh235fs/msdos/namei.cbrelse(bh);
bh269fs/msdos/namei.cstruct buffer_head *bh;
bh281fs/msdos/namei.cif (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) {
bh283fs/msdos/namei.cbrelse(bh);
bh328fs/msdos/namei.cstruct buffer_head *bh;
bh335fs/msdos/namei.cbh = NULL;
bh336fs/msdos/namei.cwhile (msdos_get_entry(dir,&pos,&bh,&de) > -1)
bh340fs/msdos/namei.cbrelse(bh);
bh343fs/msdos/namei.cif (bh)
bh344fs/msdos/namei.cbrelse(bh);
bh354fs/msdos/namei.cstruct buffer_head *bh;
bh358fs/msdos/namei.cbh = NULL;
bh363fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
bh378fs/msdos/namei.cmark_buffer_dirty(bh, 1);
bh381fs/msdos/namei.cbrelse(bh);
bh396fs/msdos/namei.cstruct buffer_head *bh;
bh400fs/msdos/namei.cbh = NULL;
bh402fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
bh417fs/msdos/namei.cmark_buffer_dirty(bh, 1);
bh419fs/msdos/namei.cbrelse(bh);
bh38fs/sysv/balloc.cstruct buffer_head * bh;
bh62fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
bh63fs/sysv/balloc.cif (!bh) {
bh68fs/sysv/balloc.cbh_data = bh->b_data;
bh90fs/sysv/balloc.cmark_buffer_dirty(bh, 1);
bh91fs/sysv/balloc.cbh->b_uptodate = 1;
bh92fs/sysv/balloc.cbrelse(bh);
bh99fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
bh100fs/sysv/balloc.cif (!bh) {
bh105fs/sysv/balloc.cmemset(bh->b_data, 0, sb->sv_block_size);
bh107fs/sysv/balloc.cmark_buffer_dirty(bh, 1);
bh108fs/sysv/balloc.cbh->b_uptodate = 1;
bh109fs/sysv/balloc.cbrelse(bh);
bh113fs/sysv/balloc.cbh = sv_get_hash_table(sb, sb->s_dev, block);
bh114fs/sysv/balloc.cif (bh)
bh115fs/sysv/balloc.cbh->b_dirt = 0;
bh116fs/sysv/balloc.cbrelse(bh);
bh135fs/sysv/balloc.cstruct buffer_head * bh;
bh164fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh171fs/sysv/balloc.cbh_data = bh->b_data;
bh193fs/sysv/balloc.cbrelse(bh);
bh199fs/sysv/balloc.cbrelse(bh);
bh202fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
bh203fs/sysv/balloc.cif (!bh) {
bh208fs/sysv/balloc.cif (bh->b_count != 1) {
bh213fs/sysv/balloc.cmemset(bh->b_data, 0, sb->sv_block_size);
bh214fs/sysv/balloc.cmark_buffer_dirty(bh, 1);
bh215fs/sysv/balloc.cbh->b_uptodate = 1;
bh216fs/sysv/balloc.cbrelse(bh);
bh234fs/sysv/balloc.cstruct buffer_head * bh;
bh261fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh265fs/sysv/balloc.cbh_data = bh->b_data;
bh287fs/sysv/balloc.cbrelse(bh);
bh291fs/sysv/balloc.cbrelse(bh);
bh305fs/sysv/balloc.cbrelse(bh);
bh77fs/sysv/dir.cstruct buffer_head * bh;
bh87fs/sysv/dir.cbh = sysv_file_bread(inode, filp->f_pos >> sb->sv_block_size_bits, 0);
bh88fs/sysv/dir.cif (!bh) {
bh92fs/sysv/dir.cbh_data = bh->b_data;
bh117fs/sysv/dir.cbrelse(bh);
bh122fs/sysv/dir.cbrelse(bh);
bh208fs/sysv/file.cstruct buffer_head * bh;
bh232fs/sysv/file.cbh = sysv_getblk (inode, pos >> sb->sv_block_size_bits, 1);
bh233fs/sysv/file.cif (!bh) {
bh241fs/sysv/file.cif (c != sb->sv_block_size && !bh->b_uptodate) {
bh242fs/sysv/file.cll_rw_block(READ, 1, &bh);
bh243fs/sysv/file.cwait_on_buffer(bh);
bh244fs/sysv/file.cif (!bh->b_uptodate) {
bh245fs/sysv/file.cbrelse(bh);
bh252fs/sysv/file.cp = (pos & sb->sv_block_size_1) + bh->b_data;
bh261fs/sysv/file.cbh->b_uptodate = 1;
bh262fs/sysv/file.cmark_buffer_dirty(bh, 0);
bh263fs/sysv/file.cbrelse(bh);
bh35fs/sysv/fsync.cstruct buffer_head * bh;
bh45fs/sysv/fsync.cbh = sv_get_hash_table(sb, inode->i_dev, block);
bh46fs/sysv/fsync.cif (!bh)
bh49fs/sysv/fsync.cbrelse (bh);
bh52fs/sysv/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh53fs/sysv/fsync.cbrelse(bh);
bh56fs/sysv/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt) {
bh57fs/sysv/fsync.cbrelse(bh);
bh60fs/sysv/fsync.cll_rw_block(WRITE, 1, &bh);
bh61fs/sysv/fsync.cbh->b_count--;
bh67fs/sysv/fsync.cstruct buffer_head * *bh, int wait)
bh72fs/sysv/fsync.c*bh = NULL;
bh81fs/sysv/fsync.c*bh = sv_bread(inode->i_sb, inode->i_dev, block);
bh83fs/sysv/fsync.cbrelse(*bh);
bh84fs/sysv/fsync.c*bh = NULL;
bh87fs/sysv/fsync.cif (!*bh)
bh60fs/sysv/ialloc.cstruct buffer_head * bh;
bh86fs/sysv/ialloc.cif (!(bh = sv_bread(sb, inode->i_dev, sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits)))) {
bh91fs/sysv/ialloc.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
bh100fs/sysv/ialloc.cmark_buffer_dirty(bh, 1);
bh102fs/sysv/ialloc.cbrelse(bh);
bh110fs/sysv/ialloc.cstruct buffer_head * bh;
bh131fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh136fs/sysv/ialloc.craw_inode = (struct sysv_inode *) bh->b_data + j;
bh141fs/sysv/ialloc.cbrelse(bh);
bh183fs/sysv/ialloc.cstruct buffer_head * bh;
bh197fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh202fs/sysv/ialloc.craw_inode = (struct sysv_inode *) bh->b_data + j;
bh206fs/sysv/ialloc.cbrelse(bh);
bh125fs/sysv/inode.cstatic const char* detect_xenix (struct super_block *sb, struct buffer_head *bh)
bh129fs/sysv/inode.csbd = (struct xenix_super_block *) bh->b_data;
bh182fs/sysv/inode.cstatic const char* detect_sysv4 (struct super_block *sb, struct buffer_head *bh)
bh186fs/sysv/inode.csbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh199fs/sysv/inode.cstatic struct super_block * detected_sysv4 (struct super_block *sb, struct buffer_head *bh)
bh204fs/sysv/inode.csbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh206fs/sysv/inode.csbd = (struct sysv4_super_block *) bh->b_data;
bh220fs/sysv/inode.csb->sv_bh1 = bh;
bh221fs/sysv/inode.csb->sv_bh2 = bh;
bh240fs/sysv/inode.cstatic const char* detect_sysv2 (struct super_block *sb, struct buffer_head *bh)
bh244fs/sysv/inode.csbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh257fs/sysv/inode.cstatic struct super_block * detected_sysv2 (struct super_block *sb, struct buffer_head *bh)
bh262fs/sysv/inode.csbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh264fs/sysv/inode.csbd = (struct sysv2_super_block *) bh->b_data;
bh278fs/sysv/inode.csb->sv_bh1 = bh;
bh279fs/sysv/inode.csb->sv_bh2 = bh;
bh298fs/sysv/inode.cstatic const char* detect_coherent (struct super_block *sb, struct buffer_head *bh)
bh302fs/sysv/inode.csbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh310fs/sysv/inode.cstatic struct super_block * detected_coherent (struct super_block *sb, struct buffer_head *bh)
bh314fs/sysv/inode.csbd = (struct coh_super_block *) bh->b_data;
bh326fs/sysv/inode.csb->sv_bh1 = bh;
bh327fs/sysv/inode.csb->sv_bh2 = bh;
bh348fs/sysv/inode.cstruct buffer_head *bh;
bh366fs/sysv/inode.cif ((bh = bread(dev, 1, BLOCK_SIZE)) != NULL) {
bh367fs/sysv/inode.cif ((found = detect_xenix(sb,bh)) != NULL)
bh369fs/sysv/inode.cbrelse(bh);
bh371fs/sysv/inode.cif ((bh = bread(dev, 0, BLOCK_SIZE)) != NULL) {
bh373fs/sysv/inode.cif ((found = detect_sysv4(sb,bh)) != NULL)
bh375fs/sysv/inode.cif ((found = detect_sysv2(sb,bh)) != NULL)
bh378fs/sysv/inode.cif ((found = detect_coherent(sb,bh)) != NULL)
bh380fs/sysv/inode.cbrelse(bh);
bh387fs/sysv/inode.cif ((bh = bread(dev, offsets[i], BLOCK_SIZE)) != NULL) {
bh389fs/sysv/inode.cif ((found = detect_sysv4(sb,bh)) != NULL) {
bh393fs/sysv/inode.cif ((found = detect_sysv2(sb,bh)) != NULL) {
bh397fs/sysv/inode.cbrelse(bh);
bh412fs/sysv/inode.cif (!detected_xenix(sb,bh,bh))
bh416fs/sysv/inode.cif (!detected_sysv4(sb,bh))
bh420fs/sysv/inode.cif (!detected_sysv2(sb,bh))
bh425fs/sysv/inode.cbrelse(bh);
bh435fs/sysv/inode.cunsigned long blocknr = bh->b_blocknr << sb->sv_block_size_ratio_bits;
bh437fs/sysv/inode.cbrelse(bh);
bh566fs/sysv/inode.cstatic int block_bmap(struct super_block * sb, struct buffer_head * bh, int nr, int convert)
bh570fs/sysv/inode.cif (!bh)
bh572fs/sysv/inode.ctmp = ((sysv_zone_t *) bh->b_data) [nr];
bh575fs/sysv/inode.cbrelse(bh);
bh587fs/sysv/inode.cstruct buffer_head * bh;
bh597fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh598fs/sysv/inode.creturn block_bmap(sb, bh, block, convert);
bh605fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh606fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_bits, convert);
bh609fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh610fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
bh617fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh618fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_2_bits, convert);
bh621fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh622fs/sysv/inode.ci = block_bmap(sb, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1,convert);
bh625fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh626fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
bh677fs/sysv/inode.cstruct buffer_head * bh, int nr, int create)
bh684fs/sysv/inode.cif (!bh)
bh686fs/sysv/inode.cif (!bh->b_uptodate) {
bh687fs/sysv/inode.cll_rw_block(READ, 1, &bh);
bh688fs/sysv/inode.cwait_on_buffer(bh);
bh689fs/sysv/inode.cif (!bh->b_uptodate) {
bh690fs/sysv/inode.cbrelse(bh);
bh695fs/sysv/inode.cp = nr + (sysv_zone_t *) bh->b_data;
bh701fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
bh703fs/sysv/inode.cbrelse(bh);
bh710fs/sysv/inode.cbrelse(bh);
bh715fs/sysv/inode.cbrelse(bh);
bh718fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
bh725fs/sysv/inode.cmark_buffer_dirty(bh, 1);
bh726fs/sysv/inode.cbrelse(bh);
bh733fs/sysv/inode.cstruct buffer_head * bh;
bh739fs/sysv/inode.cbh = inode_getblk(inode,10,create);
bh740fs/sysv/inode.creturn block_getblk(inode, bh, block, create);
bh744fs/sysv/inode.cbh = inode_getblk(inode,11,create);
bh745fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_bits, create);
bh746fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
bh750fs/sysv/inode.cbh = inode_getblk(inode,12,create);
bh751fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_2_bits, create);
bh752fs/sysv/inode.cbh = block_getblk(inode, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1, create);
bh753fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
bh765fs/sysv/inode.cstruct buffer_head * bh;
bh767fs/sysv/inode.cbh = sysv_getblk(inode,block,create);
bh768fs/sysv/inode.cif (!bh || bh->b_uptodate)
bh769fs/sysv/inode.creturn bh;
bh770fs/sysv/inode.cll_rw_block(READ, 1, &bh);
bh771fs/sysv/inode.cwait_on_buffer(bh);
bh772fs/sysv/inode.cif (bh->b_uptodate)
bh773fs/sysv/inode.creturn bh;
bh774fs/sysv/inode.cbrelse(bh);
bh806fs/sysv/inode.cstruct buffer_head * bh;
bh820fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
bh825fs/sysv/inode.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
bh857fs/sysv/inode.cbrelse(bh);
bh893fs/sysv/inode.cstruct buffer_head * bh;
bh906fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
bh911fs/sysv/inode.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
bh940fs/sysv/inode.cmark_buffer_dirty(bh, 1);
bh941fs/sysv/inode.creturn bh;
bh946fs/sysv/inode.cstruct buffer_head *bh;
bh947fs/sysv/inode.cbh = sysv_update_inode(inode);
bh948fs/sysv/inode.cbrelse(bh);
bh954fs/sysv/inode.cstruct buffer_head *bh;
bh956fs/sysv/inode.cbh = sysv_update_inode(inode);
bh957fs/sysv/inode.cif (bh && bh->b_dirt) {
bh958fs/sysv/inode.cll_rw_block(WRITE, 1, &bh);
bh959fs/sysv/inode.cwait_on_buffer(bh);
bh960fs/sysv/inode.cif (bh->b_req && !bh->b_uptodate)
bh967fs/sysv/inode.celse if (!bh)
bh969fs/sysv/inode.cbrelse (bh);
bh69fs/sysv/namei.cstruct buffer_head * bh;
bh80fs/sysv/namei.cbh = NULL;
bh83fs/sysv/namei.cif (!bh) {
bh84fs/sysv/namei.cbh = sysv_file_bread(dir,block,0);
bh85fs/sysv/namei.cif (!bh) {
bh92fs/sysv/namei.c*res_dir = (struct sysv_dir_entry *) (bh->b_data + offset) ))
bh93fs/sysv/namei.creturn bh;
bh98fs/sysv/namei.cbrelse(bh);
bh99fs/sysv/namei.cbh = NULL;
bh102fs/sysv/namei.cbrelse(bh);
bh112fs/sysv/namei.cstruct buffer_head * bh;
bh121fs/sysv/namei.cif (!(bh = sysv_find_entry(dir,name,len,&de))) {
bh126fs/sysv/namei.cbrelse(bh);
bh153fs/sysv/namei.cstruct buffer_head * bh;
bh168fs/sysv/namei.cbh = NULL;
bh171fs/sysv/namei.cif (!bh) {
bh172fs/sysv/namei.cbh = sysv_file_bread(dir,block,1);
bh173fs/sysv/namei.cif (!bh)
bh176fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + offset);
bh186fs/sysv/namei.cbrelse(bh);
bh194fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh200fs/sysv/namei.cbrelse(bh);
bh201fs/sysv/namei.cbh = NULL;
bh204fs/sysv/namei.c*res_buf = bh;
bh213fs/sysv/namei.cstruct buffer_head * bh;
bh227fs/sysv/namei.cerror = sysv_add_entry(dir,name,len, &bh ,&de);
bh236fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh237fs/sysv/namei.cbrelse(bh);
bh247fs/sysv/namei.cstruct buffer_head * bh;
bh252fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh253fs/sysv/namei.cif (bh) {
bh254fs/sysv/namei.cbrelse(bh);
bh284fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
bh293fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh294fs/sysv/namei.cbrelse(bh);
bh304fs/sysv/namei.cstruct buffer_head * bh, *dir_block;
bh311fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh312fs/sysv/namei.cif (bh) {
bh313fs/sysv/namei.cbrelse(bh);
bh349fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
bh357fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh362fs/sysv/namei.cbrelse(bh);
bh373fs/sysv/namei.cstruct buffer_head * bh;
bh379fs/sysv/namei.cbh = NULL;
bh385fs/sysv/namei.cbh = sysv_file_bread(inode,0,0);
bh386fs/sysv/namei.cif (!bh)
bh388fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + 0*SYSV_DIRSIZE);
bh391fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + 1*SYSV_DIRSIZE);
bh396fs/sysv/namei.cif (!bh) {
bh397fs/sysv/namei.cbh = sysv_file_bread(inode,block,0);
bh398fs/sysv/namei.cif (!bh) {
bh404fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + offset);
bh408fs/sysv/namei.cbrelse(bh);
bh413fs/sysv/namei.cbrelse(bh);
bh414fs/sysv/namei.cbh = NULL;
bh417fs/sysv/namei.cbrelse(bh);
bh420fs/sysv/namei.cbrelse(bh);
bh429fs/sysv/namei.cstruct buffer_head * bh;
bh433fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh435fs/sysv/namei.cif (!bh)
bh467fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh477fs/sysv/namei.cbrelse(bh);
bh485fs/sysv/namei.cstruct buffer_head * bh;
bh491fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh492fs/sysv/namei.cif (!bh)
bh501fs/sysv/namei.cbrelse(bh);
bh520fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh528fs/sysv/namei.cbrelse(bh);
bh543fs/sysv/namei.cstruct buffer_head * bh;
bh569fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh570fs/sysv/namei.cif (bh) {
bh574fs/sysv/namei.cbrelse(bh);
bh578fs/sysv/namei.ci = sysv_add_entry(dir, name, len, &bh, &de);
bh587fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh588fs/sysv/namei.cbrelse(bh);
bh598fs/sysv/namei.cstruct buffer_head * bh;
bh610fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh611fs/sysv/namei.cif (bh) {
bh612fs/sysv/namei.cbrelse(bh);
bh617fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
bh624fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh625fs/sysv/namei.cbrelse(bh);
bh55fs/sysv/symlink.cstruct buffer_head * bh;
bh76fs/sysv/symlink.cif (!(bh = sysv_file_bread(inode, 0, 0))) { /* is reading 1 block enough ?? */
bh83fs/sysv/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh85fs/sysv/symlink.cbrelse(bh);
bh91fs/sysv/symlink.cstruct buffer_head * bh;
bh102fs/sysv/symlink.cbh = sysv_file_bread(inode, 0, 0);
bh104fs/sysv/symlink.cif (!bh)
bh106fs/sysv/symlink.cbh_data = bh->b_data;
bh112fs/sysv/symlink.cbrelse(bh);
bh50fs/sysv/truncate.cstruct buffer_head * bh;
bh60fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
bh62fs/sysv/truncate.cbrelse(bh);
bh65fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (block != *p)) {
bh67fs/sysv/truncate.cbrelse(bh);
bh72fs/sysv/truncate.cbrelse(bh);
bh86fs/sysv/truncate.cstruct buffer_head * bh;
bh117fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
bh119fs/sysv/truncate.cbrelse(bh);
bh122fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (tmp != *ind)) {
bh124fs/sysv/truncate.cbrelse(bh);
bh129fs/sysv/truncate.cbrelse(bh);
bh32fs/xiafs/bitmap.cstatic int find_first_zero(struct buffer_head *bh, int start_bit, int end_bit) 
bh43fs/xiafs/bitmap.cbmap=(u_long *)bh->b_data;
bh65fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh69fs/xiafs/bitmap.cstatic void clear_buf(struct buffer_head * bh) 
bh74fs/xiafs/bitmap.clp=(long *)bh->b_data;
bh75fs/xiafs/bitmap.cfor (i= bh->b_size >> 2; i-- > 0; )
bh176fs/xiafs/bitmap.cstruct buffer_head * bh;
bh199fs/xiafs/bitmap.cbh = get__map_zone(sb, bmap_buf, bznr, cache, first_zone, 
bh201fs/xiafs/bitmap.cif (!bh)
bh203fs/xiafs/bitmap.ctmp=find_first_zero(bh, start_bit, end_bit);
bh220fs/xiafs/bitmap.cstruct buffer_head * bh;
bh232fs/xiafs/bitmap.cbh = get_hash_table(sb->s_dev, d_addr, XIAFS_ZSIZE(sb));
bh233fs/xiafs/bitmap.cif (bh)
bh234fs/xiafs/bitmap.cbh->b_dirt=0;
bh235fs/xiafs/bitmap.cbrelse(bh);
bh237fs/xiafs/bitmap.cbh = get_zmap_zone(sb, bit, NULL);
bh238fs/xiafs/bitmap.cif (!bh)
bh241fs/xiafs/bitmap.cif (!clear_bit(offset, bh->b_data))
bh245fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh251fs/xiafs/bitmap.cstruct buffer_head * bh;
bh267fs/xiafs/bitmap.cif (!(bh = getblk(sb->s_dev, tmp, XIAFS_ZSIZE(sb)))) {
bh271fs/xiafs/bitmap.cif (bh->b_count != 1) {
bh275fs/xiafs/bitmap.cclear_buf(bh);
bh276fs/xiafs/bitmap.cbh->b_uptodate = 1;
bh277fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh278fs/xiafs/bitmap.cbrelse(bh);
bh284fs/xiafs/bitmap.cstruct buffer_head * bh;
bh297fs/xiafs/bitmap.cbh = get_imap_zone(sb, ino, NULL);
bh298fs/xiafs/bitmap.cif (!bh)
bh301fs/xiafs/bitmap.cif (!clear_bit(ino & (XIAFS_BITS_PER_Z(sb)-1), bh->b_data))
bh305fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh343fs/xiafs/bitmap.cstatic u_long count_zone(struct buffer_head * bh)
bh349fs/xiafs/bitmap.cfor (i=bh->b_size; i-- > 0; ) {
bh350fs/xiafs/bitmap.ctmp=bh->b_data[i];
bh358fs/xiafs/bitmap.cstruct buffer_head * bh;
bh365fs/xiafs/bitmap.cbh=get_imap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
bh366fs/xiafs/bitmap.cif (bh) {
bh367fs/xiafs/bitmap.csum += count_zone(bh);
bh377fs/xiafs/bitmap.cstruct buffer_head * bh;
bh384fs/xiafs/bitmap.cbh=get_zmap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
bh385fs/xiafs/bitmap.cif (bh) {
bh386fs/xiafs/bitmap.csum += count_zone(bh);
bh76fs/xiafs/dir.cstruct buffer_head * bh;
bh86fs/xiafs/dir.cbh = xiafs_bread(inode, filp->f_pos >> XIAFS_ZSIZE_BITS(inode->i_sb),0);
bh87fs/xiafs/dir.cif (!bh) {
bh92fs/xiafs/dir.cde = (struct xiafs_direct *) (bh->b_data + i);
bh98fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
bh103fs/xiafs/dir.c(char *)de+de->d_rec_len > XIAFS_ZSIZE(inode->i_sb)+bh->b_data ||
bh108fs/xiafs/dir.cbrelse(bh);
bh126fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
bh128fs/xiafs/dir.cbrelse(bh);
bh198fs/xiafs/file.cstruct buffer_head * bh;
bh219fs/xiafs/file.cbh = xiafs_getblk(inode, pos >> XIAFS_ZSIZE_BITS(inode->i_sb), 1);
bh220fs/xiafs/file.cif (!bh) {
bh228fs/xiafs/file.cif (c != XIAFS_ZSIZE(inode->i_sb) && !bh->b_uptodate) {
bh229fs/xiafs/file.cll_rw_block(READ, 1, &bh);
bh230fs/xiafs/file.cwait_on_buffer(bh);
bh231fs/xiafs/file.cif (!bh->b_uptodate) {
bh232fs/xiafs/file.cbrelse(bh);
bh238fs/xiafs/file.ccp = (pos & (XIAFS_ZSIZE(inode->i_sb)-1)) + bh->b_data;
bh247fs/xiafs/file.cbh->b_uptodate = 1;
bh248fs/xiafs/file.cmark_buffer_dirty(bh, 0);
bh249fs/xiafs/file.cbrelse(bh);
bh35fs/xiafs/fsync.cstruct buffer_head * bh;
bh41fs/xiafs/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh42fs/xiafs/fsync.cif (!bh)
bh45fs/xiafs/fsync.cbrelse (bh);
bh48fs/xiafs/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh49fs/xiafs/fsync.cbrelse(bh);
bh52fs/xiafs/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt)
bh54fs/xiafs/fsync.cbrelse(bh);
bh57fs/xiafs/fsync.cll_rw_block(WRITE, 1, &bh);
bh58fs/xiafs/fsync.cbh->b_count--;
bh63fs/xiafs/fsync.cstruct buffer_head **bh, int wait) 
bh67fs/xiafs/fsync.c*bh = NULL;
bh74fs/xiafs/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh76fs/xiafs/fsync.cbrelse(*bh);
bh77fs/xiafs/fsync.c*bh = NULL;
bh80fs/xiafs/fsync.cif (!*bh)
bh71fs/xiafs/inode.cstruct buffer_head *bh;
bh81fs/xiafs/inode.cif (!(bh = bread(dev, 0, BLOCK_SIZE))) {
bh88fs/xiafs/inode.csp = (struct xiafs_super_block *) bh->b_data;
bh93fs/xiafs/inode.cbrelse(bh);
bh105fs/xiafs/inode.cbrelse(bh);
bh107fs/xiafs/inode.cbh = bread (dev, 0,  s->s_blocksize);
bh108fs/xiafs/inode.cif(!bh) {
bh112fs/xiafs/inode.csp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
bh122fs/xiafs/inode.cbrelse(bh);
bh190fs/xiafs/inode.cstatic int zone_bmap(struct buffer_head * bh, int nr)
bh194fs/xiafs/inode.cif (!bh)
bh196fs/xiafs/inode.ctmp = ((u_long *) bh->b_data)[nr];
bh197fs/xiafs/inode.cbrelse(bh);
bh280fs/xiafs/inode.cindt_getblk(struct inode * inode, struct buffer_head * bh, 
bh287fs/xiafs/inode.cif (!bh)
bh289fs/xiafs/inode.cif (!bh->b_uptodate) {
bh290fs/xiafs/inode.cll_rw_block(READ, 1, &bh);
bh291fs/xiafs/inode.cwait_on_buffer(bh);
bh292fs/xiafs/inode.cif (!bh->b_uptodate) {
bh293fs/xiafs/inode.cbrelse(bh);
bh297fs/xiafs/inode.clp = nr + (u_long *) bh->b_data;
bh300fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh302fs/xiafs/inode.cbrelse(bh);
bh309fs/xiafs/inode.cbrelse(bh);
bh314fs/xiafs/inode.cbrelse(bh);
bh317fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh325fs/xiafs/inode.cmark_buffer_dirty(bh, 1);
bh326fs/xiafs/inode.cbrelse(bh);
bh332fs/xiafs/inode.cstruct buffer_head * bh;
bh350fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_ind_zone), create, prev_addr);
bh351fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone, create, prev_addr);
bh352fs/xiafs/inode.creturn bh;
bh355fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_dind_zone), create, prev_addr);
bh356fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb), 
bh358fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone&(XIAFS_ADDRS_PER_Z(inode->i_sb)-1), 
bh360fs/xiafs/inode.creturn bh;
bh365fs/xiafs/inode.cstruct buffer_head * bh;
bh367fs/xiafs/inode.cbh = xiafs_getblk(inode, zone, create);
bh368fs/xiafs/inode.cif (!bh || bh->b_uptodate)
bh369fs/xiafs/inode.creturn bh;
bh370fs/xiafs/inode.cll_rw_block(READ, 1, &bh);
bh371fs/xiafs/inode.cwait_on_buffer(bh);
bh372fs/xiafs/inode.cif (bh->b_uptodate)
bh373fs/xiafs/inode.creturn bh;
bh374fs/xiafs/inode.cbrelse(bh);
bh380fs/xiafs/inode.cstruct buffer_head * bh;
bh395fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
bh399fs/xiafs/inode.craw_inode = ((struct xiafs_inode *) bh->b_data) + 
bh420fs/xiafs/inode.cbrelse(bh);
bh437fs/xiafs/inode.cstruct buffer_head * bh;
bh457fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
bh462fs/xiafs/inode.craw_inode = ((struct xiafs_inode *)bh->b_data) +
bh485fs/xiafs/inode.cmark_buffer_dirty(bh, 1);
bh486fs/xiafs/inode.creturn bh;
bh492fs/xiafs/inode.cstruct buffer_head * bh;
bh493fs/xiafs/inode.cbh = xiafs_update_inode(inode);
bh494fs/xiafs/inode.cbrelse (bh);
bh500fs/xiafs/inode.cstruct buffer_head *bh;
bh502fs/xiafs/inode.cbh = xiafs_update_inode(inode);
bh503fs/xiafs/inode.cif (bh && bh->b_dirt)
bh505fs/xiafs/inode.cll_rw_block(WRITE, 1, &bh);
bh506fs/xiafs/inode.cwait_on_buffer(bh);
bh507fs/xiafs/inode.cif (bh->b_req && !bh->b_uptodate)
bh514fs/xiafs/inode.celse if (!bh)
bh516fs/xiafs/inode.cbrelse (bh);
bh65fs/xiafs/namei.cstruct buffer_head * bh;
bh80fs/xiafs/namei.cbh = xiafs_bread(inode, i, 0);
bh81fs/xiafs/namei.cif (!bh)
bh83fs/xiafs/namei.cdep_pre=dep=(struct xiafs_direct *)bh->b_data;
bh87fs/xiafs/namei.cbrelse(bh);
bh94fs/xiafs/namei.cdep->d_rec_len+(char *)dep > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
bh97fs/xiafs/namei.cbrelse(bh);
bh104fs/xiafs/namei.creturn bh;
bh108fs/xiafs/namei.cdep=(struct xiafs_direct *)(bh->b_data + pos);
bh110fs/xiafs/namei.cbrelse(bh);
bh124fs/xiafs/namei.cstruct buffer_head * bh;
bh133fs/xiafs/namei.cif (!(bh = xiafs_find_entry(dir, name, len, &dep, NULL))) {
bh138fs/xiafs/namei.cbrelse(bh);
bh162fs/xiafs/namei.cstruct buffer_head * bh;
bh175fs/xiafs/namei.cbh =  xiafs_bread(dir, pos >> XIAFS_ZSIZE_BITS(dir->i_sb), pos ? 1:0);
bh176fs/xiafs/namei.cif (!bh)
bh178fs/xiafs/namei.cde_pre=de=(struct xiafs_direct *)bh->b_data;
bh183fs/xiafs/namei.cbrelse(bh);
bh187fs/xiafs/namei.cde_pre=de=(struct xiafs_direct *)(bh->b_data+12);
bh201fs/xiafs/namei.c(char *)de+de->d_rec_len > bh->b_data+XIAFS_ZSIZE(dir->i_sb) ||
bh205fs/xiafs/namei.cbrelse(bh);
bh228fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh232fs/xiafs/namei.creturn bh;
bh236fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
bh238fs/xiafs/namei.cbrelse(bh);
bh252fs/xiafs/namei.cstruct buffer_head * bh;
bh266fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh267fs/xiafs/namei.cif (!bh) {
bh275fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh276fs/xiafs/namei.cbrelse(bh);
bh285fs/xiafs/namei.cstruct buffer_head * bh;
bh290fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
bh291fs/xiafs/namei.cif (bh) {
bh292fs/xiafs/namei.cbrelse(bh);
bh323fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh324fs/xiafs/namei.cif (!bh) {
bh332fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh333fs/xiafs/namei.cbrelse(bh);
bh342fs/xiafs/namei.cstruct buffer_head * bh, *dir_block;
bh345fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
bh346fs/xiafs/namei.cif (bh) {
bh347fs/xiafs/namei.cbrelse(bh);
bh389fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh390fs/xiafs/namei.cif (!bh) {
bh397fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh402fs/xiafs/namei.cbrelse(bh);
bh412fs/xiafs/namei.cstruct buffer_head * bh;
bh422fs/xiafs/namei.cbh =  xiafs_bread(inode, i, 0);
bh424fs/xiafs/namei.cif (!bh) {
bh428fs/xiafs/namei.cde=(struct xiafs_direct *)bh->b_data;
bh432fs/xiafs/namei.cbrelse(bh);
bh435fs/xiafs/namei.cde=(struct xiafs_direct *)(12 + bh->b_data);
bh438fs/xiafs/namei.cbrelse(bh);
bh445fs/xiafs/namei.cif (!bh)
bh448fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
bh451fs/xiafs/namei.c(char *)de+de->d_rec_len > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
bh455fs/xiafs/namei.cbrelse(bh);
bh459fs/xiafs/namei.cbrelse(bh);
bh464fs/xiafs/namei.cbrelse(bh);
bh493fs/xiafs/namei.cstruct buffer_head * bh;
bh497fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
bh499fs/xiafs/namei.cif (!bh)
bh527fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh537fs/xiafs/namei.cbrelse(bh);
bh545fs/xiafs/namei.cstruct buffer_head * bh;
bh551fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
bh552fs/xiafs/namei.cif (!bh)
bh561fs/xiafs/namei.cbrelse(bh);
bh575fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh582fs/xiafs/namei.cbrelse(bh);
bh593fs/xiafs/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh597fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
bh598fs/xiafs/namei.cif (bh) {
bh599fs/xiafs/namei.cbrelse(bh);
bh624fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh625fs/xiafs/namei.cif (!bh) {
bh633fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh634fs/xiafs/namei.cbrelse(bh);
bh644fs/xiafs/namei.cstruct buffer_head * bh;
bh656fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
bh657fs/xiafs/namei.cif (bh) {
bh658fs/xiafs/namei.cbrelse(bh);
bh663fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh664fs/xiafs/namei.cif (!bh) {
bh670fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh671fs/xiafs/namei.cbrelse(bh);
bh53fs/xiafs/symlink.cstruct buffer_head * bh;
bh63fs/xiafs/symlink.cbh = xiafs_bread(inode, 0, 0);
bh69fs/xiafs/symlink.cif (!bh)
bh71fs/xiafs/symlink.cfor (i=0; i < buflen && (c=bh->b_data[i]); i++)
bh75fs/xiafs/symlink.cbrelse(bh);
bh83fs/xiafs/symlink.cstruct buffer_head * bh;
bh108fs/xiafs/symlink.cif (!(bh = xiafs_bread(inode, 0, 0))) {
bh115fs/xiafs/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh117fs/xiafs/symlink.cbrelse(bh);
bh45fs/xiafs/truncate.cstruct buffer_head * bh;
bh56fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh58fs/xiafs/truncate.cbrelse(bh);
bh61fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *lp)
bh69fs/xiafs/truncate.cbrelse(bh);
bh79fs/xiafs/truncate.cstruct buffer_head * bh, * ind_bh;
bh102fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh104fs/xiafs/truncate.cbrelse(bh);
bh107fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *indp)
bh115fs/xiafs/truncate.cbrelse(bh);
bh23include/linux/blkdev.hstruct buffer_head * bh;
bh441include/linux/fs.hextern inline void mark_buffer_clean(struct buffer_head * bh)
bh443include/linux/fs.hif(bh->b_dirt) {
bh444include/linux/fs.hbh->b_dirt = 0;
bh445include/linux/fs.hif(bh->b_list == BUF_DIRTY) refile_buffer(bh);
bh449include/linux/fs.hextern inline void mark_buffer_dirty(struct buffer_head * bh, int flag)
bh451include/linux/fs.hif(!bh->b_dirt) {
bh452include/linux/fs.hbh->b_dirt = 1;
bh453include/linux/fs.hset_writetime(bh, flag);
bh454include/linux/fs.hif(bh->b_list != BUF_DIRTY) refile_buffer(bh);
bh486include/linux/fs.hextern void ll_rw_block(int rw, int nr, struct buffer_head * bh[]);
bh202include/linux/iso_fs.hextern void leak_check_brelse(struct buffer_head * bh);
bh10include/linux/locks.hextern inline void wait_on_buffer(struct buffer_head * bh)
bh12include/linux/locks.hif (bh->b_lock)
bh13include/linux/locks.h__wait_on_buffer(bh);
bh16include/linux/locks.hextern inline void lock_buffer(struct buffer_head * bh)
bh18include/linux/locks.hif (bh->b_lock)
bh19include/linux/locks.h__wait_on_buffer(bh);
bh20include/linux/locks.hbh->b_lock = 1;
bh23include/linux/locks.hextern inline void unlock_buffer(struct buffer_head * bh)
bh25include/linux/locks.hbh->b_lock = 0;
bh26include/linux/locks.hwake_up(&bh->b_wait);
bh125include/linux/msdos_fs.hextern int msdos_get_entry(struct inode *dir,loff_t *pos,struct buffer_head **bh,
bh38kernel/softirq.cstruct bh_struct *bh;
bh40kernel/softirq.cbh = bh_base;
bh42kernel/softirq.cfor (mask = 1, left = ~0 ; left & active ; bh++,mask += mask,left += left) {
bh46kernel/softirq.cfn = bh->routine;
bh49kernel/softirq.cfn(bh->data);
bh68mm/filemap.cstruct buffer_head * bh;
bh70mm/filemap.cbh = buffer_pages[MAP_NR(page)];
bh71mm/filemap.cif (bh) {
bh73mm/filemap.cstruct buffer_head * tmp = bh;
bh77mm/filemap.c} while (tmp != bh);
bh590mm/swap.cstruct buffer_head * bh;
bh592mm/swap.cbh = buffer_pages[MAP_NR(addr)];
bh593mm/swap.cif (bh) {
bh594mm/swap.cstruct buffer_head *tmp = bh;
bh599mm/swap.c} while (tmp != bh);