taglinefilesource code
bh37arch/m68k/amiga/amipart.cstruct buffer_head *bh;
bh43arch/m68k/amiga/amipart.cif (!(bh = bread(dev,bnum,1024))) {
bh51arch/m68k/amiga/amipart.crdb = (struct RigidDiskBlock *)bh->b_data;
bh54arch/m68k/amiga/amipart.crdb = (struct RigidDiskBlock *)&bh->b_data[512];
bh57arch/m68k/amiga/amipart.cbrelse (bh);
bh74arch/m68k/amiga/amipart.cbrelse (bh);
bh80arch/m68k/amiga/amipart.cif (!(bh = bread(dev,partsect/2,1024))) {
bh88arch/m68k/amiga/amipart.cpb = (struct PartitionBlock *)bh->b_data;
bh90arch/m68k/amiga/amipart.cpb = (struct PartitionBlock *)&bh->b_data[512];
bh94arch/m68k/amiga/amipart.cbrelse (bh);
bh99arch/m68k/amiga/amipart.cbrelse (bh);
bh115arch/m68k/amiga/amipart.cbrelse (bh);
bh36arch/m68k/atari/atapart.cstruct buffer_head *bh;
bh44arch/m68k/atari/atapart.cbh = bread (dev, 0, 1024);
bh45arch/m68k/atari/atapart.cif (!bh)
bh51arch/m68k/atari/atapart.crs = (struct rootsector *) bh->b_data;
bh154arch/m68k/atari/atapart.cbrelse (bh);
bh1269drivers/block/amiflop.cif (CURRENT->bh && !buffer_locked(CURRENT->bh))
bh1439drivers/block/ataflop.cif (CURRENT->bh && !buffer_locked(CURRENT->bh))
bh2297drivers/block/floppy.cstruct buffer_head *bh;
bh2303drivers/block/floppy.cbh = CURRENT->bh;
bh2305drivers/block/floppy.cif (bh){
bh2306drivers/block/floppy.cbh = bh->b_reqnext;
bh2307drivers/block/floppy.cwhile (bh && bh->b_data == base + size){
bh2308drivers/block/floppy.csize += bh->b_size;
bh2309drivers/block/floppy.cbh = bh->b_reqnext;
bh2335drivers/block/floppy.cstruct buffer_head *bh;
bh2367drivers/block/floppy.cbh = CURRENT->bh;
bh2404drivers/block/floppy.cbh = bh->b_reqnext;
bh2406drivers/block/floppy.cif (!bh){
bh2411drivers/block/floppy.csize = bh->b_size;
bh2412drivers/block/floppy.cbuffer = bh->b_data;
bh2704drivers/block/floppy.cif (CURRENT->bh && !buffer_locked(CURRENT->bh))
bh3682drivers/block/floppy.cstruct buffer_head * bh;
bh3709drivers/block/floppy.cif (!(bh = getblk(dev,0,size))){
bh3713drivers/block/floppy.cif (bh && !buffer_uptodate(bh))
bh3714drivers/block/floppy.cll_rw_block(READ, 1, &bh);
bh3716drivers/block/floppy.cwait_on_buffer(bh);
bh3717drivers/block/floppy.cbrelse(bh);
bh126drivers/block/genhd.cstruct buffer_head *bh;
bh139drivers/block/genhd.cif (!(bh = bread(dev,0,1024)))
bh145drivers/block/genhd.cbh->b_state = 0;
bh147drivers/block/genhd.cif (*(unsigned short *) (bh->b_data+510) != 0xAA55)
bh150drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
bh205drivers/block/genhd.cbrelse(bh);
bh208drivers/block/genhd.cbrelse(bh);
bh214drivers/block/genhd.cstruct buffer_head *bh;
bh223drivers/block/genhd.cif (!(bh = bread(dev,0,1024))) {
bh227drivers/block/genhd.cdata = bh->b_data;
bh231drivers/block/genhd.cbh->b_state = 0;
bh236drivers/block/genhd.cbrelse(bh);
bh274drivers/block/genhd.cbrelse(bh);
bh348drivers/block/genhd.cbrelse(bh);
bh360drivers/block/genhd.cstruct buffer_head *bh;
bh395drivers/block/genhd.cif (!(bh = bread(dev,0,1024))) {
bh399drivers/block/genhd.clabel = (struct disklabel *) (bh->b_data+64);
bh403drivers/block/genhd.cbrelse(bh);
bh408drivers/block/genhd.cbrelse(bh);
bh421drivers/block/genhd.cbrelse(bh);
bh433drivers/block/genhd.cstruct buffer_head *bh;
bh458drivers/block/genhd.cif(!(bh = bread(dev, 0, 1024))) {
bh462drivers/block/genhd.clabel = (struct sun_disklabel *) bh->b_data;
bh466drivers/block/genhd.cbrelse(bh);
bh475drivers/block/genhd.cbrelse(bh);
bh491drivers/block/genhd.cbrelse(bh);
bh537drivers/block/hd.cWCURRENT.bh = WCURRENT.bh->b_reqnext;
bh538drivers/block/hd.cif (WCURRENT.bh == NULL)
bh540drivers/block/hd.cWCURRENT.current_nr_sectors = WCURRENT.bh->b_size>>9;
bh541drivers/block/hd.cWCURRENT.buffer             = WCURRENT.bh->b_data;
bh605drivers/block/hd.cif (!i || (CURRENT->bh && !SUBSECTOR(i)))
bh535drivers/block/ide-cd.cif (rq->buffer != rq->bh->b_data) {
bh536drivers/block/ide-cd.cint n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
bh537drivers/block/ide-cd.crq->buffer = rq->bh->b_data;
bh541drivers/block/ide-cd.crq->current_nr_sectors = rq->bh->b_size >> SECTOR_BITS;
bh594drivers/block/ide-cd.cif (!uptodate && rq->bh != 0) {
bh971drivers/block/ide-cd.c(rq->bh->b_size >> SECTOR_BITS)),
bh1073drivers/block/ide-cd.cif (rq->current_nr_sectors < (rq->bh->b_size >> SECTOR_BITS) &&
bh1116drivers/block/ide-cd.c(rq->bh->b_size >> SECTOR_BITS)) {
bh4284drivers/block/ide-tape.cidetape_buffer_head_t *prev_bh,*bh;
bh4305drivers/block/ide-tape.cprev_bh=new_stage->bh=(idetape_buffer_head_t *) kmalloc (sizeof (idetape_buffer_head_t),GFP_KERNEL);
bh4306drivers/block/ide-tape.cif (new_stage->bh==NULL) {
bh4310drivers/block/ide-tape.cnew_stage->bh->next=NULL;
bh4312drivers/block/ide-tape.cnew_stage->bh->data=kmalloc (IDETAPE_ALLOCATION_BLOCK,GFP_KERNEL);
bh4313drivers/block/ide-tape.cif (new_stage->bh->data==NULL) {
bh4319drivers/block/ide-tape.cbh=(idetape_buffer_head_t *) kmalloc (sizeof (idetape_buffer_head_t),GFP_KERNEL);
bh4320drivers/block/ide-tape.cif (bh==NULL) {
bh4324drivers/block/ide-tape.cbh->next=NULL;
bh4325drivers/block/ide-tape.cprev_bh->next=bh;
bh4326drivers/block/ide-tape.cbh->data=kmalloc (IDETAPE_ALLOCATION_BLOCK,GFP_KERNEL);
bh4327drivers/block/ide-tape.cif (bh->data == NULL) {
bh4331drivers/block/ide-tape.cprev_bh=bh;
bh4344drivers/block/ide-tape.cidetape_buffer_head_t *prev_bh,*bh;
bh4353drivers/block/ide-tape.cbh=stage->bh;
bh4355drivers/block/ide-tape.cwhile (bh != NULL) {
bh4356drivers/block/ide-tape.cprev_bh=bh;
bh4357drivers/block/ide-tape.cif (bh->data != NULL)
bh4358drivers/block/ide-tape.ckfree (bh->data);
bh4359drivers/block/ide-tape.cbh=bh->next;
bh4375drivers/block/ide-tape.cidetape_buffer_head_t *bh;
bh4389drivers/block/ide-tape.cbh=stage->bh;
bh4391drivers/block/ide-tape.cwhile (bh != NULL) {
bh4393drivers/block/ide-tape.cif (bh->data == NULL) {
bh4398drivers/block/ide-tape.cmemcpy (ptr,bh->data,IDETAPE_ALLOCATION_BLOCK);
bh4399drivers/block/ide-tape.cbh=bh->next;
bh4413drivers/block/ide-tape.cidetape_buffer_head_t *bh;
bh4427drivers/block/ide-tape.cbh=stage->bh;
bh4429drivers/block/ide-tape.cwhile (bh != NULL) {
bh4431drivers/block/ide-tape.cif (bh->data == NULL) {
bh4436drivers/block/ide-tape.cmemcpy (bh->data,ptr,IDETAPE_ALLOCATION_BLOCK);
bh4437drivers/block/ide-tape.cbh=bh->next;
bh348drivers/block/ide-tape.hidetape_buffer_head_t *bh;      /* The data buffers */
bh1038drivers/block/ide.cif ((rq->bh = rq->bh->b_reqnext) != NULL) {
bh1039drivers/block/ide.crq->current_nr_sectors = rq->bh->b_size>>9;
bh1040drivers/block/ide.crq->buffer             = rq->bh->b_data;
bh1384drivers/block/ide.cif (rq->bh && !buffer_locked(rq->bh)) {
bh1690drivers/block/ide.crq->bh = NULL;
bh257drivers/block/ll_rw_blk.cif (req->bh)
bh258drivers/block/ll_rw_blk.cmark_buffer_clean(req->bh);
bh281drivers/block/ll_rw_blk.cstatic void make_request(int major,int rw, struct buffer_head * bh)
bh287drivers/block/ll_rw_blk.ccount = bh->b_size >> 9;
bh288drivers/block/ll_rw_blk.csector = bh->b_rsector;
bh290drivers/block/ll_rw_blk.cif (blk_size[major][MINOR(bh->b_rdev)] < (sector + count)>>1) {
bh291drivers/block/ll_rw_blk.cbh->b_state = 0;
bh293drivers/block/ll_rw_blk.cprintk("%s: rw=%d, want=%d, limit=%d\n", kdevname(bh->b_rdev),
bh294drivers/block/ll_rw_blk.crw, (sector + count)>>1, blk_size[major][MINOR(bh->b_rdev)]);
bh298drivers/block/ll_rw_blk.cif (buffer_locked(bh))
bh301drivers/block/ll_rw_blk.clock_buffer(bh);
bh309drivers/block/ll_rw_blk.cif (buffer_uptodate(bh)) {
bh310drivers/block/ll_rw_blk.cunlock_buffer(bh); /* Hmmph! Already have it */
bh320drivers/block/ll_rw_blk.cif (!buffer_dirty(bh)) {
bh321drivers/block/ll_rw_blk.cunlock_buffer(bh); /* Hmmph! Nothing to write */
bh334drivers/block/ll_rw_blk.cunlock_buffer(bh);
bh379drivers/block/ll_rw_blk.cif (req->rq_dev != bh->b_rdev)
bh383drivers/block/ll_rw_blk.creq->bhtail->b_reqnext = bh;
bh384drivers/block/ll_rw_blk.creq->bhtail = bh;
bh387drivers/block/ll_rw_blk.cbh->b_reqnext = req->bh;
bh388drivers/block/ll_rw_blk.creq->bh = bh;
bh389drivers/block/ll_rw_blk.creq->buffer = bh->b_data;
bh396drivers/block/ll_rw_blk.cmark_buffer_clean(bh);
bh403drivers/block/ll_rw_blk.creq = get_request(max_req, bh->b_rdev);
bh409drivers/block/ll_rw_blk.cunlock_buffer(bh);
bh412drivers/block/ll_rw_blk.creq = __get_request_wait(max_req, bh->b_rdev);
bh421drivers/block/ll_rw_blk.creq->buffer = bh->b_data;
bh423drivers/block/ll_rw_blk.creq->bh = bh;
bh424drivers/block/ll_rw_blk.creq->bhtail = bh;
bh433drivers/block/ll_rw_blk.cvoid ll_rw_block(int rw, int nr, struct buffer_head * bh[])
bh441drivers/block/ll_rw_blk.cwhile (!*bh) {
bh442drivers/block/ll_rw_blk.cbh++;
bh448drivers/block/ll_rw_blk.cif ((major = MAJOR(bh[0]->b_dev)) < MAX_BLKDEV)
bh453drivers/block/ll_rw_blk.ckdevname(bh[0]->b_dev), bh[0]->b_blocknr);
bh460drivers/block/ll_rw_blk.ci = blksize_size[major][MINOR(bh[0]->b_dev)];
bh467drivers/block/ll_rw_blk.cif (bh[i] && bh[i]->b_size != correct_size) {
bh470drivers/block/ll_rw_blk.ckdevname(bh[0]->b_dev),
bh471drivers/block/ll_rw_blk.ccorrect_size, bh[i]->b_size);
bh476drivers/block/ll_rw_blk.cbh[i]->b_rdev = bh[i]->b_dev;
bh477drivers/block/ll_rw_blk.cbh[i]->b_rsector=bh[i]->b_blocknr*(bh[i]->b_size >> 9);
bh480drivers/block/ll_rw_blk.cmd_map (MINOR(bh[i]->b_dev), &bh[i]->b_rdev,
bh481drivers/block/ll_rw_blk.c&bh[i]->b_rsector, bh[i]->b_size >> 9))
bh486drivers/block/ll_rw_blk.cif ((rw == WRITE || rw == WRITEA) && is_read_only(bh[0]->b_dev)) {
bh488drivers/block/ll_rw_blk.ckdevname(bh[0]->b_dev));
bh493drivers/block/ll_rw_blk.cif (bh[i]) {
bh494drivers/block/ll_rw_blk.cset_bit(BH_Req, &bh[i]->b_state);
bh496drivers/block/ll_rw_blk.cmake_request(MAJOR(bh[i]->b_rdev), rw, bh[i]);
bh503drivers/block/ll_rw_blk.cif (bh[i]) {
bh504drivers/block/ll_rw_blk.cclear_bit(BH_Dirty, &bh[i]->b_state);
bh505drivers/block/ll_rw_blk.cclear_bit(BH_Uptodate, &bh[i]->b_state);
bh571drivers/block/ll_rw_blk.creq[j]->bh = NULL;
bh153drivers/block/loop.cstruct buffer_head *bh;
bh202drivers/block/loop.cbh = getblk(lo->lo_device, real_block, blksize);
bh203drivers/block/loop.cif (!bh) {
bh209drivers/block/loop.cif (!buffer_uptodate(bh) && ((CURRENT->cmd == READ) ||
bh211drivers/block/loop.cll_rw_block(READ, 1, &bh);
bh212drivers/block/loop.cwait_on_buffer(bh);
bh213drivers/block/loop.cif (!buffer_uptodate(bh)) {
bh214drivers/block/loop.cbrelse(bh);
bh222drivers/block/loop.cif ((lo->transfer)(lo, CURRENT->cmd, bh->b_data + offset,
bh225drivers/block/loop.cbrelse(bh);
bh229drivers/block/loop.cmark_buffer_dirty(bh, 1);
bh230drivers/block/loop.cbrelse(bh);
bh140drivers/block/rd.cset_bit(BH_Protected, &CURRENT->bh->b_state);
bh182drivers/block/triton.cstruct buffer_head *bh = rq->bh;
bh194drivers/block/triton.cif (bh == NULL) {  /* paging and tape requests have (rq->bh == NULL) */
bh204drivers/block/triton.caddr = virt_to_bus (bh->b_data);
bh205drivers/block/triton.csize = bh->b_size;
bh206drivers/block/triton.cwhile ((bh = bh->b_reqnext) != NULL) {
bh207drivers/block/triton.cif ((addr + size) != virt_to_bus (bh->b_data))
bh209drivers/block/triton.csize += bh->b_size;
bh231drivers/block/triton.c} while (bh != NULL);
bh1006drivers/cdrom/aztcd.cif (CURRENT->bh) {
bh1007drivers/cdrom/aztcd.cif (!buffer_locked(CURRENT->bh))
bh1551drivers/cdrom/cdu31a.cif (CURRENT->bh)
bh1553drivers/cdrom/cdu31a.cif (!buffer_locked(CURRENT->bh))
bh487drivers/cdrom/cm206.cstats(bh);
bh661drivers/cdrom/mcd.cif (CURRENT->bh) {
bh662drivers/cdrom/mcd.cif (!buffer_locked(CURRENT->bh))
bh1359drivers/cdrom/optcd.cif (CURRENT->bh) {
bh1360drivers/cdrom/optcd.cif (!buffer_locked(CURRENT->bh))
bh1277drivers/cdrom/sjcd.cif( CURRENT->bh && !buffer_locked(CURRENT->bh) )
bh44drivers/isdn/teles/buffers.cstruct BufHeader *bh = NULL, *prev, *first;
bh69drivers/isdn/teles/buffers.cbh = (struct BufHeader *) bptr;
bh71drivers/isdn/teles/buffers.cbh->magic = 020167;
bh73drivers/isdn/teles/buffers.cbh->next = prev;
bh74drivers/isdn/teles/buffers.cprev = bh;
bh75drivers/isdn/teles/buffers.cbh->bp = bp;
bh82drivers/isdn/teles/buffers.cbp->freelist = bh;
bh107drivers/isdn/teles/buffers.cBufPoolGet(struct BufHeader **bh,
bh125drivers/isdn/teles/buffers.c*bh = bp->freelist;
bh127drivers/isdn/teles/buffers.c(*bh)->heldby = heldby;
bh128drivers/isdn/teles/buffers.c(*bh)->where = where;
bh139drivers/isdn/teles/buffers.c*bh = NULL;
bh148drivers/isdn/teles/buffers.cBufPoolRelease(struct BufHeader *bh)
bh154drivers/isdn/teles/buffers.cif (bh->magic != 020167) {
bh161drivers/isdn/teles/buffers.cbp = bh->bp;
bh172drivers/isdn/teles/buffers.cbh->next = bp->freelist;
bh173drivers/isdn/teles/buffers.cbp->freelist = bh;
bh179drivers/isdn/teles/buffers.cstruct BufHeader *bh)
bh186drivers/isdn/teles/buffers.cbq->head = bh;
bh188drivers/isdn/teles/buffers.cbq->tail->next = bh;
bh189drivers/isdn/teles/buffers.cbq->tail = bh;
bh190drivers/isdn/teles/buffers.cbh->next = NULL;
bh196drivers/isdn/teles/buffers.cstruct BufHeader *bh)
bh202drivers/isdn/teles/buffers.cbh->next = bq->head;
bh203drivers/isdn/teles/buffers.cbq->head = bh;
bh205drivers/isdn/teles/buffers.cbq->tail = bh;
bh210drivers/isdn/teles/buffers.cBufQueueUnlink(struct BufHeader **bh, struct BufQueue *bq)
bh220drivers/isdn/teles/buffers.c*bh = bq->head;
bh221drivers/isdn/teles/buffers.cbq->head = (*bh)->next;
bh243drivers/isdn/teles/buffers.cstruct BufHeader *bh;
bh246drivers/isdn/teles/buffers.cBufQueueUnlink(&bh, bq);
bh247drivers/isdn/teles/buffers.cBufPoolRelease(bh);
bh255drivers/isdn/teles/buffers.cstruct BufHeader *bh;
bh257drivers/isdn/teles/buffers.cbh = bq->head;
bh258drivers/isdn/teles/buffers.cwhile (bh) {
bh260drivers/isdn/teles/buffers.cbh = bh->next;
bh366drivers/isdn/teles/teles.hint             BufPoolGet(struct BufHeader **bh,
bh368drivers/isdn/teles/teles.hvoid            BufPoolRelease(struct BufHeader *bh);
bh370drivers/isdn/teles/teles.hstruct BufHeader *bh);
bh371drivers/isdn/teles/teles.hint             BufQueueUnlink(struct BufHeader **bh, struct BufQueue *bq);
bh378drivers/isdn/teles/teles.hstruct BufHeader *bh);
bh885drivers/scsi/scsi.cstruct buffer_head * bh, *bhp;
bh938drivers/scsi/scsi.cbhp = bh = req->bh;
bh939drivers/scsi/scsi.cif(!tablesize) bh = NULL;
bh944drivers/scsi/scsi.cwhile(req->nr_sectors && bh){
bh946drivers/scsi/scsi.cif(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
bh947drivers/scsi/scsi.creq->nr_sectors -= bh->b_size >> 9;
bh948drivers/scsi/scsi.creq->sector += bh->b_size >> 9;
bh950drivers/scsi/scsi.cbh = bhp;
bh952drivers/scsi/scsi.cif(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
bh953drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
bh954drivers/scsi/scsi.creq->bh = bh->b_reqnext; /* Divide request */
bh955drivers/scsi/scsi.cbh->b_reqnext = NULL;
bh956drivers/scsi/scsi.cbh = req->bh;
bh960drivers/scsi/scsi.creq->current_nr_sectors = bh->b_size >> 9;
bh961drivers/scsi/scsi.creq->buffer = bh->b_data;
bh1006drivers/scsi/scsi.cstruct buffer_head * bh, *bhp;
bh1104drivers/scsi/scsi.cbhp = bh = req->bh;
bh1105drivers/scsi/scsi.cif(!tablesize) bh = NULL;
bh1110drivers/scsi/scsi.cwhile(req->nr_sectors && bh){
bh1112drivers/scsi/scsi.cif(!bhp || !CONTIGUOUS_BUFFERS(bh,bhp)) tablesize--;
bh1113drivers/scsi/scsi.creq->nr_sectors -= bh->b_size >> 9;
bh1114drivers/scsi/scsi.creq->sector += bh->b_size >> 9;
bh1116drivers/scsi/scsi.cbh = bhp;
bh1118drivers/scsi/scsi.cif(req->nr_sectors && bh && bh->b_reqnext){/* Any leftovers? */
bh1119drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
bh1120drivers/scsi/scsi.creq->bh = bh->b_reqnext; /* Divide request */
bh1121drivers/scsi/scsi.cbh->b_reqnext = NULL;
bh1122drivers/scsi/scsi.cbh = req->bh;
bh1125drivers/scsi/scsi.creq->current_nr_sectors = bh->b_size >> 9;
bh1126drivers/scsi/scsi.creq->buffer = bh->b_data;
bh494drivers/scsi/scsi.hstruct buffer_head * bh;
bh504drivers/scsi/scsi.hif ((bh = req->bh) != NULL) {
bh505drivers/scsi/scsi.hreq->bh = bh->b_reqnext;
bh506drivers/scsi/scsi.hreq->nr_sectors -= bh->b_size >> 9;
bh507drivers/scsi/scsi.hreq->sector += bh->b_size >> 9;
bh508drivers/scsi/scsi.hbh->b_reqnext = NULL;
bh509drivers/scsi/scsi.hmark_buffer_uptodate(bh, uptodate);
bh510drivers/scsi/scsi.hunlock_buffer(bh);
bh511drivers/scsi/scsi.hsectors -= bh->b_size >> 9;
bh512drivers/scsi/scsi.hif ((bh = req->bh) != NULL) {
bh513drivers/scsi/scsi.hreq->current_nr_sectors = bh->b_size >> 9;
bh520drivers/scsi/scsi.h} while(sectors && bh);
bh521drivers/scsi/scsi.hif (req->bh){
bh522drivers/scsi/scsi.hreq->buffer = bh->b_data;
bh557drivers/scsi/scsi.hif (CURRENT->bh) {                                \
bh558drivers/scsi/scsi.hif (!buffer_locked(CURRENT->bh))              \
bh85drivers/scsi/scsi_debug.cif (bh){                            \
bh86drivers/scsi/scsi_debug.cif (bh->b_size != 1024) panic ("Wrong bh size");    \
bh87drivers/scsi/scsi_debug.cif ((bh->b_blocknr << 1) + start != block)          \
bh88drivers/scsi/scsi_debug.c{   printk("Wrong bh block# %d %d ",bh->b_blocknr, block);  \
bh91drivers/scsi/scsi_debug.cif (bh->b_dev != SCpnt->request.rq_dev)  \
bh103drivers/scsi/scsi_debug.cif (SCpnt->request.bh){                         \
bh104drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_size != 1024) panic ("Wrong bh size"); \
bh105drivers/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
bh106drivers/scsi/scsi_debug.c{   printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
bh109drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_dev != SCpnt->request.rq_dev) \
bh178drivers/scsi/scsi_debug.cstruct buffer_head * bh = NULL;
bh291drivers/scsi/scsi_debug.cbh = SCpnt->request.bh;
bh353drivers/scsi/scsi_debug.cmemcpy(buff+128, bh, sizeof(struct buffer_head));
bh356drivers/scsi/scsi_debug.cbh = bh->b_reqnext;
bh359drivers/scsi/scsi_debug.cif(!bh) panic("Too few blocks for linked request.");
bh371drivers/scsi/scsi_debug.cif(bh) scsi_dump(SCpnt, 0);
bh29drivers/scsi/scsicam.cstatic int partsize(struct buffer_head *bh, unsigned long capacity,
bh49drivers/scsi/scsicam.cstruct buffer_head *bh;
bh53drivers/scsi/scsicam.cif (!(bh = bread(MKDEV(MAJOR(dev), MINOR(dev)&~0xf), 0, 1024)))
bh59drivers/scsi/scsicam.cret_code = partsize (bh, (unsigned long) size, (unsigned int *) ip + 2, 
bh61drivers/scsi/scsicam.cbrelse (bh);
bh85drivers/scsi/scsicam.cstatic int partsize(struct buffer_head *bh, unsigned long capacity,
bh93drivers/scsi/scsicam.cif (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
bh95drivers/scsi/scsicam.c(0x1BE + bh->b_data), i = 0; i < 4; ++i, ++p) {
bh279drivers/scsi/sd.cif (!SCpnt->request.bh)
bh512drivers/scsi/sd.cstruct buffer_head * bh, *bhp;
bh606drivers/scsi/sd.cif (contiguous && SCpnt->request.bh &&
bh607drivers/scsi/sd.c((long) SCpnt->request.bh->b_data) 
bh610drivers/scsi/sd.cif(((long) SCpnt->request.bh->b_data) > ISA_DMA_THRESHOLD)
bh615drivers/scsi/sd.cif(contiguous && SCpnt->request.bh && SCpnt->request.bh->b_reqnext)
bh616drivers/scsi/sd.cfor(bh = SCpnt->request.bh, bhp = bh->b_reqnext; bhp; bh = bhp, 
bh618drivers/scsi/sd.cif(!CONTIGUOUS_BUFFERS(bh,bhp)) { 
bh624drivers/scsi/sd.cif (!SCpnt->request.bh || contiguous) {
bh657drivers/scsi/sd.cbh = SCpnt->request.bh;
bh662drivers/scsi/sd.cwhile(bh) {
bh663drivers/scsi/sd.cif ((this_count + (bh->b_size >> 9)) > this_count_max) break;
bh664drivers/scsi/sd.cif(!bhp || !CONTIGUOUS_BUFFERS(bhp,bh) ||
bh667drivers/scsi/sd.c((unsigned long) bh->b_data-1) == ISA_DMA_THRESHOLD)) {
bh671drivers/scsi/sd.cthis_count += (bh->b_size >> 9);
bh672drivers/scsi/sd.cbhp = bh;
bh673drivers/scsi/sd.cbh = bh->b_reqnext;
bh677drivers/scsi/sd.c((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
bh699drivers/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
bh700drivers/scsi/sd.ccount < SCpnt->use_sg && bh; 
bh701drivers/scsi/sd.ccount++, bh = bhp) {
bh703drivers/scsi/sd.cbhp = bh->b_reqnext;
bh705drivers/scsi/sd.cif(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
bh706drivers/scsi/sd.csgpnt[count].length += bh->b_size;
bh707drivers/scsi/sd.ccounted += bh->b_size >> 9;
bh743drivers/scsi/sd.cthis_count = counted -= bh->b_size >> 9;
bh753drivers/scsi/sd.cif(bhp && CONTIGUOUS_BUFFERS(bh,bhp) 
bh790drivers/scsi/sd.cbh = SCpnt->request.bh;
bh795drivers/scsi/sd.cwhile(bh){
bh796drivers/scsi/sd.cprintk("[%p %lx] ", bh->b_data, bh->b_size);
bh797drivers/scsi/sd.cbh = bh->b_reqnext;
bh156drivers/scsi/sr.cprintk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
bh174drivers/scsi/sr.cSCpnt->request.bh &&
bh175drivers/scsi/sr.cSCpnt->request.bh->b_reqnext &&
bh176drivers/scsi/sr.cSCpnt->request.bh->b_reqnext->b_size == 1024) {
bh177drivers/scsi/sr.cmemcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
bh205drivers/scsi/sr.cprintk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, 
bh211drivers/scsi/sr.cif (!SCpnt->request.bh)
bh725drivers/scsi/sr.cstruct buffer_head * bh;
bh728drivers/scsi/sr.cbh = SCpnt->request.bh;
bh736drivers/scsi/sr.cwhile(bh && count < SCpnt->host->sg_tablesize) {
bh737drivers/scsi/sr.cif ((this_count + (bh->b_size >> 9)) > this_count_max) break;
bh738drivers/scsi/sr.cthis_count += (bh->b_size >> 9);
bh740drivers/scsi/sr.cbh = bh->b_reqnext;
bh766drivers/scsi/sr.cbh = SCpnt->request.bh;
bh775drivers/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
bh776drivers/scsi/sr.ccount++, bh = bh->b_reqnext) {
bh777drivers/scsi/sr.cif (bh) { /* Need a placeholder at the end of the record? */
bh778drivers/scsi/sr.csgpnt[count].address = bh->b_data;
bh779drivers/scsi/sr.csgpnt[count].length = bh->b_size;
bh833drivers/scsi/sr.cif (!SCpnt->request.bh)    
bh836drivers/scsi/sr.cthis_count = (SCpnt->request.bh->b_size >> 9);
bh75fs/affs/file.cstruct buffer_head *bh;
bh93fs/affs/file.cbh = affs_pread (inode, key, &fh_data);
bh94fs/affs/file.cif (!bh)
bh103fs/affs/file.cbrelse (bh);
bh107fs/affs/file.cbrelse (bh);
bh126fs/affs/file.cstruct buffer_head *bh;
bh152fs/affs/file.cbh = affs_pread (inode, sector, &data);
bh153fs/affs/file.cif (!bh)
bh159fs/affs/file.cbrelse (bh);
bh134fs/affs/inode.cstruct buffer_head *bh;
bh187fs/affs/inode.cbh = affs_sread (dev, root_block, &root_data);
bh188fs/affs/inode.cif (!bh) {
bh220fs/affs/inode.cbrelse(bh);
bh239fs/affs/inode.cbrelse (bh);
bh274fs/affs/inode.cstruct buffer_head *bh;
bh291fs/affs/inode.cif (!(bh=affs_pread (inode, block, &fh_data))) {
bh344fs/affs/inode.cbrelse(bh);
bh391fs/affs/inode.cbrelse(bh);
bh426fs/affs/inode.cvoid leak_check_brelse(struct buffer_head * bh){
bh428fs/affs/inode.creturn brelse(bh);
bh75fs/affs/namei.cstruct buffer_head *bh;
bh81fs/affs/namei.cbh = affs_pread (dir, dir->i_ino, &dir_data);
bh82fs/affs/namei.cif (!bh)
bh87fs/affs/namei.creturn bh;
bh91fs/affs/namei.creturn bh;
bh100fs/affs/namei.cbrelse (bh);
bh103fs/affs/namei.cbh = affs_pread (dir, key, &dir_data);
bh104fs/affs/namei.cif (!bh)
bh115fs/affs/namei.creturn bh;
bh122fs/affs/namei.cstruct buffer_head *bh;
bh136fs/affs/namei.cif (!(bh = affs_find_entry(dir, name, len, &ino))) {
bh140fs/affs/namei.cbrelse(bh);
bh168fs/affs/namei.cif (!(bh = affs_find_entry(dir,name,len, &ino, &ino_back))) {
bh172fs/affs/namei.cbrelse(bh);
bh55fs/affs/symlink.cstruct buffer_head *bh;
bh78fs/affs/symlink.cif (!(bh = affs_pread(inode,inode->i_ino,(void **)&sy_data))) {
bh88fs/affs/symlink.cbrelse(bh);
bh147fs/affs/symlink.cstruct buffer_head *bh;
bh158fs/affs/symlink.cif (!(bh = affs_pread(inode,inode->i_ino,(void **)&sy_data))) {
bh176fs/affs/symlink.cbrelse(bh);
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 && !buffer_uptodate(bh)) {
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.cmark_buffer_uptodate(bh, 1);
bh127fs/block_dev.cmark_buffer_dirty(bh, 0);
bh129fs/block_dev.cbufferlist[buffercount++] = bh;
bh131fs/block_dev.cbrelse(bh);
bh126fs/buffer.cvoid __wait_on_buffer(struct buffer_head * bh)
bh130fs/buffer.cbh->b_count++;
bh131fs/buffer.cadd_wait_queue(&bh->b_wait, &wait);
bh135fs/buffer.cif (buffer_locked(bh)) {
bh139fs/buffer.cremove_wait_queue(&bh->b_wait, &wait);
bh140fs/buffer.cbh->b_count--;
bh158fs/buffer.cstruct buffer_head * bh, *next;
bh173fs/buffer.cbh = lru_list[nlist];
bh174fs/buffer.cif(!bh) continue;
bh175fs/buffer.cfor (i = nr_buffers_type[nlist]*2 ; i-- > 0 ; bh = next) {
bh176fs/buffer.cif(bh->b_list != nlist) goto repeat1;
bh177fs/buffer.cnext = bh->b_next_free;
bh179fs/buffer.cif (dev && bh->b_dev != dev)
bh181fs/buffer.cif (buffer_locked(bh))
bh189fs/buffer.cwait_on_buffer (bh);
bh194fs/buffer.cif (wait && buffer_req(bh) && !buffer_locked(bh) &&
bh195fs/buffer.c!buffer_dirty(bh) && !buffer_uptodate(bh)) {
bh201fs/buffer.cif (!buffer_dirty(bh) || pass>=2)
bh204fs/buffer.cif (buffer_locked(bh))
bh206fs/buffer.cbh->b_count++;
bh207fs/buffer.cbh->b_flushtime = 0;
bh208fs/buffer.cll_rw_block(WRITE, 1, &bh);
bh212fs/buffer.ckdevname(bh->b_dev), bh->b_blocknr);
bh215fs/buffer.cbh->b_count--;
bh293fs/buffer.cstruct buffer_head * bh;
bh296fs/buffer.cbh = lru_list[nlist];
bh297fs/buffer.cfor (i = nr_buffers_type[nlist]*2 ; --i > 0 ; bh = bh->b_next_free) {
bh298fs/buffer.cif (bh->b_dev != dev)
bh300fs/buffer.cwait_on_buffer(bh);
bh301fs/buffer.cif (bh->b_dev != dev)
bh303fs/buffer.cif (bh->b_count)
bh305fs/buffer.cbh->b_flushtime = 0;
bh306fs/buffer.cclear_bit(BH_Protected, &bh->b_state);
bh307fs/buffer.cclear_bit(BH_Uptodate, &bh->b_state);
bh308fs/buffer.cclear_bit(BH_Dirty, &bh->b_state);
bh309fs/buffer.cclear_bit(BH_Req, &bh->b_state);
bh317fs/buffer.cstatic inline void remove_from_hash_queue(struct buffer_head * bh)
bh319fs/buffer.cif (bh->b_next)
bh320fs/buffer.cbh->b_next->b_prev = bh->b_prev;
bh321fs/buffer.cif (bh->b_prev)
bh322fs/buffer.cbh->b_prev->b_next = bh->b_next;
bh323fs/buffer.cif (hash(bh->b_dev,bh->b_blocknr) == bh)
bh324fs/buffer.chash(bh->b_dev,bh->b_blocknr) = bh->b_next;
bh325fs/buffer.cbh->b_next = bh->b_prev = NULL;
bh328fs/buffer.cstatic inline void remove_from_lru_list(struct buffer_head * bh)
bh330fs/buffer.cif (!(bh->b_prev_free) || !(bh->b_next_free))
bh332fs/buffer.cif (bh->b_dev == B_FREE)
bh334fs/buffer.cbh->b_prev_free->b_next_free = bh->b_next_free;
bh335fs/buffer.cbh->b_next_free->b_prev_free = bh->b_prev_free;
bh337fs/buffer.cif (lru_list[bh->b_list] == bh)
bh338fs/buffer.clru_list[bh->b_list] = bh->b_next_free;
bh339fs/buffer.cif (lru_list[bh->b_list] == bh)
bh340fs/buffer.clru_list[bh->b_list] = NULL;
bh341fs/buffer.cif (next_to_age[bh->b_list] == bh)
bh342fs/buffer.cnext_to_age[bh->b_list] = bh->b_next_free;
bh343fs/buffer.cif (next_to_age[bh->b_list] == bh)
bh344fs/buffer.cnext_to_age[bh->b_list] = NULL;
bh346fs/buffer.cbh->b_next_free = bh->b_prev_free = NULL;
bh349fs/buffer.cstatic inline void remove_from_free_list(struct buffer_head * bh)
bh351fs/buffer.cint isize = BUFSIZE_INDEX(bh->b_size);
bh352fs/buffer.cif (!(bh->b_prev_free) || !(bh->b_next_free))
bh354fs/buffer.cif(bh->b_dev != B_FREE)
bh359fs/buffer.cif(bh->b_next_free == bh)
bh362fs/buffer.cbh->b_prev_free->b_next_free = bh->b_next_free;
bh363fs/buffer.cbh->b_next_free->b_prev_free = bh->b_prev_free;
bh364fs/buffer.cif (free_list[isize] == bh)
bh365fs/buffer.cfree_list[isize] = bh->b_next_free;
bh367fs/buffer.cbh->b_next_free = bh->b_prev_free = NULL;
bh370fs/buffer.cstatic inline void remove_from_queues(struct buffer_head * bh)
bh372fs/buffer.cif(bh->b_dev == B_FREE) {
bh373fs/buffer.cremove_from_free_list(bh); /* Free list entries should not be
bh377fs/buffer.cnr_buffers_type[bh->b_list]--;
bh378fs/buffer.cnr_buffers_st[BUFSIZE_INDEX(bh->b_size)][bh->b_list]--;
bh379fs/buffer.cremove_from_hash_queue(bh);
bh380fs/buffer.cremove_from_lru_list(bh);
bh383fs/buffer.cstatic inline void put_last_lru(struct buffer_head * bh)
bh385fs/buffer.cif (!bh)
bh387fs/buffer.cif (bh == lru_list[bh->b_list]) {
bh388fs/buffer.clru_list[bh->b_list] = bh->b_next_free;
bh389fs/buffer.cif (next_to_age[bh->b_list] == bh)
bh390fs/buffer.cnext_to_age[bh->b_list] = bh->b_next_free;
bh393fs/buffer.cif(bh->b_dev == B_FREE)
bh395fs/buffer.cremove_from_lru_list(bh);
bh398fs/buffer.cif(!lru_list[bh->b_list]) {
bh399fs/buffer.clru_list[bh->b_list] = bh;
bh400fs/buffer.clru_list[bh->b_list]->b_prev_free = bh;
bh402fs/buffer.cif (!next_to_age[bh->b_list])
bh403fs/buffer.cnext_to_age[bh->b_list] = bh;
bh405fs/buffer.cbh->b_next_free = lru_list[bh->b_list];
bh406fs/buffer.cbh->b_prev_free = lru_list[bh->b_list]->b_prev_free;
bh407fs/buffer.clru_list[bh->b_list]->b_prev_free->b_next_free = bh;
bh408fs/buffer.clru_list[bh->b_list]->b_prev_free = bh;
bh411fs/buffer.cstatic inline void put_last_free(struct buffer_head * bh)
bh414fs/buffer.cif (!bh)
bh417fs/buffer.cisize = BUFSIZE_INDEX(bh->b_size);  
bh418fs/buffer.cbh->b_dev = B_FREE;  /* So it is obvious we are on the free list */
bh421fs/buffer.cfree_list[isize] = bh;
bh422fs/buffer.cbh->b_prev_free = bh;
bh426fs/buffer.cbh->b_next_free = free_list[isize];
bh427fs/buffer.cbh->b_prev_free = free_list[isize]->b_prev_free;
bh428fs/buffer.cfree_list[isize]->b_prev_free->b_next_free = bh;
bh429fs/buffer.cfree_list[isize]->b_prev_free = bh;
bh432fs/buffer.cstatic inline void insert_into_queues(struct buffer_head * bh)
bh435fs/buffer.cif(bh->b_dev == B_FREE) {
bh436fs/buffer.cput_last_free(bh);
bh439fs/buffer.cif(!lru_list[bh->b_list]) {
bh440fs/buffer.clru_list[bh->b_list] = bh;
bh441fs/buffer.cbh->b_prev_free = bh;
bh443fs/buffer.cif (!next_to_age[bh->b_list])
bh444fs/buffer.cnext_to_age[bh->b_list] = bh;
bh445fs/buffer.cif (bh->b_next_free) panic("VFS: buffer LRU pointers corrupted");
bh446fs/buffer.cbh->b_next_free = lru_list[bh->b_list];
bh447fs/buffer.cbh->b_prev_free = lru_list[bh->b_list]->b_prev_free;
bh448fs/buffer.clru_list[bh->b_list]->b_prev_free->b_next_free = bh;
bh449fs/buffer.clru_list[bh->b_list]->b_prev_free = bh;
bh450fs/buffer.cnr_buffers_type[bh->b_list]++;
bh451fs/buffer.cnr_buffers_st[BUFSIZE_INDEX(bh->b_size)][bh->b_list]++;
bh453fs/buffer.cbh->b_prev = NULL;
bh454fs/buffer.cbh->b_next = NULL;
bh455fs/buffer.cif (!(bh->b_dev))
bh457fs/buffer.cbh->b_next = hash(bh->b_dev,bh->b_blocknr);
bh458fs/buffer.chash(bh->b_dev,bh->b_blocknr) = bh;
bh459fs/buffer.cif (bh->b_next)
bh460fs/buffer.cbh->b_next->b_prev = bh;
bh488fs/buffer.cstruct buffer_head * bh;
bh491fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
bh493fs/buffer.cbh->b_count++;
bh494fs/buffer.cwait_on_buffer(bh);
bh495fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block
bh496fs/buffer.c&& bh->b_size == size)
bh497fs/buffer.creturn bh;
bh498fs/buffer.cbh->b_count--;
bh505fs/buffer.cstruct buffer_head * bh, *bhnext;
bh531fs/buffer.cbh = lru_list[nlist];
bh532fs/buffer.cfor (i = nr_buffers_type[nlist]*2 ; --i > 0 ; bh = bhnext) {
bh533fs/buffer.cif(!bh) break;
bh534fs/buffer.cbhnext = bh->b_next_free; 
bh535fs/buffer.cif (bh->b_dev != dev)
bh537fs/buffer.cif (bh->b_size == size)
bh540fs/buffer.cwait_on_buffer(bh);
bh541fs/buffer.cif (bh->b_dev == dev && bh->b_size != size) {
bh542fs/buffer.cclear_bit(BH_Dirty, &bh->b_state);
bh543fs/buffer.cclear_bit(BH_Uptodate, &bh->b_state);
bh544fs/buffer.cclear_bit(BH_Req, &bh->b_state);
bh545fs/buffer.cbh->b_flushtime = 0;
bh547fs/buffer.cremove_from_hash_queue(bh);
bh552fs/buffer.c#define BADNESS(bh) (buffer_dirty(bh) || buffer_locked(bh))
bh556fs/buffer.cstruct buffer_head * bh, * tmp;
bh610fs/buffer.cfor (bh = lru_list[i]; buffers[i] > 0; bh = tmp, buffers[i]--)
bh613fs/buffer.ctmp = bh->b_next_free;
bh614fs/buffer.cif (!bh) break;
bh616fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1 ||
bh617fs/buffer.cbuffer_dirty(bh)) {
bh618fs/buffer.crefile_buffer(bh);
bh622fs/buffer.cif (bh->b_count || buffer_protected(bh) || bh->b_size != size)
bh629fs/buffer.cif (buffer_locked(bh) && (i == BUF_LOCKED || i == BUF_LOCKED1)) {
bh634fs/buffer.cif (BADNESS(bh)) continue;
bh638fs/buffer.celse candidate[i] = bh;
bh659fs/buffer.cbh = candidate[i];
bh660fs/buffer.ccandidate[i] = bh->b_next_free;
bh661fs/buffer.cif(candidate[i] == bh) candidate[i] = NULL;  /* Got last one */
bh662fs/buffer.cif (bh->b_count || bh->b_size != size)
bh664fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1)
bh666fs/buffer.cif (buffer_protected(bh))
bh668fs/buffer.cif (BADNESS(bh)) panic("Buffer in candidate list with BADNESS != 0\n");
bh670fs/buffer.cif(bh->b_dev == B_FREE)
bh672fs/buffer.cremove_from_queues(bh);
bh673fs/buffer.cbh->b_dev = B_FREE;
bh674fs/buffer.cput_last_free(bh);
bh675fs/buffer.cneeded -= bh->b_size;
bh685fs/buffer.cfor (bh = candidate[i]; buffers[i] > 0; bh = tmp, buffers[i]--) {
bh687fs/buffer.ctmp = bh->b_next_free;
bh688fs/buffer.cif (!bh) break;
bh690fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1 ||
bh691fs/buffer.cbuffer_dirty(bh)) {
bh692fs/buffer.crefile_buffer(bh);
bh696fs/buffer.cif (bh->b_count || buffer_protected(bh) || bh->b_size != size)
bh703fs/buffer.cif (buffer_locked(bh) && (i == BUF_LOCKED || i == BUF_LOCKED1)) {
bh708fs/buffer.cif (BADNESS(bh)) continue;
bh712fs/buffer.celse candidate[i] = bh;
bh744fs/buffer.cstruct buffer_head * bh;
bh754fs/buffer.cbh = get_hash_table(dev, block, size);
bh755fs/buffer.cif (bh) {
bh756fs/buffer.cif (!buffer_dirty(bh)) {
bh757fs/buffer.cif (buffer_uptodate(bh))
bh758fs/buffer.cput_last_lru(bh);
bh759fs/buffer.cbh->b_flushtime = 0;
bh761fs/buffer.cset_bit(BH_Touched, &bh->b_state);
bh762fs/buffer.creturn bh;
bh770fs/buffer.cbh = free_list[isize];
bh771fs/buffer.cremove_from_free_list(bh);
bh775fs/buffer.cbh->b_count=1;
bh776fs/buffer.cbh->b_flushtime=0;
bh777fs/buffer.cbh->b_state=(1<<BH_Touched);
bh778fs/buffer.cbh->b_dev=dev;
bh779fs/buffer.cbh->b_blocknr=block;
bh780fs/buffer.cinsert_into_queues(bh);
bh781fs/buffer.creturn bh;
bh879fs/buffer.cstruct buffer_head * bh;
bh881fs/buffer.cif (!(bh = getblk(dev, block, size))) {
bh886fs/buffer.cif (buffer_uptodate(bh))
bh887fs/buffer.creturn bh;
bh888fs/buffer.cll_rw_block(READ, 1, &bh);
bh889fs/buffer.cwait_on_buffer(bh);
bh890fs/buffer.cif (buffer_uptodate(bh))
bh891fs/buffer.creturn bh;
bh892fs/buffer.cbrelse(bh);
bh909fs/buffer.cstruct buffer_head * bh;
bh916fs/buffer.cif (block < 0 || !(bh = getblk(dev,block,bufsize)))
bh919fs/buffer.cindex = BUFSIZE_INDEX(bh->b_size);
bh921fs/buffer.cif (buffer_uptodate(bh))
bh922fs/buffer.creturn bh;
bh931fs/buffer.cbhlist[0] = bh;
bh934fs/buffer.cbh = getblk(dev,block+i,bufsize);
bh935fs/buffer.cif (buffer_uptodate(bh)) {
bh936fs/buffer.cbrelse(bh);
bh939fs/buffer.cbhlist[j++] = bh;
bh949fs/buffer.cbh = bhlist[0];
bh950fs/buffer.cwait_on_buffer(bh);
bh951fs/buffer.cif (buffer_uptodate(bh))
bh952fs/buffer.creturn bh;
bh953fs/buffer.cbrelse(bh);
bh960fs/buffer.cstatic void put_unused_buffer_head(struct buffer_head * bh)
bh964fs/buffer.cwait = ((volatile struct buffer_head *) bh)->b_wait;
bh965fs/buffer.cmemset(bh,0,sizeof(*bh));
bh966fs/buffer.c((volatile struct buffer_head *) bh)->b_wait = wait;
bh967fs/buffer.cbh->b_next_free = unused_list;
bh968fs/buffer.cunused_list = bh;
bh975fs/buffer.cstruct buffer_head * bh;
bh986fs/buffer.cbh = (struct buffer_head *) get_free_page(GFP_ATOMIC);
bh987fs/buffer.cif (bh)
bh999fs/buffer.cfor (nr_buffer_heads+=i=PAGE_SIZE/sizeof*bh ; i>0; i--) {
bh1000fs/buffer.cbh->b_next_free = unused_list;  /* only make link */
bh1001fs/buffer.cunused_list = bh++;
bh1021fs/buffer.cstruct buffer_head *bh;
bh1027fs/buffer.cbh = reuse_list;
bh1028fs/buffer.creuse_list = bh->b_next_free;
bh1030fs/buffer.cput_unused_buffer_head(bh);
bh1037fs/buffer.cstruct buffer_head * bh;
bh1043fs/buffer.cbh = unused_list;
bh1044fs/buffer.cunused_list = bh->b_next_free;
bh1045fs/buffer.cbh->b_next_free = NULL;
bh1046fs/buffer.cbh->b_data = NULL;
bh1047fs/buffer.cbh->b_size = 0;
bh1048fs/buffer.cbh->b_state = 0;
bh1049fs/buffer.creturn bh;
bh1060fs/buffer.cstruct buffer_head *bh, *head;
bh1066fs/buffer.cbh = get_unused_buffer_head();
bh1067fs/buffer.cif (!bh)
bh1069fs/buffer.cbh->b_this_page = head;
bh1070fs/buffer.chead = bh;
bh1071fs/buffer.cbh->b_data = (char *) (page+offset);
bh1072fs/buffer.cbh->b_size = size;
bh1073fs/buffer.cbh->b_dev = B_FREE;  /* Flag as unused */
bh1080fs/buffer.cbh = head;
bh1081fs/buffer.cwhile (bh) {
bh1082fs/buffer.chead = bh;
bh1083fs/buffer.cbh = bh->b_this_page;
bh1101fs/buffer.cstatic inline void free_async_buffers (struct buffer_head * bh)
bh1106fs/buffer.ctmp = bh;
bh1120fs/buffer.c} while (tmp != bh);
bh1131fs/buffer.cstruct buffer_head *bh, *prev, *next, *arr[MAX_BUF_PER_PAGE];
bh1144fs/buffer.cbh = create_buffers(address, size);
bh1145fs/buffer.cif (!bh) {
bh1151fs/buffer.cnext = bh;
bh1197fs/buffer.cprev->b_this_page = bh;
bh1207fs/buffer.cfree_async_buffers(bh);
bh1217fs/buffer.cvoid mark_buffer_uptodate(struct buffer_head * bh, int on)
bh1220fs/buffer.cstruct buffer_head *tmp = bh;
bh1222fs/buffer.cset_bit(BH_Uptodate, &bh->b_state);
bh1231fs/buffer.c} while (tmp && tmp != bh);
bh1233fs/buffer.cset_bit(PG_uptodate, &mem_map[MAP_NR(bh->b_data)].flags);
bh1235fs/buffer.cclear_bit(BH_Uptodate, &bh->b_state);
bh1241fs/buffer.cvoid unlock_buffer(struct buffer_head * bh)
bh1246fs/buffer.cclear_bit(BH_Lock, &bh->b_state);
bh1247fs/buffer.cwake_up(&bh->b_wait);
bh1249fs/buffer.cif (!test_bit(BH_FreeOnIO, &bh->b_state))
bh1252fs/buffer.cpage = mem_map + MAP_NR(bh->b_data);
bh1258fs/buffer.cif (bh->b_count != 1) {
bh1266fs/buffer.cbh->b_count--;
bh1267fs/buffer.cfor (tmp = bh; tmp=tmp->b_this_page, tmp!=bh; ) {
bh1274fs/buffer.cfree_async_buffers(bh);
bh1319fs/buffer.cstruct buffer_head *bh, *tmp;
bh1332fs/buffer.cbh = create_buffers(page, size);
bh1333fs/buffer.cif (!bh) {
bh1340fs/buffer.ctmp = bh;
bh1359fs/buffer.cfree_list[isize] = bh;
bh1360fs/buffer.cmem_map[MAP_NR(page)].buffers = bh;
bh1361fs/buffer.ctmp->b_this_page = bh;
bh1373fs/buffer.cint try_to_free_buffer(struct buffer_head * bh, struct buffer_head ** bhp,
bh1378fs/buffer.cint isize = BUFSIZE_INDEX(bh->b_size);
bh1380fs/buffer.c*bhp = bh;
bh1381fs/buffer.cpage = (unsigned long) bh->b_data;
bh1383fs/buffer.ctmp = bh;
bh1393fs/buffer.c} while (tmp != bh);
bh1394fs/buffer.ctmp = bh;
bh1408fs/buffer.c} while (tmp != bh);
bh1417fs/buffer.cstatic inline void age_buffer(struct buffer_head *bh)
bh1419fs/buffer.cstruct buffer_head *tmp = bh;
bh1429fs/buffer.cif (clear_bit(BH_Has_aged, &bh->b_state))
bh1436fs/buffer.c} while (tmp != bh);
bh1437fs/buffer.cclear_bit(BH_Has_aged, &bh->b_state);
bh1440fs/buffer.ctouch_page(mem_map + MAP_NR((unsigned long) bh->b_data));
bh1442fs/buffer.cage_page(mem_map + MAP_NR((unsigned long) bh->b_data));
bh1509fs/buffer.cstruct buffer_head *bh;
bh1522fs/buffer.cbh = free_list[isize];
bh1523fs/buffer.cif(!bh) continue;
bh1524fs/buffer.cfor (i=0 ; !i || bh != free_list[isize]; bh = bh->b_next_free, i++) {
bh1525fs/buffer.cif (bh->b_count || buffer_protected(bh) ||
bh1526fs/buffer.c!bh->b_this_page)
bh1528fs/buffer.cif (!age_of((unsigned long) bh->b_data) &&
bh1529fs/buffer.ctry_to_free_buffer(bh, &bh, 6))
bh1531fs/buffer.cif(!bh) break;
bh1545fs/buffer.cbh = next_to_age[nlist];
bh1546fs/buffer.cif (!bh)
bh1548fs/buffer.cnext_to_age[nlist] = bh->b_next_free;
bh1551fs/buffer.cage_buffer(bh);
bh1554fs/buffer.cif(bh->b_list != nlist) goto repeat1;
bh1555fs/buffer.cif (bh->b_count || buffer_protected(bh) ||
bh1556fs/buffer.c!bh->b_this_page)
bh1558fs/buffer.cif(size && bh->b_size != size) continue;
bh1559fs/buffer.cif (buffer_locked(bh))
bh1563fs/buffer.cwait_on_buffer(bh);
bh1564fs/buffer.cif (buffer_dirty(bh)) {
bh1565fs/buffer.cbh->b_count++;
bh1566fs/buffer.cbh->b_flushtime = 0;
bh1567fs/buffer.cll_rw_block(WRITEA, 1, &bh);
bh1568fs/buffer.cbh->b_count--;
bh1574fs/buffer.cif ((age_of((unsigned long) bh->b_data) >>
bh1577fs/buffer.cif (try_to_free_buffer(bh, &bh, 0))
bh1579fs/buffer.cif(!bh) break;
bh1590fs/buffer.cstruct buffer_head * bh;
bh1602fs/buffer.cbh = lru_list[nlist];
bh1603fs/buffer.cif(!bh) continue;
bh1606fs/buffer.cif (buffer_locked(bh))
bh1608fs/buffer.cif (buffer_protected(bh))
bh1610fs/buffer.cif (buffer_dirty(bh))
bh1612fs/buffer.cif (mem_map[MAP_NR(((unsigned long) bh->b_data))].count != 1)
bh1614fs/buffer.cif (bh->b_count)
bh1616fs/buffer.cbh = bh->b_next_free;
bh1617fs/buffer.c} while (bh != lru_list[nlist]);
bh1640fs/buffer.cstatic inline int try_to_reassign(struct buffer_head * bh, struct buffer_head ** bhp,
bh1646fs/buffer.c*bhp = bh;
bh1647fs/buffer.cpage = (unsigned long) bh->b_data;
bh1650fs/buffer.ctmp = bh;
bh1659fs/buffer.c} while (tmp != bh);
bh1660fs/buffer.ctmp = bh;
bh1666fs/buffer.cbh = tmp;
bh1676fs/buffer.c} while (tmp != bh);
bh1697fs/buffer.cstruct buffer_head *bh;
bh1707fs/buffer.cbh = free_list[isize];
bh1708fs/buffer.cif(bh)
bh1709fs/buffer.cfor (i=0 ; !i || bh != free_list[isize] ; bh = bh->b_next_free, i++) {
bh1710fs/buffer.cif (!bh->b_this_page)  continue;
bh1711fs/buffer.cif (try_to_reassign(bh, &bh, dev, starting_block))
bh1723fs/buffer.cstruct buffer_head * bh, * tmp, * arr[MAX_BUF_PER_PAGE];
bh1732fs/buffer.cbh = create_buffers(page, size);
bh1733fs/buffer.cif (!bh) {
bh1742fs/buffer.ctmp = bh;
bh1745fs/buffer.carr[nblock++] = bh;
bh1746fs/buffer.cbh->b_count = 1;
bh1747fs/buffer.cbh->b_flushtime = 0;
bh1748fs/buffer.cbh->b_state = 0;
bh1749fs/buffer.cbh->b_dev = dev;
bh1750fs/buffer.cbh->b_list = BUF_CLEAN;
bh1751fs/buffer.cbh->b_blocknr = block++;
bh1754fs/buffer.cinsert_into_queues(bh);
bh1755fs/buffer.cif (bh->b_this_page)
bh1756fs/buffer.cbh = bh->b_this_page;
bh1761fs/buffer.cmem_map[MAP_NR(page)].buffers = bh;
bh1762fs/buffer.cbh->b_this_page = tmp;
bh1767fs/buffer.cwhile ((tmp = bh) != NULL) {
bh1768fs/buffer.cbh = bh->b_this_page;
bh1873fs/buffer.cstruct buffer_head * bh, *next;
bh1888fs/buffer.cbh = lru_list[nlist];
bh1889fs/buffer.cif(bh) 
bh1890fs/buffer.cfor (i = nr_buffers_type[nlist]; i-- > 0; bh = next) {
bh1892fs/buffer.cif(bh->b_list != nlist) goto repeat;
bh1893fs/buffer.cnext = bh->b_next_free;
bh1900fs/buffer.cif (nlist == BUF_DIRTY && !buffer_dirty(bh) && !buffer_locked(bh))
bh1902fs/buffer.crefile_buffer(bh);
bh1906fs/buffer.cif (buffer_locked(bh) || !buffer_dirty(bh))
bh1909fs/buffer.cif(bh->b_flushtime > jiffies) continue;
bh1911fs/buffer.cbh->b_count++;
bh1912fs/buffer.cbh->b_flushtime = 0;
bh1916fs/buffer.cll_rw_block(WRITE, 1, &bh);
bh1917fs/buffer.cbh->b_count--;
bh1986fs/buffer.cstruct buffer_head * bh, *next;
bh2023fs/buffer.cbh = lru_list[nlist];
bh2024fs/buffer.cif(bh) 
bh2026fs/buffer.cbh = next) {
bh2028fs/buffer.cif(bh->b_list != nlist) goto repeat;
bh2029fs/buffer.cnext = bh->b_next_free;
bh2036fs/buffer.cif (nlist == BUF_DIRTY && !buffer_dirty(bh) && !buffer_locked(bh))
bh2038fs/buffer.crefile_buffer(bh);
bh2042fs/buffer.cif (buffer_locked(bh) || !buffer_dirty(bh))
bh2046fs/buffer.cbh->b_count++;
bh2048fs/buffer.cbh->b_flushtime = 0;
bh2049fs/buffer.cll_rw_block(WRITE, 1, &bh);
bh2053fs/buffer.cbh->b_count--;
bh72fs/ext/dir.cstruct buffer_head * bh;
bh82fs/ext/dir.cbh = ext_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
bh83fs/ext/dir.cif (!bh) {
bh88fs/ext/dir.cde = (struct ext_dir_entry *) (bh->b_data + i);
bh94fs/ext/dir.cde = (struct ext_dir_entry *) (offset + bh->b_data);
bh118fs/ext/dir.cbrelse(bh);
bh204fs/ext/file.cstruct buffer_head * bh;
bh225fs/ext/file.cbh = ext_getblk(inode,pos/BLOCK_SIZE,1);
bh226fs/ext/file.cif (!bh) {
bh234fs/ext/file.cif (c != BLOCK_SIZE && !buffer_uptodate(bh)) {
bh235fs/ext/file.cll_rw_block(READ, 1, &bh);
bh236fs/ext/file.cwait_on_buffer(bh);
bh237fs/ext/file.cif (!buffer_uptodate(bh)) {
bh238fs/ext/file.cbrelse(bh);
bh244fs/ext/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
bh254fs/ext/file.cmark_buffer_uptodate(bh, 1);
bh255fs/ext/file.cmark_buffer_dirty(bh, 0);
bh256fs/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.cmark_buffer_clean(bh);
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.cmark_buffer_uptodate(bh, 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 && buffer_req(bh) && !buffer_uptodate(bh)) {
bh46fs/ext/fsync.cbrelse(bh);
bh49fs/ext/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
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)
bh63fs/ext/inode.cstruct buffer_head *bh;
bh71fs/ext/inode.cif (!(bh = bread(dev, 1, BLOCK_SIZE))) {
bh78fs/ext/inode.ces = (struct ext_super_block *) bh->b_data;
bh91fs/ext/inode.cbrelse(bh);
bh140fs/ext/inode.cstruct buffer_head * bh;
bh143fs/ext/inode.cif (!(bh = bread(sb->s_dev, 1, BLOCK_SIZE))) {
bh147fs/ext/inode.ces = (struct ext_super_block *) bh->b_data;
bh152fs/ext/inode.cmark_buffer_dirty(bh, 1);
bh153fs/ext/inode.cbrelse (bh);
bh174fs/ext/inode.cstatic inline int block_bmap(struct buffer_head * bh, int nr)
bh178fs/ext/inode.cif (!bh)
bh180fs/ext/inode.ctmp = ((unsigned long *) bh->b_data)[nr];
bh181fs/ext/inode.cbrelse(bh);
bh263fs/ext/inode.cstruct buffer_head * bh, int nr, int create)
bh269fs/ext/inode.cif (!bh)
bh271fs/ext/inode.cif (!buffer_uptodate(bh)) {
bh272fs/ext/inode.cll_rw_block(READ, 1, &bh);
bh273fs/ext/inode.cwait_on_buffer(bh);
bh274fs/ext/inode.cif (!buffer_uptodate(bh)) {
bh275fs/ext/inode.cbrelse(bh);
bh279fs/ext/inode.cp = nr + (unsigned long *) bh->b_data;
bh283fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh285fs/ext/inode.cbrelse(bh);
bh292fs/ext/inode.cbrelse(bh);
bh297fs/ext/inode.cbrelse(bh);
bh300fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh307fs/ext/inode.cmark_buffer_dirty(bh, 1);
bh308fs/ext/inode.cbrelse(bh);
bh314fs/ext/inode.cstruct buffer_head * bh;
bh328fs/ext/inode.cbh = inode_getblk(inode,9,create);
bh329fs/ext/inode.creturn block_getblk(inode,bh,block,create);
bh333fs/ext/inode.cbh = inode_getblk(inode,10,create);
bh334fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
bh335fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
bh338fs/ext/inode.cbh = inode_getblk(inode,11,create);
bh339fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
bh340fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
bh341fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
bh346fs/ext/inode.cstruct buffer_head * bh;
bh348fs/ext/inode.cbh = ext_getblk(inode,block,create);
bh349fs/ext/inode.cif (!bh || buffer_uptodate(bh)) 
bh350fs/ext/inode.creturn bh;
bh351fs/ext/inode.cll_rw_block(READ, 1, &bh);
bh352fs/ext/inode.cwait_on_buffer(bh);
bh353fs/ext/inode.cif (buffer_uptodate(bh))
bh354fs/ext/inode.creturn bh;
bh355fs/ext/inode.cbrelse(bh);
bh361fs/ext/inode.cstruct buffer_head * bh;
bh366fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
bh368fs/ext/inode.craw_inode = ((struct ext_inode *) bh->b_data) +
bh381fs/ext/inode.cbrelse(bh);
bh399fs/ext/inode.cstruct buffer_head * bh;
bh404fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
bh406fs/ext/inode.craw_inode = ((struct ext_inode *)bh->b_data) +
bh418fs/ext/inode.cmark_buffer_dirty(bh, 1);
bh420fs/ext/inode.creturn bh;
bh425fs/ext/inode.cstruct buffer_head *bh;
bh426fs/ext/inode.cbh = ext_update_inode (inode);
bh427fs/ext/inode.cbrelse(bh);
bh433fs/ext/inode.cstruct buffer_head *bh;
bh435fs/ext/inode.cbh = ext_update_inode(inode);
bh436fs/ext/inode.cif (bh && buffer_dirty(bh))
bh438fs/ext/inode.cll_rw_block(WRITE, 1, &bh);
bh439fs/ext/inode.cwait_on_buffer(bh);
bh440fs/ext/inode.cif (buffer_req(bh) && !buffer_uptodate(bh))
bh448fs/ext/inode.celse if (!bh)
bh450fs/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)) {
bh125fs/ext/namei.cde = (struct ext_dir_entry *) (bh->b_data+BLOCK_SIZE);
bh135fs/ext/namei.c((char *)de) + de->rec_len < BLOCK_SIZE+bh->b_data)
bh140fs/ext/namei.creturn bh;
bh147fs/ext/namei.cbrelse(bh);
bh156fs/ext/namei.cstruct buffer_head * bh;
bh165fs/ext/namei.cif (!(bh = ext_find_entry(dir,name,len,&de,NULL,NULL))) {
bh170fs/ext/namei.cbrelse(bh);
bh195fs/ext/namei.cstruct buffer_head * bh;
bh210fs/ext/namei.cbh = ext_bread(dir,0,0);
bh211fs/ext/namei.cif (!bh)
bh215fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh217fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) {
bh221fs/ext/namei.cbrelse(bh);
bh222fs/ext/namei.cbh = NULL;
bh223fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
bh224fs/ext/namei.cif (!bh)
bh226fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh246fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh248fs/ext/namei.cbrelse (bh);
bh249fs/ext/namei.cbh = NULL;
bh253fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,1);
bh254fs/ext/namei.cif (!bh)
bh256fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh269fs/ext/namei.c(((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) {
bh275fs/ext/namei.cbrelse (bh);
bh296fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh298fs/ext/namei.creturn bh;
bh303fs/ext/namei.cbrelse(bh);
bh311fs/ext/namei.cstruct buffer_head * bh;
bh325fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh326fs/ext/namei.cif (!bh) {
bh334fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh335fs/ext/namei.cbrelse(bh);
bh344fs/ext/namei.cstruct buffer_head * bh;
bh349fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh350fs/ext/namei.cif (bh) {
bh351fs/ext/namei.cbrelse(bh);
bh384fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh385fs/ext/namei.cif (!bh) {
bh393fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh394fs/ext/namei.cbrelse(bh);
bh403fs/ext/namei.cstruct buffer_head * bh, *dir_block;
bh406fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh407fs/ext/namei.cif (bh) {
bh408fs/ext/namei.cbrelse(bh);
bh451fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh452fs/ext/namei.cif (!bh) {
bh459fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh464fs/ext/namei.cbrelse(bh);
bh474fs/ext/namei.cstruct buffer_head * bh;
bh477fs/ext/namei.cif (inode->i_size < 2 * 12 || !(bh = ext_bread(inode,0,0))) {
bh482fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh493fs/ext/namei.cif ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) {
bh494fs/ext/namei.cbrelse(bh);
bh495fs/ext/namei.cbh = ext_bread(inode, offset >> BLOCK_SIZE_BITS,1);
bh496fs/ext/namei.cif (!bh) {
bh500fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh509fs/ext/namei.cbrelse (bh);
bh513fs/ext/namei.cbrelse(bh);
bh519fs/ext/namei.cbrelse(bh);
bh536fs/ext/namei.cstruct buffer_head * bh;
bh540fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
bh542fs/ext/namei.cif (!bh)
bh572fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh582fs/ext/namei.cbrelse(bh);
bh590fs/ext/namei.cstruct buffer_head * bh;
bh595fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
bh596fs/ext/namei.cif (!bh)
bh616fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh624fs/ext/namei.cbrelse(bh);
bh634fs/ext/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh660fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh661fs/ext/namei.cif (bh) {
bh665fs/ext/namei.cbrelse(bh);
bh669fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh670fs/ext/namei.cif (!bh) {
bh678fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh679fs/ext/namei.cbrelse(bh);
bh688fs/ext/namei.cstruct buffer_head * bh;
bh700fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh701fs/ext/namei.cif (bh) {
bh702fs/ext/namei.cbrelse(bh);
bh707fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh708fs/ext/namei.cif (!bh) {
bh714fs/ext/namei.cmark_buffer_dirty(bh, 1);
bh715fs/ext/namei.cbrelse(bh);
bh53fs/ext/symlink.cstruct buffer_head * bh;
bh74fs/ext/symlink.cif (!(bh = ext_bread(inode, 0, 0))) {
bh81fs/ext/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh83fs/ext/symlink.cbrelse(bh);
bh89fs/ext/symlink.cstruct buffer_head * bh;
bh99fs/ext/symlink.cbh = ext_bread(inode, 0, 0);
bh101fs/ext/symlink.cif (!bh)
bh104fs/ext/symlink.cwhile (i<buflen && (c = bh->b_data[i])) {
bh108fs/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);
bh40fs/ext2/balloc.cstruct buffer_head ** bh)
bh61fs/ext2/balloc.cif (bh)
bh62fs/ext2/balloc.c*bh = sb->u.ext2_sb.s_group_desc[group_desc];
bh71fs/ext2/balloc.cstruct buffer_head * bh;
bh74fs/ext2/balloc.cbh = bread (sb->s_dev, gdp->bg_block_bitmap, sb->s_blocksize);
bh75fs/ext2/balloc.cif (!bh)
bh81fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[bitmap_nr] = bh;
bh171fs/ext2/balloc.cstruct buffer_head * bh;
bh208fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh224fs/ext2/balloc.cif (!clear_bit (bit + i, bh->b_data))
bh239fs/ext2/balloc.cmark_buffer_dirty(bh, 1);
bh241fs/ext2/balloc.cll_rw_block (WRITE, 1, &bh);
bh242fs/ext2/balloc.cwait_on_buffer (bh);
bh259fs/ext2/balloc.cstruct buffer_head * bh;
bh304fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh308fs/ext2/balloc.cif (!test_bit(j, bh->b_data)) {
bh325fs/ext2/balloc.cj = find_next_zero_bit(bh->b_data, end_goal, j);
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--);
bh423fs/ext2/balloc.cif (set_bit (j, bh->b_data)) {
bh445fs/ext2/balloc.cif (set_bit (j + k, bh->b_data)) {
bh461fs/ext2/balloc.cmark_buffer_dirty(bh, 1);
bh463fs/ext2/balloc.cll_rw_block (WRITE, 1, &bh);
bh464fs/ext2/balloc.cwait_on_buffer (bh);
bh474fs/ext2/balloc.cif (!(bh = getblk (sb->s_dev, j, sb->s_blocksize))) {
bh479fs/ext2/balloc.cmemset(bh->b_data, 0, sb->s_blocksize);
bh480fs/ext2/balloc.cmark_buffer_uptodate(bh, 1);
bh481fs/ext2/balloc.cmark_buffer_dirty(bh, 1);
bh482fs/ext2/balloc.cbrelse (bh);
bh540fs/ext2/balloc.cstruct buffer_head * bh;
bh559fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh561fs/ext2/balloc.cif (!test_bit (0, bh->b_data))
bh566fs/ext2/balloc.cif (!test_bit (j + 1, bh->b_data))
bh571fs/ext2/balloc.cif (!block_in_use (gdp->bg_block_bitmap, sb, bh->b_data))
bh576fs/ext2/balloc.cif (!block_in_use (gdp->bg_inode_bitmap, sb, bh->b_data))
bh582fs/ext2/balloc.cif (!block_in_use (gdp->bg_inode_table + j, sb, bh->b_data))
bh587fs/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 >
bh106fs/ext2/dir.cstruct buffer_head * bh, * tmp, * bha[16];
bh116fs/ext2/dir.cbh = NULL;
bh121fs/ext2/dir.cbh = ext2_bread (inode, blk, 0, &err);
bh122fs/ext2/dir.cif (!bh) {
bh157fs/ext2/dir.c(bh->b_data + i);
bh176fs/ext2/dir.cde = (struct ext2_dir_entry *) (bh->b_data + offset);
bh178fs/ext2/dir.cbh, offset)) {
bh183fs/ext2/dir.cbrelse (bh);
bh207fs/ext2/dir.cbrelse (bh);
bh92fs/ext2/file.cstruct buffer_head * bh, *bufferlist[NBUF];
bh137fs/ext2/file.cbh = ext2_getblk (inode, block, 1, &err);
bh138fs/ext2/file.cif (!bh) {
bh146fs/ext2/file.cif (c != sb->s_blocksize && !buffer_uptodate(bh)) {
bh147fs/ext2/file.cll_rw_block (READ, 1, &bh);
bh148fs/ext2/file.cwait_on_buffer (bh);
bh149fs/ext2/file.cif (!buffer_uptodate(bh)) {
bh150fs/ext2/file.cbrelse (bh);
bh156fs/ext2/file.cmemcpy_fromfs (bh->b_data + offset, buf, c);
bh157fs/ext2/file.cupdate_vm_cache(inode, pos, bh->b_data + offset, c);
bh162fs/ext2/file.cmark_buffer_uptodate(bh, 1);
bh163fs/ext2/file.cmark_buffer_dirty(bh, 0);
bh165fs/ext2/file.cbufferlist[buffercount++] = bh;
bh167fs/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 && buffer_req(bh) && !buffer_uptodate(bh)) {
bh46fs/ext2/fsync.cbrelse (bh);
bh49fs/ext2/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh)) {
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)
bh39fs/ext2/ialloc.cstruct buffer_head ** bh)
bh60fs/ext2/ialloc.cif (bh)
bh61fs/ext2/ialloc.c*bh = sb->u.ext2_sb.s_group_desc[group_desc];
bh70fs/ext2/ialloc.cstruct buffer_head * bh;
bh73fs/ext2/ialloc.cbh = bread (sb->s_dev, gdp->bg_inode_bitmap, sb->s_blocksize);
bh74fs/ext2/ialloc.cif (!bh)
bh80fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[bitmap_nr] = bh;
bh163fs/ext2/ialloc.cstruct buffer_head * bh;
bh169fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
bh170fs/ext2/ialloc.cif (!bh)
bh175fs/ext2/ialloc.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh181fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh183fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh184fs/ext2/ialloc.cwait_on_buffer (bh);
bh186fs/ext2/ialloc.cbrelse (bh);
bh192fs/ext2/ialloc.cstruct buffer_head * bh;
bh236fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
bh237fs/ext2/ialloc.cif (!clear_bit (bit, bh->b_data))
bh251fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh253fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh254fs/ext2/ialloc.cwait_on_buffer (bh);
bh273fs/ext2/ialloc.cstruct buffer_head * bh;
bh279fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
bh280fs/ext2/ialloc.cif (!bh) {
bh288fs/ext2/ialloc.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh294fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh295fs/ext2/ialloc.cbrelse (bh);
bh311fs/ext2/ialloc.cstruct buffer_head * bh;
bh411fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
bh412fs/ext2/ialloc.cif ((j = find_first_zero_bit ((unsigned long *) bh->b_data,
bh415fs/ext2/ialloc.cif (set_bit (j, bh->b_data)) {
bh420fs/ext2/ialloc.cmark_buffer_dirty(bh, 1);
bh422fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh423fs/ext2/ialloc.cwait_on_buffer (bh);
bh44fs/ext2/inode.cstatic inline int block_bmap (struct buffer_head * bh, int nr)
bh48fs/ext2/inode.cif (!bh)
bh50fs/ext2/inode.ctmp = ((u32 *) bh->b_data)[nr];
bh51fs/ext2/inode.cbrelse (bh);
bh81fs/ext2/inode.cstruct buffer_head * bh;
bh98fs/ext2/inode.cif (!(bh = getblk (inode->i_sb->s_dev, result,
bh104fs/ext2/inode.cmemset(bh->b_data, 0, inode->i_sb->s_blocksize);
bh105fs/ext2/inode.cmark_buffer_uptodate(bh, 1);
bh106fs/ext2/inode.cmark_buffer_dirty(bh, 1);
bh107fs/ext2/inode.cbrelse (bh);
bh249fs/ext2/inode.cstruct buffer_head * bh, int nr,
bh258fs/ext2/inode.cif (!bh)
bh260fs/ext2/inode.cif (!buffer_uptodate(bh)) {
bh261fs/ext2/inode.cll_rw_block (READ, 1, &bh);
bh262fs/ext2/inode.cwait_on_buffer (bh);
bh263fs/ext2/inode.cif (!buffer_uptodate(bh)) {
bh264fs/ext2/inode.cbrelse (bh);
bh268fs/ext2/inode.cp = (u32 *) bh->b_data + nr;
bh272fs/ext2/inode.cresult = getblk (bh->b_dev, tmp, blocksize);
bh274fs/ext2/inode.cbrelse (bh);
bh283fs/ext2/inode.cbrelse (bh);
bh291fs/ext2/inode.cif (((u32 *) bh->b_data)[tmp]) {
bh292fs/ext2/inode.cgoal = ((u32 *)bh->b_data)[tmp];
bh297fs/ext2/inode.cgoal = bh->b_blocknr;
bh301fs/ext2/inode.cbrelse (bh);
bh304fs/ext2/inode.cresult = getblk (bh->b_dev, tmp, blocksize);
bh311fs/ext2/inode.cmark_buffer_dirty(bh, 1);
bh313fs/ext2/inode.cll_rw_block (WRITE, 1, &bh);
bh314fs/ext2/inode.cwait_on_buffer (bh);
bh321fs/ext2/inode.cbrelse (bh);
bh325fs/ext2/inode.cstatic int block_getcluster (struct inode * inode, struct buffer_head * bh,
bh336fs/ext2/inode.cif(!bh) return 0;
bh343fs/ext2/inode.cp = (u32 *) bh->b_data + nr + i;
bh353fs/ext2/inode.cp = (u32 *) bh->b_data + nr;
bh354fs/ext2/inode.cresult = generate_cluster(bh->b_dev, (int *) p, blocksize);
bh357fs/ext2/inode.cbrelse(bh);
bh364fs/ext2/inode.cstruct buffer_head * bh;
bh401fs/ext2/inode.cbh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, err);
bh402fs/ext2/inode.creturn block_getblk (inode, bh, block, create,
bh407fs/ext2/inode.cbh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, err);
bh408fs/ext2/inode.cbh = block_getblk (inode, bh, block >> addr_per_block_bits,
bh410fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1),
bh414fs/ext2/inode.cbh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, err);
bh415fs/ext2/inode.cbh = block_getblk (inode, bh, block >> (addr_per_block_bits * 2),
bh417fs/ext2/inode.cbh = block_getblk (inode, bh, (block >> addr_per_block_bits) & (addr_per_block - 1),
bh419fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1), create,
bh425fs/ext2/inode.cstruct buffer_head * bh;
bh451fs/ext2/inode.cbh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, &err);
bh452fs/ext2/inode.creturn block_getcluster (inode, bh, block, 
bh457fs/ext2/inode.cbh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, &err);
bh458fs/ext2/inode.cbh = block_getblk (inode, bh, block >> addr_per_block_bits,
bh460fs/ext2/inode.creturn block_getcluster (inode, bh, block & (addr_per_block - 1),
bh464fs/ext2/inode.cbh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, &err);
bh465fs/ext2/inode.cbh = block_getblk (inode, bh, block >> (addr_per_block_bits * 2),
bh467fs/ext2/inode.cbh = block_getblk (inode, bh, (block >> addr_per_block_bits) & (addr_per_block - 1),
bh469fs/ext2/inode.creturn block_getcluster (inode, bh, block & (addr_per_block - 1),
bh476fs/ext2/inode.cstruct buffer_head * bh;
bh478fs/ext2/inode.cbh = ext2_getblk (inode, block, create, err);
bh479fs/ext2/inode.cif (!bh || buffer_uptodate(bh))
bh480fs/ext2/inode.creturn bh;
bh481fs/ext2/inode.cll_rw_block (READ, 1, &bh);
bh482fs/ext2/inode.cwait_on_buffer (bh);
bh483fs/ext2/inode.cif (buffer_uptodate(bh))
bh484fs/ext2/inode.creturn bh;
bh485fs/ext2/inode.cbrelse (bh);
bh492fs/ext2/inode.cstruct buffer_head * bh;
bh513fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
bh514fs/ext2/inode.cif (!bh)
bh517fs/ext2/inode.cgdp = (struct ext2_group_desc *) bh->b_data;
bh521fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
bh525fs/ext2/inode.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh557fs/ext2/inode.cbrelse (bh);
bh584fs/ext2/inode.cstruct buffer_head * bh;
bh604fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
bh605fs/ext2/inode.cif (!bh)
bh608fs/ext2/inode.cgdp = (struct ext2_group_desc *) bh->b_data;
bh612fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
bh616fs/ext2/inode.craw_inode = ((struct ext2_inode *)bh->b_data) +
bh639fs/ext2/inode.cmark_buffer_dirty(bh, 1);
bh641fs/ext2/inode.creturn bh;
bh646fs/ext2/inode.cstruct buffer_head * bh;
bh647fs/ext2/inode.cbh = ext2_update_inode (inode);
bh648fs/ext2/inode.cbrelse (bh);
bh654fs/ext2/inode.cstruct buffer_head *bh;
bh656fs/ext2/inode.cbh = ext2_update_inode (inode);
bh657fs/ext2/inode.cif (bh && buffer_dirty(bh))
bh659fs/ext2/inode.cll_rw_block (WRITE, 1, &bh);
bh660fs/ext2/inode.cwait_on_buffer (bh);
bh661fs/ext2/inode.cif (buffer_req(bh) && !buffer_uptodate(bh))
bh669fs/ext2/inode.celse if (!bh)
bh671fs/ext2/inode.cbrelse (bh);
bh94fs/ext2/namei.cstruct buffer_head * bh;
bh98fs/ext2/namei.cbh = ext2_getblk (dir, block, 0, &err);
bh99fs/ext2/namei.cbh_use[block] = bh;
bh100fs/ext2/namei.cif (bh && !buffer_uptodate(bh))
bh101fs/ext2/namei.cbh_read[toread++] = bh;
bh105fs/ext2/namei.cstruct buffer_head * bh;
bh113fs/ext2/namei.cbh = bh_use[block % NAMEI_RA_SIZE];
bh114fs/ext2/namei.cif (!bh) {
bh121fs/ext2/namei.cwait_on_buffer (bh);
bh122fs/ext2/namei.cif (!buffer_uptodate(bh)) {
bh129fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh130fs/ext2/namei.cdlimit = bh->b_data + sb->s_blocksize;
bh133fs/ext2/namei.cde, bh, offset))
bh137fs/ext2/namei.cif (bh_use[i] != bh)
bh141fs/ext2/namei.creturn bh;
bh148fs/ext2/namei.cbrelse (bh);
bh151fs/ext2/namei.cbh = NULL;
bh153fs/ext2/namei.cbh = ext2_getblk (dir, block + NAMEI_RA_SIZE, 0, &err);
bh154fs/ext2/namei.cbh_use[block % NAMEI_RA_SIZE] = bh;
bh155fs/ext2/namei.cif (bh && !buffer_uptodate(bh))
bh156fs/ext2/namei.cbh_read[toread++] = bh;
bh170fs/ext2/namei.cstruct buffer_head * bh;
bh192fs/ext2/namei.cif (!(bh = ext2_find_entry (dir, name, len, &de))) {
bh200fs/ext2/namei.cbrelse (bh);
bh226fs/ext2/namei.cstruct buffer_head * bh;
bh252fs/ext2/namei.cbh = ext2_bread (dir, 0, 0, err);
bh253fs/ext2/namei.cif (!bh)
bh257fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh260fs/ext2/namei.cif ((char *)de >= sb->s_blocksize + bh->b_data) {
bh261fs/ext2/namei.cbrelse (bh);
bh262fs/ext2/namei.cbh = NULL;
bh263fs/ext2/namei.cbh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, err);
bh264fs/ext2/namei.cif (!bh)
bh274fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh283fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh286fs/ext2/namei.cif (!ext2_check_dir_entry ("ext2_add_entry", dir, de, bh,
bh289fs/ext2/namei.cbrelse (bh);
bh294fs/ext2/namei.cbrelse (bh);
bh325fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh328fs/ext2/namei.creturn bh;
bh333fs/ext2/namei.cbrelse (bh);
bh342fs/ext2/namei.cstruct buffer_head * bh)
bh349fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh350fs/ext2/namei.cwhile (i < bh->b_size) {
bh352fs/ext2/namei.cde, bh, i))
bh371fs/ext2/namei.cstruct buffer_head * bh;
bh386fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh387fs/ext2/namei.cif (!bh) {
bh397fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh399fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh400fs/ext2/namei.cwait_on_buffer (bh);
bh402fs/ext2/namei.cbrelse (bh);
bh412fs/ext2/namei.cstruct buffer_head * bh;
bh418fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh419fs/ext2/namei.cif (bh) {
bh420fs/ext2/namei.cbrelse (bh);
bh450fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh451fs/ext2/namei.cif (!bh) {
bh461fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh463fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh464fs/ext2/namei.cwait_on_buffer (bh);
bh466fs/ext2/namei.cbrelse (bh);
bh475fs/ext2/namei.cstruct buffer_head * bh, * dir_block;
bh481fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh482fs/ext2/namei.cif (bh) {
bh483fs/ext2/namei.cbrelse (bh);
bh524fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh525fs/ext2/namei.cif (!bh) {
bh535fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh537fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh538fs/ext2/namei.cwait_on_buffer (bh);
bh544fs/ext2/namei.cbrelse (bh);
bh554fs/ext2/namei.cstruct buffer_head * bh;
bh561fs/ext2/namei.c!(bh = ext2_bread (inode, 0, 0, &err))) {
bh567fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh579fs/ext2/namei.cif ((void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
bh580fs/ext2/namei.cbrelse (bh);
bh581fs/ext2/namei.cbh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, &err);
bh582fs/ext2/namei.cif (!bh) {
bh589fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh591fs/ext2/namei.cif (!ext2_check_dir_entry ("empty_dir", inode, de, bh,
bh593fs/ext2/namei.cbrelse (bh);
bh597fs/ext2/namei.cbrelse (bh);
bh603fs/ext2/namei.cbrelse (bh);
bh611fs/ext2/namei.cstruct buffer_head * bh;
bh618fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh620fs/ext2/namei.cif (!bh)
bh631fs/ext2/namei.cbrelse(bh);
bh662fs/ext2/namei.cretval = ext2_delete_entry (de, bh);
bh668fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh670fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh671fs/ext2/namei.cwait_on_buffer (bh);
bh686fs/ext2/namei.cbrelse (bh);
bh694fs/ext2/namei.cstruct buffer_head * bh;
bh702fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh703fs/ext2/namei.cif (!bh)
bh716fs/ext2/namei.cbrelse(bh);
bh731fs/ext2/namei.cretval = ext2_delete_entry (de, bh);
bh735fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh737fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh738fs/ext2/namei.cwait_on_buffer (bh);
bh747fs/ext2/namei.cbrelse (bh);
bh758fs/ext2/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh803fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh804fs/ext2/namei.cif (bh) {
bh808fs/ext2/namei.cbrelse (bh);
bh812fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh813fs/ext2/namei.cif (!bh) {
bh823fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh825fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh826fs/ext2/namei.cwait_on_buffer (bh);
bh828fs/ext2/namei.cbrelse (bh);
bh838fs/ext2/namei.cstruct buffer_head * bh;
bh856fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh857fs/ext2/namei.cif (bh) {
bh858fs/ext2/namei.cbrelse (bh);
bh863fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh864fs/ext2/namei.cif (!bh) {
bh872fs/ext2/namei.cmark_buffer_dirty(bh, 1);
bh874fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh875fs/ext2/namei.cwait_on_buffer (bh);
bh877fs/ext2/namei.cbrelse (bh);
bh368fs/ext2/super.cstruct buffer_head * bh;
bh388fs/ext2/super.cif (!(bh = bread (dev, sb_block, BLOCK_SIZE))) {
bh399fs/ext2/super.ces = (struct ext2_super_block *) bh->b_data;
bh405fs/ext2/super.cbrelse (bh);
bh418fs/ext2/super.cbrelse (bh);
bh422fs/ext2/super.cbh = bread (dev, logic_sb_block, sb->s_blocksize);
bh423fs/ext2/super.cif(!bh) {
bh427fs/ext2/super.ces = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
bh432fs/ext2/super.cbrelse (bh);
bh454fs/ext2/super.csb->u.ext2_sb.s_sbh = bh;
bh475fs/ext2/super.cbrelse (bh);
bh483fs/ext2/super.cif (sb->s_blocksize != bh->b_size) {
bh486fs/ext2/super.cbrelse (bh);
bh497fs/ext2/super.cbrelse (bh);
bh507fs/ext2/super.cbrelse (bh);
bh516fs/ext2/super.cbrelse (bh);
bh525fs/ext2/super.cbrelse (bh);
bh542fs/ext2/super.cbrelse (bh);
bh557fs/ext2/super.cbrelse (bh);
bh570fs/ext2/super.cbrelse (bh);
bh597fs/ext2/super.cbrelse (bh);
bh58fs/ext2/symlink.cstruct buffer_head * bh = NULL;
bh81fs/ext2/symlink.cif (!(bh = ext2_bread (inode, 0, 0, &error))) {
bh86fs/ext2/symlink.clink = bh->b_data;
bh97fs/ext2/symlink.cif (bh)
bh98fs/ext2/symlink.cbrelse (bh);
bh104fs/ext2/symlink.cstruct buffer_head * bh = NULL;
bh116fs/ext2/symlink.cbh = ext2_bread (inode, 0, 0, &err);
bh117fs/ext2/symlink.cif (!bh) {
bh121fs/ext2/symlink.clink = bh->b_data;
bh135fs/ext2/symlink.cif (bh)
bh136fs/ext2/symlink.cbrelse (bh);
bh63fs/ext2/truncate.cstruct buffer_head * bh;
bh78fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp,
bh81fs/ext2/truncate.cbrelse (bh);
bh84fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh86fs/ext2/truncate.cbrelse (bh);
bh92fs/ext2/truncate.cbforget(bh);
bh113fs/ext2/truncate.cstruct buffer_head * bh;
bh146fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp,
bh149fs/ext2/truncate.cbrelse (bh);
bh152fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh154fs/ext2/truncate.cbrelse (bh);
bh159fs/ext2/truncate.cbforget(bh);
bh320fs/ext2/truncate.cstruct buffer_head * bh;
bh353fs/ext2/truncate.cbh = ext2_bread (inode,
bh356fs/ext2/truncate.cif (bh) {
bh357fs/ext2/truncate.cmemset (bh->b_data + offset, 0,
bh359fs/ext2/truncate.cmark_buffer_dirty (bh, 0);
bh360fs/ext2/truncate.cbrelse (bh);
bh87fs/fat/buffer.cstruct buffer_head *bh)
bh89fs/fat/buffer.cif (bh != NULL){
bh91fs/fat/buffer.cbrelse (bh);
bh93fs/fat/buffer.cbrelse (bh->b_next);
bh97fs/fat/buffer.ckfree (bh);
bh104fs/fat/buffer.cstruct buffer_head *bh,
bh108fs/fat/buffer.cbh = bh->b_next;
bh110fs/fat/buffer.cmark_buffer_dirty (bh,dirty_val);
bh115fs/fat/buffer.cstruct buffer_head *bh,
bh119fs/fat/buffer.cbh = bh->b_next;
bh121fs/fat/buffer.cmark_buffer_uptodate(bh, val);
bh125fs/fat/buffer.cstruct buffer_head *bh)
bh128fs/fat/buffer.cbh = bh->b_next;
bh130fs/fat/buffer.creturn buffer_uptodate(bh);
bh137fs/fat/buffer.cstruct buffer_head *bh[32])
bh140fs/fat/buffer.cll_rw_block(opr,nbreq,bh);
bh145fs/fat/buffer.ctmp[i] = bh[i]->b_next;
bh22fs/fat/cache.cstruct buffer_head *bh,*bh2,*c_bh,*c_bh2;
bh32fs/fat/cache.cif (!(bh = bread(sb->s_dev,MSDOS_SB(sb)->fat_start+(first >>
bh38fs/fat/cache.cbh2 = bh;
bh42fs/fat/cache.cbrelse(bh);
bh49fs/fat/cache.cnext = CF_LE_W(((unsigned short *) bh->b_data)[(first &
bh54fs/fat/cache.cp_first = &((unsigned char *) bh->b_data)[first & (SECTOR_SIZE-1)];
bh63fs/fat/cache.c((unsigned short *) bh->b_data)[(first & (SECTOR_SIZE-1)) >>
bh76fs/fat/cache.cmark_buffer_dirty(bh, 1);
bh81fs/fat/cache.cmemcpy(c_bh->b_data,bh->b_data,SECTOR_SIZE);
bh83fs/fat/cache.cif (bh != bh2) {
bh97fs/fat/cache.cbrelse(bh);
bh98fs/fat/cache.cif (bh != bh2) brelse(bh2);
bh107fs/fat/dir.cstruct buffer_head *bh;
bh135fs/fat/dir.cbh = NULL;
bh138fs/fat/dir.cino = fat_get_entry(inode,&filp->f_pos,&bh,&de);
bh201fs/fat/dir.cino = fat_get_entry(inode,&filp->f_pos,&bh,&de);
bh296fs/fat/dir.cino = fat_get_entry(inode,&filp->f_pos,&bh,&de);  
bh298fs/fat/dir.cif (bh) brelse(bh);
bh136fs/fat/file.cstruct buffer_head *bh;
bh139fs/fat/file.cbh = getblk(inode->i_dev,sector,SECTOR_SIZE);
bh140fs/fat/file.cif (bh == NULL)  break;
bh141fs/fat/file.cpre->bhlist[pre->nblist++] = bh;
bh142fs/fat/file.cif (!fat_is_uptodate(sb,bh)) bhreq[nbreq++] = bh;
bh215fs/fat/file.cstruct buffer_head *bh = pre.bhlist[pre.nolist];
bh218fs/fat/file.cif (bh == NULL) break;
bh229fs/fat/file.cwait_on_buffer(bh);
bh230fs/fat/file.cif (!fat_is_uptodate(sb,bh)){
bh232fs/fat/file.cbrelse (bh);
bh236fs/fat/file.cdata = bh->b_data + offset;
bh255fs/fat/file.cbrelse(bh);
bh279fs/fat/file.cstruct buffer_head *bh;
bh316fs/fat/file.cif (!(bh = getblk(inode->i_dev,sector,SECTOR_SIZE))){
bh320fs/fat/file.c}else if (!(bh = bread(inode->i_dev,sector,SECTOR_SIZE))) {
bh325fs/fat/file.cmemcpy_fromfs(bh->b_data+offset,buf,written = size);
bh330fs/fat/file.cto = (char *) bh->b_data+(filp->f_pos & (SECTOR_SIZE-1));
bh349fs/fat/file.cupdate_vm_cache(inode, filp->f_pos, bh->b_data + (filp->f_pos & (SECTOR_SIZE-1)), written);
bh355fs/fat/file.cfat_set_uptodate(sb,bh,1);
bh356fs/fat/file.cmark_buffer_dirty(bh, 0);
bh357fs/fat/file.cbrelse(bh);
bh191fs/fat/inode.cstruct buffer_head *bh;
bh216fs/fat/inode.cbh = bread(sb->s_dev, 0, 1024);
bh218fs/fat/inode.cif (bh == NULL || !fat_is_uptodate(sb,bh)) {
bh219fs/fat/inode.cbrelse (bh);
bh225fs/fat/inode.cb = (struct msdos_boot_sector *) bh->b_data;
bh274fs/fat/inode.cbrelse(bh);
bh382fs/fat/inode.cstruct buffer_head *bh;
bh411fs/fat/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
bh417fs/fat/inode.craw_entry = &((struct msdos_dir_entry *) (bh->b_data))
bh474fs/fat/inode.cbrelse(bh);
bh481fs/fat/inode.cstruct buffer_head *bh;
bh509fs/fat/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
bh515fs/fat/inode.craw_entry = &((struct msdos_dir_entry *) (bh->b_data))
bh536fs/fat/inode.cmark_buffer_dirty(bh, 1);
bh537fs/fat/inode.cbrelse(bh);
bh120fs/fat/misc.cstruct buffer_head *bh;
bh194fs/fat/misc.cif (!(bh = getblk(inode->i_dev,sector,SECTOR_SIZE)))
bh197fs/fat/misc.cmemset(bh->b_data,0,SECTOR_SIZE);
bh198fs/fat/misc.cfat_set_uptodate(sb,bh,1);
bh199fs/fat/misc.cmark_buffer_dirty(bh, 1);
bh200fs/fat/misc.cbrelse(bh);
bh283fs/fat/misc.cint fat_get_entry(struct inode *dir, loff_t *pos,struct buffer_head **bh,
bh294fs/fat/misc.cPRINTK (("get_entry sector %d %p\n",sector,*bh));
bh298fs/fat/misc.cif (*bh)
bh299fs/fat/misc.cbrelse(*bh);
bh301fs/fat/misc.cif (!(*bh = bread(dir->i_dev,sector,SECTOR_SIZE))) {
bh306fs/fat/misc.c*de = (struct msdos_dir_entry *) ((*bh)->b_data+(offset &
bh370fs/fat/misc.cstruct buffer_head *bh;
bh375fs/fat/misc.cif (!(bh = bread(sb->s_dev,sector,SECTOR_SIZE))) return -EIO;
bh376fs/fat/misc.cdata = (struct msdos_dir_entry *) bh->b_data;
bh396fs/fat/misc.cif (!res_bh) brelse(bh);
bh398fs/fat/misc.c*res_bh = bh;
bh404fs/fat/misc.cbrelse(bh);
bh4fs/fat/msbuffer.hvoid fat_brelse (struct super_block *sb, struct buffer_head *bh);
bh6fs/fat/msbuffer.hstruct buffer_head *bh,
bh9fs/fat/msbuffer.hstruct buffer_head *bh,
bh11fs/fat/msbuffer.hint fat_is_uptodate (struct super_block *sb, struct buffer_head *bh);
bh13fs/fat/msbuffer.hint nbreq, struct buffer_head *bh[32]);
bh232fs/hpfs/hpfs_fs.cstruct buffer_head *bh[4];
bh885fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh917fs/hpfs/hpfs_fs.cblock = map_sector(inode->i_dev, hpfs_bmap(inode, q), &bh);
bh945fs/hpfs/hpfs_fs.cbrelse(bh);
bh1016fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1032fs/hpfs/hpfs_fs.cfnode = map_fnode(inode->i_dev, inode->i_ino, &bh);
bh1036fs/hpfs/hpfs_fs.cfile_secno, &bh);
bh1037fs/hpfs/hpfs_fs.cbrelse(bh);
bh1592fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1596fs/hpfs/hpfs_fs.cfnode = map_fnode(dev, ino, &bh);
bh1601fs/hpfs/hpfs_fs.cbrelse(bh);
bh1674fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1676fs/hpfs/hpfs_fs.cif ((*bhp = bh = bread(dev, secno, 512)) != 0)
bh1677fs/hpfs/hpfs_fs.creturn bh->b_data;
bh1689fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1701fs/hpfs/hpfs_fs.cqbh->bh[0] = bh = breada(dev, secno, 512, 0, UINT_MAX);
bh1702fs/hpfs/hpfs_fs.cif (!bh)
bh1704fs/hpfs/hpfs_fs.cmemcpy(data, bh->b_data, 512);
bh1706fs/hpfs/hpfs_fs.cqbh->bh[1] = bh = bread(dev, secno + 1, 512);
bh1707fs/hpfs/hpfs_fs.cif (!bh)
bh1709fs/hpfs/hpfs_fs.cmemcpy(data + 512, bh->b_data, 512);
bh1711fs/hpfs/hpfs_fs.cqbh->bh[2] = bh = bread(dev, secno + 2, 512);
bh1712fs/hpfs/hpfs_fs.cif (!bh)
bh1714fs/hpfs/hpfs_fs.cmemcpy(data + 2 * 512, bh->b_data, 512);
bh1716fs/hpfs/hpfs_fs.cqbh->bh[3] = bh = bread(dev, secno + 3, 512);
bh1717fs/hpfs/hpfs_fs.cif (!bh)
bh1719fs/hpfs/hpfs_fs.cmemcpy(data + 3 * 512, bh->b_data, 512);
bh1724fs/hpfs/hpfs_fs.cbrelse(qbh->bh[2]);
bh1726fs/hpfs/hpfs_fs.cbrelse(qbh->bh[1]);
bh1728fs/hpfs/hpfs_fs.cbrelse(qbh->bh[0]);
bh1740fs/hpfs/hpfs_fs.cbrelse(qbh->bh[3]);
bh1741fs/hpfs/hpfs_fs.cbrelse(qbh->bh[2]);
bh1742fs/hpfs/hpfs_fs.cbrelse(qbh->bh[1]);
bh1743fs/hpfs/hpfs_fs.cbrelse(qbh->bh[0]);
bh116fs/isofs/dir.cstruct buffer_head *bh;
bh128fs/isofs/dir.cif (!(bh = breada(inode->i_dev, block, bufsize, filp->f_pos, inode->i_size)))
bh139fs/isofs/dir.cbrelse(bh);
bh144fs/isofs/dir.cbh = breada(inode->i_dev, block, bufsize, filp->f_pos, inode->i_size);
bh145fs/isofs/dir.cif (!bh)
bh150fs/isofs/dir.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh160fs/isofs/dir.cbrelse(bh);
bh167fs/isofs/dir.cbh = breada(inode->i_dev, block, bufsize, filp->f_pos, inode->i_size);
bh168fs/isofs/dir.cif (!bh)
bh180fs/isofs/dir.cbrelse(bh);
bh184fs/isofs/dir.cbh = breada(inode->i_dev, block, bufsize, filp->f_pos+de_len, inode->i_size);
bh185fs/isofs/dir.cif (!bh)
bh187fs/isofs/dir.cmemcpy(bufsize - offset + (char *) tmpde, bh->b_data, next_offset);
bh256fs/isofs/dir.cbrelse(bh);
bh199fs/isofs/inode.cstruct buffer_head *bh=NULL;
bh257fs/isofs/inode.cif (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits), opt.blocksize))) {
bh267fs/isofs/inode.cvdp = (struct iso_volume_descriptor *)bh->b_data;
bh268fs/isofs/inode.chdp = (struct hs_volume_descriptor *)bh->b_data;
bh294fs/isofs/inode.cbrelse(bh);
bh355fs/isofs/inode.cbrelse(bh);
bh421fs/isofs/inode.cbrelse(bh);
bh457fs/isofs/inode.cstruct buffer_head * bh;
bh467fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
bh472fs/isofs/inode.cpnt = ((unsigned char *) bh->b_data
bh485fs/isofs/inode.cbrelse(bh);
bh488fs/isofs/inode.cmemcpy(cpnt, bh->b_data + offset, frag1);
bh489fs/isofs/inode.cbrelse(bh);
bh490fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
bh496fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh598fs/isofs/inode.cbrelse(bh);
bh681fs/isofs/inode.cstruct buffer_head * bh;
bh686fs/isofs/inode.cif (!(bh = bread(parent->i_dev, block, bufsize)))  return -1;
bh689fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh692fs/isofs/inode.cbrelse(bh);
bh703fs/isofs/inode.cbrelse(bh);
bh711fs/isofs/inode.cbrelse(bh);
bh724fs/isofs/inode.cif (!block || !(bh = bread(parent->i_dev,block, bufsize)))
bh731fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh740fs/isofs/inode.cbrelse(bh);
bh754fs/isofs/inode.c|| !(bh = bread(parent->i_dev,block, bufsize)))
bh774fs/isofs/inode.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
bh776fs/isofs/inode.cbrelse(bh);
bh785fs/isofs/inode.cif(!(bh = bread(parent->i_dev,block,bufsize))) {
bh789fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh811fs/isofs/inode.cbrelse(bh);
bh841fs/isofs/inode.cvoid leak_check_brelse(struct buffer_head * bh){
bh843fs/isofs/inode.creturn brelse(bh);
bh67fs/isofs/namei.cstruct buffer_head * bh;
bh86fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) return NULL;
bh89fs/isofs/namei.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh97fs/isofs/namei.cbrelse(bh);
bh102fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize)))
bh118fs/isofs/namei.cmemcpy(cpnt, bh->b_data + old_offset, frag1);
bh121fs/isofs/namei.cbrelse(bh);
bh124fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) {
bh128fs/isofs/namei.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh210fs/isofs/namei.creturn bh;
bh216fs/isofs/namei.cbrelse(bh);
bh224fs/isofs/namei.cstruct buffer_head * bh;
bh257fs/isofs/namei.cbh = isofs_find_entry(dir,lcname,len, &ino, &ino_back);
bh260fs/isofs/namei.cbh = isofs_find_entry(dir,name,len, &ino, &ino_back);
bh262fs/isofs/namei.cif (!bh) {
bh268fs/isofs/namei.cbrelse(bh);
bh57fs/isofs/rock.cstruct buffer_head * bh; \
bh68fs/isofs/rock.cbh = bread(DEV->i_dev, block++, ISOFS_BUFFER_SIZE(DEV)); \
bh69fs/isofs/rock.cif(!bh) {printk("Unable to read continuation Rock Ridge record\n"); \
bh72fs/isofs/rock.cmemcpy(buffer, bh->b_data + offset, 1024 - offset); \
bh73fs/isofs/rock.cbrelse(bh); \
bh79fs/isofs/rock.cbh = bread(DEV->i_dev, block, ISOFS_BUFFER_SIZE(DEV)); \
bh80fs/isofs/rock.cif(bh){       \
bh81fs/isofs/rock.cmemcpy(buffer + offset1, bh->b_data + offset, cont_size - offset1); \
bh82fs/isofs/rock.cbrelse(bh); \
bh408fs/isofs/rock.cstruct buffer_head * bh;
bh427fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
bh432fs/isofs/rock.cpnt = ((unsigned char *) bh->b_data) + (inode->i_ino & (bufsize - 1));
bh443fs/isofs/rock.cmemcpy(cpnt, bh->b_data + offset, frag1);
bh444fs/isofs/rock.cbrelse(bh);
bh445fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
bh451fs/isofs/rock.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
bh521fs/isofs/rock.cbrelse(bh);
bh22fs/minix/bitmap.cstruct buffer_head *bh;
bh25fs/minix/bitmap.cif (!(bh=map[i])) 
bh28fs/minix/bitmap.csum += nibblemap[bh->b_data[j] & 0xf] 
bh29fs/minix/bitmap.c+ nibblemap[(bh->b_data[j]>>4)&0xf];
bh36fs/minix/bitmap.cstruct buffer_head * bh;
bh48fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
bh49fs/minix/bitmap.cif (bh)
bh50fs/minix/bitmap.cclear_bit(BH_Dirty, &bh->b_state);
bh51fs/minix/bitmap.cbrelse(bh);
bh55fs/minix/bitmap.cbh = sb->u.minix_sb.s_zmap[zone];
bh56fs/minix/bitmap.cif (!bh) {
bh60fs/minix/bitmap.cif (!clear_bit(bit,bh->b_data))
bh63fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh69fs/minix/bitmap.cstruct buffer_head * bh;
bh79fs/minix/bitmap.cif ((bh=sb->u.minix_sb.s_zmap[i]) != NULL)
bh80fs/minix/bitmap.cif ((j=find_first_zero_bit(bh->b_data, 8192)) < 8192)
bh82fs/minix/bitmap.cif (i>=64 || !bh || j>=8192)
bh84fs/minix/bitmap.cif (set_bit(j,bh->b_data)) {
bh88fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh93fs/minix/bitmap.cif (!(bh = getblk(sb->s_dev,j,BLOCK_SIZE))) {
bh97fs/minix/bitmap.cmemset(bh->b_data, 0, BLOCK_SIZE);
bh98fs/minix/bitmap.cmark_buffer_uptodate(bh, 1);
bh99fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh100fs/minix/bitmap.cbrelse(bh);
bh112fs/minix/bitmap.cstruct buffer_head *bh;
bh125fs/minix/bitmap.cbh = bread(inode->i_dev, block, BLOCK_SIZE);
bh126fs/minix/bitmap.cif (!bh) {
bh130fs/minix/bitmap.craw_inode = ((struct minix_inode *)bh->b_data +
bh134fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh135fs/minix/bitmap.creturn bh;
bh140fs/minix/bitmap.cstruct buffer_head *bh;
bh153fs/minix/bitmap.cbh = bread(inode->i_dev, block, BLOCK_SIZE);
bh154fs/minix/bitmap.cif (!bh) {
bh158fs/minix/bitmap.craw_inode = ((struct minix2_inode *) bh->b_data +
bh162fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh163fs/minix/bitmap.creturn bh;
bh170fs/minix/bitmap.cstruct buffer_head *bh;
bh172fs/minix/bitmap.cbh = V1_minix_clear_inode(inode);
bh174fs/minix/bitmap.cbh = V2_minix_clear_inode(inode);
bh175fs/minix/bitmap.cbrelse (bh);
bh180fs/minix/bitmap.cstruct buffer_head * bh;
bh206fs/minix/bitmap.cif (!(bh=inode->i_sb->u.minix_sb.s_imap[ino >> 13])) {
bh212fs/minix/bitmap.cif (!clear_bit(ino & 8191, bh->b_data))
bh214fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh221fs/minix/bitmap.cstruct buffer_head * bh;
bh231fs/minix/bitmap.cif ((bh = inode->i_sb->u.minix_sb.s_imap[i]) != NULL)
bh232fs/minix/bitmap.cif ((j=find_first_zero_bit(bh->b_data, 8192)) < 8192)
bh234fs/minix/bitmap.cif (!bh || j >= 8192) {
bh238fs/minix/bitmap.cif (set_bit(j,bh->b_data)) {  /* shouldn't happen */
bh243fs/minix/bitmap.cmark_buffer_dirty(bh, 1);
bh64fs/minix/dir.cstruct buffer_head * bh;
bh75fs/minix/dir.cbh = minix_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
bh76fs/minix/dir.cif (!bh) {
bh81fs/minix/dir.cde = (struct minix_dir_entry *) (offset + bh->b_data);
bh85fs/minix/dir.cbrelse(bh);
bh92fs/minix/dir.cbrelse(bh);
bh73fs/minix/file.cstruct buffer_head * bh;
bh90fs/minix/file.cbh = minix_getblk(inode,pos/BLOCK_SIZE,1);
bh91fs/minix/file.cif (!bh) {
bh99fs/minix/file.cif (c != BLOCK_SIZE && !buffer_uptodate(bh)) {
bh100fs/minix/file.cll_rw_block(READ, 1, &bh);
bh101fs/minix/file.cwait_on_buffer(bh);
bh102fs/minix/file.cif (!buffer_uptodate(bh)) {
bh103fs/minix/file.cbrelse(bh);
bh109fs/minix/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
bh112fs/minix/file.cmark_buffer_uptodate(bh, 1);
bh113fs/minix/file.cmark_buffer_dirty(bh, 0);
bh114fs/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 && buffer_req(bh) && !buffer_uptodate(bh)) {
bh47fs/minix/fsync.cbrelse(bh);
bh50fs/minix/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
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)
bh170fs/minix/fsync.cstruct buffer_head * bh;
bh176fs/minix/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh177fs/minix/fsync.cif (!bh)
bh180fs/minix/fsync.cbrelse (bh);
bh183fs/minix/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
bh184fs/minix/fsync.cbrelse(bh);
bh187fs/minix/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
bh189fs/minix/fsync.cbrelse(bh);
bh192fs/minix/fsync.cll_rw_block(WRITE, 1, &bh);
bh193fs/minix/fsync.cbh->b_count--;
bh198fs/minix/fsync.cstruct buffer_head **bh, int wait) 
bh203fs/minix/fsync.c*bh = NULL;
bh210fs/minix/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh212fs/minix/fsync.cbrelse(*bh);
bh213fs/minix/fsync.c*bh = NULL;
bh216fs/minix/fsync.cif (!*bh)
bh128fs/minix/inode.cstruct buffer_head *bh;
bh137fs/minix/inode.cbh = minix_bread(dir, 0, 0);
bh138fs/minix/inode.cif (!bh)
bh141fs/minix/inode.cde = (struct minix_dir_entry *) bh->b_data;
bh150fs/minix/inode.cde = (struct minix_dir_entry *) (bh->b_data + dirsize);
bh160fs/minix/inode.cbrelse(bh);
bh167fs/minix/inode.cstruct buffer_head *bh;
bh180fs/minix/inode.cif (!(bh = bread(dev,1,BLOCK_SIZE))) {
bh187fs/minix/inode.cms = (struct minix_super_block *) bh->b_data;
bh189fs/minix/inode.cs->u.minix_sb.s_sbh = bh;
bh223fs/minix/inode.cbrelse(bh);
bh237fs/minix/inode.cbrelse (bh);
bh261fs/minix/inode.cbrelse(bh);
bh275fs/minix/inode.cbrelse(bh);
bh288fs/minix/inode.cbrelse (bh);
bh295fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh327fs/minix/inode.cstatic int V1_block_bmap(struct buffer_head * bh, int nr)
bh331fs/minix/inode.cif (!bh)
bh333fs/minix/inode.ctmp = ((unsigned short *) bh->b_data)[nr];
bh334fs/minix/inode.cbrelse(bh);
bh373fs/minix/inode.cstatic int V2_block_bmap(struct buffer_head * bh, int nr)
bh377fs/minix/inode.cif (!bh)
bh379fs/minix/inode.ctmp = ((unsigned long *) bh->b_data)[nr];
bh380fs/minix/inode.cbrelse(bh);
bh477fs/minix/inode.cstruct buffer_head * bh, int nr, int create)
bh483fs/minix/inode.cif (!bh)
bh485fs/minix/inode.cif (!buffer_uptodate(bh)) {
bh486fs/minix/inode.cll_rw_block(READ, 1, &bh);
bh487fs/minix/inode.cwait_on_buffer(bh);
bh488fs/minix/inode.cif (!buffer_uptodate(bh)) {
bh489fs/minix/inode.cbrelse(bh);
bh493fs/minix/inode.cp = nr + (unsigned short *) bh->b_data;
bh497fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh499fs/minix/inode.cbrelse(bh);
bh506fs/minix/inode.cbrelse(bh);
bh511fs/minix/inode.cbrelse(bh);
bh514fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh521fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh522fs/minix/inode.cbrelse(bh);
bh529fs/minix/inode.cstruct buffer_head * bh;
bh543fs/minix/inode.cbh = V1_inode_getblk(inode,7,create);
bh544fs/minix/inode.creturn V1_block_getblk(inode, bh, block, create);
bh547fs/minix/inode.cbh = V1_inode_getblk(inode,8,create);
bh548fs/minix/inode.cbh = V1_block_getblk(inode, bh, (block>>9) & 511, create);
bh549fs/minix/inode.creturn V1_block_getblk(inode, bh, block & 511, create);
bh590fs/minix/inode.cstruct buffer_head * bh, int nr, int create)
bh596fs/minix/inode.cif (!bh)
bh598fs/minix/inode.cif (!buffer_uptodate(bh)) {
bh599fs/minix/inode.cll_rw_block(READ, 1, &bh);
bh600fs/minix/inode.cwait_on_buffer(bh);
bh601fs/minix/inode.cif (!buffer_uptodate(bh)) {
bh602fs/minix/inode.cbrelse(bh);
bh606fs/minix/inode.cp = nr + (unsigned long *) bh->b_data;
bh610fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh612fs/minix/inode.cbrelse(bh);
bh619fs/minix/inode.cbrelse(bh);
bh624fs/minix/inode.cbrelse(bh);
bh627fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh634fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh635fs/minix/inode.cbrelse(bh);
bh642fs/minix/inode.cstruct buffer_head * bh;
bh656fs/minix/inode.cbh = V2_inode_getblk(inode,7,create);
bh657fs/minix/inode.creturn V2_block_getblk(inode, bh, block, create);
bh661fs/minix/inode.cbh = V2_inode_getblk(inode,8,create);
bh662fs/minix/inode.cbh = V2_block_getblk(inode, bh, (block>>8) & 255, create);
bh663fs/minix/inode.creturn V2_block_getblk(inode, bh, block & 255, create);
bh666fs/minix/inode.cbh = V2_inode_getblk(inode,9,create);
bh667fs/minix/inode.cbh = V2_block_getblk(inode, bh, (block >> 16) & 255, create);
bh668fs/minix/inode.cbh = V2_block_getblk(inode, bh, (block >> 8) & 255, create);
bh669fs/minix/inode.creturn V2_block_getblk(inode, bh, block & 255, create);
bh685fs/minix/inode.cstruct buffer_head * bh;
bh687fs/minix/inode.cbh = minix_getblk(inode,block,create);
bh688fs/minix/inode.cif (!bh || buffer_uptodate(bh))
bh689fs/minix/inode.creturn bh;
bh690fs/minix/inode.cll_rw_block(READ, 1, &bh);
bh691fs/minix/inode.cwait_on_buffer(bh);
bh692fs/minix/inode.cif (buffer_uptodate(bh))
bh693fs/minix/inode.creturn bh;
bh694fs/minix/inode.cbrelse(bh);
bh703fs/minix/inode.cstruct buffer_head * bh;
bh719fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
bh724fs/minix/inode.craw_inode = ((struct minix_inode *) bh->b_data) +
bh737fs/minix/inode.cbrelse(bh);
bh757fs/minix/inode.cstruct buffer_head * bh;
bh773fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
bh778fs/minix/inode.craw_inode = ((struct minix2_inode *) bh->b_data) +
bh793fs/minix/inode.cbrelse(bh);
bh824fs/minix/inode.cstruct buffer_head * bh;
bh838fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
bh843fs/minix/inode.craw_inode = ((struct minix_inode *)bh->b_data) +
bh856fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh857fs/minix/inode.creturn bh;
bh865fs/minix/inode.cstruct buffer_head * bh;
bh879fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
bh884fs/minix/inode.craw_inode = ((struct minix2_inode *)bh->b_data) +
bh899fs/minix/inode.cmark_buffer_dirty(bh, 1);
bh900fs/minix/inode.creturn bh;
bh913fs/minix/inode.cstruct buffer_head *bh;
bh915fs/minix/inode.cbh = minix_update_inode(inode);
bh916fs/minix/inode.cbrelse(bh);
bh922fs/minix/inode.cstruct buffer_head *bh;
bh924fs/minix/inode.cbh = minix_update_inode(inode);
bh925fs/minix/inode.cif (bh && buffer_dirty(bh))
bh927fs/minix/inode.cll_rw_block(WRITE, 1, &bh);
bh928fs/minix/inode.cwait_on_buffer(bh);
bh929fs/minix/inode.cif (buffer_req(bh) && !buffer_uptodate(bh))
bh937fs/minix/inode.celse if (!bh)
bh939fs/minix/inode.cbrelse (bh);
bh41fs/minix/namei.cstruct buffer_head * bh, unsigned long * offset,
bh46fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + *offset);
bh68fs/minix/namei.cstruct buffer_head * bh;
bh82fs/minix/namei.cbh = NULL;
bh85fs/minix/namei.cif (!bh) {
bh86fs/minix/namei.cbh = minix_bread(dir,block,0);
bh87fs/minix/namei.cif (!bh) {
bh92fs/minix/namei.c*res_dir = (struct minix_dir_entry *) (bh->b_data + offset);
bh93fs/minix/namei.cif (minix_match(namelen,name,bh,&offset,info))
bh94fs/minix/namei.creturn bh;
bh95fs/minix/namei.cif (offset < bh->b_size)
bh97fs/minix/namei.cbrelse(bh);
bh98fs/minix/namei.cbh = NULL;
bh102fs/minix/namei.cbrelse(bh);
bh112fs/minix/namei.cstruct buffer_head * bh;
bh121fs/minix/namei.cif (!(bh = minix_find_entry(dir,name,len,&de))) {
bh126fs/minix/namei.cbrelse(bh);
bh152fs/minix/namei.cstruct buffer_head * bh;
bh170fs/minix/namei.cbh = NULL;
bh173fs/minix/namei.cif (!bh) {
bh174fs/minix/namei.cbh = minix_bread(dir,block,1);
bh175fs/minix/namei.cif (!bh)
bh178fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
bh180fs/minix/namei.cif (block*bh->b_size + offset > dir->i_size) {
bh182fs/minix/namei.cdir->i_size = block*bh->b_size + offset;
bh187fs/minix/namei.cbrelse(bh);
bh196fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh200fs/minix/namei.cif (offset < bh->b_size)
bh202fs/minix/namei.cbrelse(bh);
bh203fs/minix/namei.cbh = NULL;
bh207fs/minix/namei.c*res_buf = bh;
bh216fs/minix/namei.cstruct buffer_head * bh;
bh230fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
bh239fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh240fs/minix/namei.cbrelse(bh);
bh250fs/minix/namei.cstruct buffer_head * bh;
bh255fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh256fs/minix/namei.cif (bh) {
bh257fs/minix/namei.cbrelse(bh);
bh287fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh296fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh297fs/minix/namei.cbrelse(bh);
bh307fs/minix/namei.cstruct buffer_head * bh, *dir_block;
bh316fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh317fs/minix/namei.cif (bh) {
bh318fs/minix/namei.cbrelse(bh);
bh354fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh362fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh367fs/minix/namei.cbrelse(bh);
bh377fs/minix/namei.cstruct buffer_head * bh;
bh385fs/minix/namei.cbh = NULL;
bh391fs/minix/namei.cbh = minix_bread(inode,0,0);
bh392fs/minix/namei.cif (!bh)
bh394fs/minix/namei.cde = (struct minix_dir_entry *) bh->b_data;
bh397fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + info->s_dirsize);
bh401fs/minix/namei.cif (!bh) {
bh402fs/minix/namei.cbh = minix_bread(inode,block,0);
bh403fs/minix/namei.cif (!bh) {
bh408fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
bh411fs/minix/namei.cbrelse(bh);
bh414fs/minix/namei.cif (offset < bh->b_size)
bh416fs/minix/namei.cbrelse(bh);
bh417fs/minix/namei.cbh = NULL;
bh421fs/minix/namei.cbrelse(bh);
bh424fs/minix/namei.cbrelse(bh);
bh434fs/minix/namei.cstruct buffer_head * bh;
bh438fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh440fs/minix/namei.cif (!bh)
bh473fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh483fs/minix/namei.cbrelse(bh);
bh491fs/minix/namei.cstruct buffer_head * bh;
bh497fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh498fs/minix/namei.cif (!bh)
bh507fs/minix/namei.cbrelse(bh);
bh528fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh536fs/minix/namei.cbrelse(bh);
bh546fs/minix/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh572fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh573fs/minix/namei.cif (bh) {
bh577fs/minix/namei.cbrelse(bh);
bh581fs/minix/namei.ci = minix_add_entry(dir, name, len, &bh, &de);
bh590fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh591fs/minix/namei.cbrelse(bh);
bh601fs/minix/namei.cstruct buffer_head * bh;
bh613fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh614fs/minix/namei.cif (bh) {
bh615fs/minix/namei.cbrelse(bh);
bh620fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh627fs/minix/namei.cmark_buffer_dirty(bh, 1);
bh628fs/minix/namei.cbrelse(bh);
bh47fs/minix/symlink.cstruct buffer_head * bh;
bh68fs/minix/symlink.cif (!(bh = minix_bread(inode, 0, 0))) {
bh75fs/minix/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh77fs/minix/symlink.cbrelse(bh);
bh83fs/minix/symlink.cstruct buffer_head * bh;
bh93fs/minix/symlink.cbh = minix_bread(inode, 0, 0);
bh95fs/minix/symlink.cif (!bh)
bh98fs/minix/symlink.cwhile (i<buflen && (c = bh->b_data[i])) {
bh102fs/minix/symlink.cbrelse(bh);
bh41fs/minix/truncate.cstruct buffer_head * bh;
bh50fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh52fs/minix/truncate.cbrelse(bh);
bh55fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh57fs/minix/truncate.cbrelse(bh);
bh62fs/minix/truncate.cif (bh) {
bh63fs/minix/truncate.cmark_buffer_clean(bh);
bh64fs/minix/truncate.cbrelse(bh);
bh73fs/minix/truncate.cstruct buffer_head * bh;
bh101fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh103fs/minix/truncate.cbrelse(bh);
bh106fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh108fs/minix/truncate.cbrelse(bh);
bh113fs/minix/truncate.cbrelse(bh);
bh203fs/minix/truncate.cstruct buffer_head * bh;
bh212fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh214fs/minix/truncate.cbrelse(bh);
bh217fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh219fs/minix/truncate.cbrelse(bh);
bh224fs/minix/truncate.cif (bh) {
bh225fs/minix/truncate.cmark_buffer_clean(bh);
bh226fs/minix/truncate.cbrelse(bh);
bh235fs/minix/truncate.cstruct buffer_head * bh;
bh263fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh265fs/minix/truncate.cbrelse(bh);
bh268fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh270fs/minix/truncate.cbrelse(bh);
bh275fs/minix/truncate.cbrelse(bh);
bh150fs/msdos/namei.cstruct buffer_head **bh,struct msdos_dir_entry **de,int *ino)
bh172fs/msdos/namei.creturn fat_scan(dir,msdos_name,bh,de,ino,scantype);
bh182fs/msdos/namei.cstruct buffer_head *bh;
bh214fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
bh219fs/msdos/namei.cif (bh) brelse(bh);
bh260fs/msdos/namei.cstruct buffer_head *bh;
bh264fs/msdos/namei.cif ((res = fat_scan(dir,NULL,&bh,&de,&ino,SCAN_ANY)) < 0) {
bh268fs/msdos/namei.cif ((res = fat_scan(dir,NULL,&bh,&de,&ino,SCAN_ANY)) < 0) return res;
bh282fs/msdos/namei.cmark_buffer_dirty(bh, 1);
bh285fs/msdos/namei.cbrelse(bh);
bh299fs/msdos/namei.cstruct buffer_head *bh;
bh317fs/msdos/namei.cif (fat_scan(dir,msdos_name,&bh,&de,&ino,SCAN_HID) >= 0) {
bh319fs/msdos/namei.cbrelse(bh);
bh323fs/msdos/namei.cif (fat_scan(dir,msdos_name,&bh,&de,&ino,SCAN_NOTHID) >= 0) {
bh325fs/msdos/namei.cbrelse(bh);
bh361fs/msdos/namei.cstruct buffer_head *bh;
bh368fs/msdos/namei.cbh = NULL;
bh369fs/msdos/namei.cwhile (fat_get_entry(dir,&pos,&bh,&de) > -1)
bh373fs/msdos/namei.cbrelse(bh);
bh376fs/msdos/namei.cif (bh)
bh377fs/msdos/namei.cbrelse(bh);
bh387fs/msdos/namei.cstruct buffer_head *bh;
bh391fs/msdos/namei.cbh = NULL;
bh396fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
bh412fs/msdos/namei.cmark_buffer_dirty(bh, 1);
bh415fs/msdos/namei.cbrelse(bh);
bh425fs/msdos/namei.cstruct buffer_head *bh;
bh439fs/msdos/namei.cif (fat_scan(dir,msdos_name,&bh,&de,&ino,SCAN_ANY) >= 0) {
bh441fs/msdos/namei.cbrelse(bh);
bh491fs/msdos/namei.cstruct buffer_head *bh;
bh495fs/msdos/namei.cbh = NULL;
bh497fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
bh516fs/msdos/namei.cmark_buffer_dirty(bh, 1);
bh518fs/msdos/namei.cbrelse(bh);
bh34fs/sysv/balloc.cstruct buffer_head * bh;
bh58fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
bh59fs/sysv/balloc.cif (!bh) {
bh64fs/sysv/balloc.cbh_data = bh->b_data;
bh86fs/sysv/balloc.cmark_buffer_dirty(bh, 1);
bh87fs/sysv/balloc.cmark_buffer_uptodate(bh, 1);
bh88fs/sysv/balloc.cbrelse(bh);
bh95fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
bh96fs/sysv/balloc.cif (!bh) {
bh101fs/sysv/balloc.cmemset(bh->b_data, 0, sb->sv_block_size);
bh103fs/sysv/balloc.cmark_buffer_dirty(bh, 1);
bh104fs/sysv/balloc.cmark_buffer_uptodate(bh, 1);
bh105fs/sysv/balloc.cbrelse(bh);
bh109fs/sysv/balloc.cbh = sv_get_hash_table(sb, sb->s_dev, block);
bh110fs/sysv/balloc.cif (bh)
bh111fs/sysv/balloc.cmark_buffer_clean(bh);
bh112fs/sysv/balloc.cbrelse(bh);
bh131fs/sysv/balloc.cstruct buffer_head * bh;
bh160fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh167fs/sysv/balloc.cbh_data = bh->b_data;
bh189fs/sysv/balloc.cbrelse(bh);
bh195fs/sysv/balloc.cbrelse(bh);
bh198fs/sysv/balloc.cbh = sv_getblk(sb, sb->s_dev, block);
bh199fs/sysv/balloc.cif (!bh) {
bh204fs/sysv/balloc.cif (bh->b_count != 1) {
bh209fs/sysv/balloc.cmemset(bh->b_data, 0, sb->sv_block_size);
bh210fs/sysv/balloc.cmark_buffer_dirty(bh, 1);
bh211fs/sysv/balloc.cmark_buffer_uptodate(bh, 1);
bh212fs/sysv/balloc.cbrelse(bh);
bh230fs/sysv/balloc.cstruct buffer_head * bh;
bh257fs/sysv/balloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh261fs/sysv/balloc.cbh_data = bh->b_data;
bh283fs/sysv/balloc.cbrelse(bh);
bh287fs/sysv/balloc.cbrelse(bh);
bh301fs/sysv/balloc.cbrelse(bh);
bh72fs/sysv/dir.cstruct buffer_head * bh;
bh82fs/sysv/dir.cbh = sysv_file_bread(inode, filp->f_pos >> sb->sv_block_size_bits, 0);
bh83fs/sysv/dir.cif (!bh) {
bh87fs/sysv/dir.cbh_data = bh->b_data;
bh104fs/sysv/dir.cbrelse(bh);
bh111fs/sysv/dir.cbrelse(bh);
bh207fs/sysv/file.cstruct buffer_head * bh;
bh231fs/sysv/file.cbh = sysv_getblk (inode, pos >> sb->sv_block_size_bits, 1);
bh232fs/sysv/file.cif (!bh) {
bh240fs/sysv/file.cif (c != sb->sv_block_size && !buffer_uptodate(bh)) {
bh241fs/sysv/file.cll_rw_block(READ, 1, &bh);
bh242fs/sysv/file.cwait_on_buffer(bh);
bh243fs/sysv/file.cif (!buffer_uptodate(bh)) {
bh244fs/sysv/file.cbrelse(bh);
bh251fs/sysv/file.cp = (pos & sb->sv_block_size_1) + bh->b_data;
bh261fs/sysv/file.cmark_buffer_uptodate(bh, 1);
bh262fs/sysv/file.cmark_buffer_dirty(bh, 0);
bh263fs/sysv/file.cbrelse(bh);
bh31fs/sysv/fsync.cstruct buffer_head * bh;
bh41fs/sysv/fsync.cbh = sv_get_hash_table(sb, inode->i_dev, block);
bh42fs/sysv/fsync.cif (!bh)
bh45fs/sysv/fsync.cbrelse (bh);
bh48fs/sysv/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
bh49fs/sysv/fsync.cbrelse(bh);
bh52fs/sysv/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh)) {
bh53fs/sysv/fsync.cbrelse(bh);
bh56fs/sysv/fsync.cll_rw_block(WRITE, 1, &bh);
bh57fs/sysv/fsync.cbh->b_count--;
bh63fs/sysv/fsync.cstruct buffer_head * *bh, int wait)
bh68fs/sysv/fsync.c*bh = NULL;
bh77fs/sysv/fsync.c*bh = sv_bread(inode->i_sb, inode->i_dev, block);
bh79fs/sysv/fsync.cbrelse(*bh);
bh80fs/sysv/fsync.c*bh = NULL;
bh83fs/sysv/fsync.cif (!*bh)
bh56fs/sysv/ialloc.cstruct buffer_head * bh;
bh82fs/sysv/ialloc.cif (!(bh = sv_bread(sb, inode->i_dev, sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits)))) {
bh88fs/sysv/ialloc.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
bh97fs/sysv/ialloc.cmark_buffer_dirty(bh, 1);
bh99fs/sysv/ialloc.cbrelse(bh);
bh107fs/sysv/ialloc.cstruct buffer_head * bh;
bh128fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh133fs/sysv/ialloc.craw_inode = (struct sysv_inode *) bh->b_data + j;
bh138fs/sysv/ialloc.cbrelse(bh);
bh180fs/sysv/ialloc.cstruct buffer_head * bh;
bh194fs/sysv/ialloc.cif (!(bh = sv_bread(sb, sb->s_dev, block))) {
bh199fs/sysv/ialloc.craw_inode = (struct sysv_inode *) bh->b_data + j;
bh203fs/sysv/ialloc.cbrelse(bh);
bh119fs/sysv/inode.cstatic const char* detect_xenix (struct super_block *sb, struct buffer_head *bh)
bh123fs/sysv/inode.csbd = (struct xenix_super_block *) bh->b_data;
bh176fs/sysv/inode.cstatic const char* detect_sysv4 (struct super_block *sb, struct buffer_head *bh)
bh180fs/sysv/inode.csbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh193fs/sysv/inode.cstatic struct super_block * detected_sysv4 (struct super_block *sb, struct buffer_head *bh)
bh198fs/sysv/inode.csbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh200fs/sysv/inode.csbd = (struct sysv4_super_block *) bh->b_data;
bh214fs/sysv/inode.csb->sv_bh1 = bh;
bh215fs/sysv/inode.csb->sv_bh2 = bh;
bh234fs/sysv/inode.cstatic const char* detect_sysv2 (struct super_block *sb, struct buffer_head *bh)
bh238fs/sysv/inode.csbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh251fs/sysv/inode.cstatic struct super_block * detected_sysv2 (struct super_block *sb, struct buffer_head *bh)
bh256fs/sysv/inode.csbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh258fs/sysv/inode.csbd = (struct sysv2_super_block *) bh->b_data;
bh272fs/sysv/inode.csb->sv_bh1 = bh;
bh273fs/sysv/inode.csb->sv_bh2 = bh;
bh292fs/sysv/inode.cstatic const char* detect_coherent (struct super_block *sb, struct buffer_head *bh)
bh296fs/sysv/inode.csbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2);
bh304fs/sysv/inode.cstatic struct super_block * detected_coherent (struct super_block *sb, struct buffer_head *bh)
bh308fs/sysv/inode.csbd = (struct coh_super_block *) bh->b_data;
bh320fs/sysv/inode.csb->sv_bh1 = bh;
bh321fs/sysv/inode.csb->sv_bh2 = bh;
bh342fs/sysv/inode.cstruct buffer_head *bh;
bh360fs/sysv/inode.cif ((bh = bread(dev, 1, BLOCK_SIZE)) != NULL) {
bh361fs/sysv/inode.cif ((found = detect_xenix(sb,bh)) != NULL)
bh363fs/sysv/inode.cbrelse(bh);
bh365fs/sysv/inode.cif ((bh = bread(dev, 0, BLOCK_SIZE)) != NULL) {
bh367fs/sysv/inode.cif ((found = detect_sysv4(sb,bh)) != NULL)
bh369fs/sysv/inode.cif ((found = detect_sysv2(sb,bh)) != NULL)
bh372fs/sysv/inode.cif ((found = detect_coherent(sb,bh)) != NULL)
bh374fs/sysv/inode.cbrelse(bh);
bh381fs/sysv/inode.cif ((bh = bread(dev, offsets[i], BLOCK_SIZE)) != NULL) {
bh383fs/sysv/inode.cif ((found = detect_sysv4(sb,bh)) != NULL) {
bh387fs/sysv/inode.cif ((found = detect_sysv2(sb,bh)) != NULL) {
bh391fs/sysv/inode.cbrelse(bh);
bh407fs/sysv/inode.cif (!detected_xenix(sb,bh,bh))
bh411fs/sysv/inode.cif (!detected_sysv4(sb,bh))
bh415fs/sysv/inode.cif (!detected_sysv2(sb,bh))
bh420fs/sysv/inode.cbrelse(bh);
bh430fs/sysv/inode.cunsigned long blocknr = bh->b_blocknr << sb->sv_block_size_ratio_bits;
bh432fs/sysv/inode.cbrelse(bh);
bh562fs/sysv/inode.cstatic int block_bmap(struct super_block * sb, struct buffer_head * bh, int nr, int convert)
bh566fs/sysv/inode.cif (!bh)
bh568fs/sysv/inode.ctmp = ((sysv_zone_t *) bh->b_data) [nr];
bh571fs/sysv/inode.cbrelse(bh);
bh583fs/sysv/inode.cstruct buffer_head * bh;
bh593fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh594fs/sysv/inode.creturn block_bmap(sb, bh, block, convert);
bh601fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh602fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_bits, convert);
bh605fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh606fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
bh613fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh614fs/sysv/inode.ci = block_bmap(sb, bh, block >> sb->sv_ind_per_block_2_bits, 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_bits) & sb->sv_ind_per_block_1,convert);
bh621fs/sysv/inode.cbh = bread(inode->i_dev,i,sb->sv_block_size);
bh622fs/sysv/inode.creturn block_bmap(sb, bh, block & sb->sv_ind_per_block_1, convert);
bh673fs/sysv/inode.cstruct buffer_head * bh, int nr, int create)
bh680fs/sysv/inode.cif (!bh)
bh682fs/sysv/inode.cif (!buffer_uptodate(bh)) {
bh683fs/sysv/inode.cll_rw_block(READ, 1, &bh);
bh684fs/sysv/inode.cwait_on_buffer(bh);
bh685fs/sysv/inode.cif (!buffer_uptodate(bh)) {
bh686fs/sysv/inode.cbrelse(bh);
bh691fs/sysv/inode.cp = nr + (sysv_zone_t *) bh->b_data;
bh697fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
bh699fs/sysv/inode.cbrelse(bh);
bh706fs/sysv/inode.cbrelse(bh);
bh711fs/sysv/inode.cbrelse(bh);
bh714fs/sysv/inode.cresult = sv_getblk(sb, bh->b_dev, block);
bh721fs/sysv/inode.cmark_buffer_dirty(bh, 1);
bh722fs/sysv/inode.cbrelse(bh);
bh729fs/sysv/inode.cstruct buffer_head * bh;
bh735fs/sysv/inode.cbh = inode_getblk(inode,10,create);
bh736fs/sysv/inode.creturn block_getblk(inode, bh, block, create);
bh740fs/sysv/inode.cbh = inode_getblk(inode,11,create);
bh741fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_bits, create);
bh742fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
bh746fs/sysv/inode.cbh = inode_getblk(inode,12,create);
bh747fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_2_bits, create);
bh748fs/sysv/inode.cbh = block_getblk(inode, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1, create);
bh749fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create);
bh761fs/sysv/inode.cstruct buffer_head * bh;
bh763fs/sysv/inode.cbh = sysv_getblk(inode,block,create);
bh764fs/sysv/inode.cif (!bh || buffer_uptodate(bh))
bh765fs/sysv/inode.creturn bh;
bh766fs/sysv/inode.cll_rw_block(READ, 1, &bh);
bh767fs/sysv/inode.cwait_on_buffer(bh);
bh768fs/sysv/inode.cif (buffer_uptodate(bh))
bh769fs/sysv/inode.creturn bh;
bh770fs/sysv/inode.cbrelse(bh);
bh802fs/sysv/inode.cstruct buffer_head * bh;
bh817fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
bh823fs/sysv/inode.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
bh855fs/sysv/inode.cbrelse(bh);
bh891fs/sysv/inode.cstruct buffer_head * bh;
bh905fs/sysv/inode.cif (!(bh = sv_bread(sb,inode->i_dev,block))) {
bh910fs/sysv/inode.craw_inode = (struct sysv_inode *) bh->b_data + ((ino-1) & sb->sv_inodes_per_block_1);
bh939fs/sysv/inode.cmark_buffer_dirty(bh, 1);
bh940fs/sysv/inode.creturn bh;
bh945fs/sysv/inode.cstruct buffer_head *bh;
bh946fs/sysv/inode.cbh = sysv_update_inode(inode);
bh947fs/sysv/inode.cbrelse(bh);
bh953fs/sysv/inode.cstruct buffer_head *bh;
bh955fs/sysv/inode.cbh = sysv_update_inode(inode);
bh956fs/sysv/inode.cif (bh && buffer_dirty(bh)) {
bh957fs/sysv/inode.cll_rw_block(WRITE, 1, &bh);
bh958fs/sysv/inode.cwait_on_buffer(bh);
bh959fs/sysv/inode.cif (buffer_req(bh) && !buffer_uptodate(bh))
bh967fs/sysv/inode.celse if (!bh)
bh969fs/sysv/inode.cbrelse (bh);
bh65fs/sysv/namei.cstruct buffer_head * bh;
bh76fs/sysv/namei.cbh = NULL;
bh79fs/sysv/namei.cif (!bh) {
bh80fs/sysv/namei.cbh = sysv_file_bread(dir,block,0);
bh81fs/sysv/namei.cif (!bh) {
bh88fs/sysv/namei.c*res_dir = (struct sysv_dir_entry *) (bh->b_data + offset) ))
bh89fs/sysv/namei.creturn bh;
bh94fs/sysv/namei.cbrelse(bh);
bh95fs/sysv/namei.cbh = NULL;
bh98fs/sysv/namei.cbrelse(bh);
bh108fs/sysv/namei.cstruct buffer_head * bh;
bh117fs/sysv/namei.cif (!(bh = sysv_find_entry(dir,name,len,&de))) {
bh122fs/sysv/namei.cbrelse(bh);
bh149fs/sysv/namei.cstruct buffer_head * bh;
bh164fs/sysv/namei.cbh = NULL;
bh167fs/sysv/namei.cif (!bh) {
bh168fs/sysv/namei.cbh = sysv_file_bread(dir,block,1);
bh169fs/sysv/namei.cif (!bh)
bh172fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + offset);
bh182fs/sysv/namei.cbrelse(bh);
bh190fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh196fs/sysv/namei.cbrelse(bh);
bh197fs/sysv/namei.cbh = NULL;
bh200fs/sysv/namei.c*res_buf = bh;
bh209fs/sysv/namei.cstruct buffer_head * bh;
bh223fs/sysv/namei.cerror = sysv_add_entry(dir,name,len, &bh ,&de);
bh232fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh233fs/sysv/namei.cbrelse(bh);
bh243fs/sysv/namei.cstruct buffer_head * bh;
bh248fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh249fs/sysv/namei.cif (bh) {
bh250fs/sysv/namei.cbrelse(bh);
bh280fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
bh289fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh290fs/sysv/namei.cbrelse(bh);
bh300fs/sysv/namei.cstruct buffer_head * bh, *dir_block;
bh307fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh308fs/sysv/namei.cif (bh) {
bh309fs/sysv/namei.cbrelse(bh);
bh345fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
bh353fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh358fs/sysv/namei.cbrelse(bh);
bh369fs/sysv/namei.cstruct buffer_head * bh;
bh375fs/sysv/namei.cbh = NULL;
bh381fs/sysv/namei.cbh = sysv_file_bread(inode,0,0);
bh382fs/sysv/namei.cif (!bh)
bh384fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + 0*SYSV_DIRSIZE);
bh387fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + 1*SYSV_DIRSIZE);
bh392fs/sysv/namei.cif (!bh) {
bh393fs/sysv/namei.cbh = sysv_file_bread(inode,block,0);
bh394fs/sysv/namei.cif (!bh) {
bh400fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + offset);
bh404fs/sysv/namei.cbrelse(bh);
bh409fs/sysv/namei.cbrelse(bh);
bh410fs/sysv/namei.cbh = NULL;
bh413fs/sysv/namei.cbrelse(bh);
bh416fs/sysv/namei.cbrelse(bh);
bh426fs/sysv/namei.cstruct buffer_head * bh;
bh430fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh432fs/sysv/namei.cif (!bh)
bh464fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh474fs/sysv/namei.cbrelse(bh);
bh482fs/sysv/namei.cstruct buffer_head * bh;
bh488fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh489fs/sysv/namei.cif (!bh)
bh498fs/sysv/namei.cbrelse(bh);
bh518fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh526fs/sysv/namei.cbrelse(bh);
bh541fs/sysv/namei.cstruct buffer_head * bh;
bh567fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh568fs/sysv/namei.cif (bh) {
bh572fs/sysv/namei.cbrelse(bh);
bh576fs/sysv/namei.ci = sysv_add_entry(dir, name, len, &bh, &de);
bh585fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh586fs/sysv/namei.cbrelse(bh);
bh596fs/sysv/namei.cstruct buffer_head * bh;
bh608fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
bh609fs/sysv/namei.cif (bh) {
bh610fs/sysv/namei.cbrelse(bh);
bh615fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
bh622fs/sysv/namei.cmark_buffer_dirty(bh, 1);
bh623fs/sysv/namei.cbrelse(bh);
bh53fs/sysv/symlink.cstruct buffer_head * bh;
bh74fs/sysv/symlink.cif (!(bh = sysv_file_bread(inode, 0, 0))) { /* is reading 1 block enough ?? */
bh81fs/sysv/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh83fs/sysv/symlink.cbrelse(bh);
bh89fs/sysv/symlink.cstruct buffer_head * bh;
bh100fs/sysv/symlink.cbh = sysv_file_bread(inode, 0, 0);
bh102fs/sysv/symlink.cif (!bh)
bh104fs/sysv/symlink.cbh_data = bh->b_data;
bh110fs/sysv/symlink.cbrelse(bh);
bh46fs/sysv/truncate.cstruct buffer_head * bh;
bh56fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
bh58fs/sysv/truncate.cbrelse(bh);
bh61fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (block != *p)) {
bh63fs/sysv/truncate.cbrelse(bh);
bh68fs/sysv/truncate.cbrelse(bh);
bh82fs/sysv/truncate.cstruct buffer_head * bh;
bh113fs/sysv/truncate.cbh = sv_get_hash_table(sb, inode->i_dev, block);
bh115fs/sysv/truncate.cbrelse(bh);
bh118fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (tmp != *ind)) {
bh120fs/sysv/truncate.cbrelse(bh);
bh125fs/sysv/truncate.cbrelse(bh);
bh36fs/ufs/ufs_dir.cstruct buffer_head * bh;
bh51fs/ufs/ufs_dir.cbh = NULL;
bh59fs/ufs/ufs_dir.cbh = bread (sb->s_dev, blk, sb->s_blocksize);
bh60fs/ufs/ufs_dir.cif (!bh) {
bh76fs/ufs/ufs_dir.c(bh->b_data + i);
bh95fs/ufs/ufs_dir.cde = (struct direct *) (bh->b_data + offset);
bh99fs/ufs/ufs_dir.cbrelse(bh);
bh104fs/ufs/ufs_dir.cbh, offset)) {
bh109fs/ufs/ufs_dir.cbrelse (bh);
bh139fs/ufs/ufs_dir.cbrelse (bh);
bh23fs/ufs/ufs_file.cstruct buffer_head * bh;
bh75fs/ufs/ufs_file.cbh = bread(inode->i_dev, inode->u.ufs_i.ui_ib[0],
bh77fs/ufs/ufs_file.cif (bh == NULL) {
bh82fs/ufs/ufs_file.cphys_block = ((__u32 *)bh->b_data)[block];
bh83fs/ufs/ufs_file.cbrelse(bh);
bh45fs/ufs/ufs_inode.cstruct buffer_head * bh;
bh61fs/ufs/ufs_inode.cbh = bread(inode->i_dev,
bh65fs/ufs/ufs_inode.cif (!bh) {
bh71fs/ufs/ufs_inode.cufsip = (struct ufs_inode *)bh->b_data;
bh200fs/ufs/ufs_inode.cbrelse(bh);
bh41fs/ufs/ufs_namei.cstruct buffer_head * bh;
bh104fs/ufs/ufs_namei.cbh = bread(dir->i_dev, fragno, dir->i_sb->s_blocksize);
bh105fs/ufs/ufs_namei.cif (bh == NULL) {
bh110fs/ufs/ufs_namei.cd = (struct direct *)(bh->b_data);
bh111fs/ufs/ufs_namei.cwhile (((char *)d - bh->b_data + d->d_reclen) <=
bh130fs/ufs/ufs_namei.cbrelse(bh);
bh141fs/ufs/ufs_namei.cbrelse(bh);
bh22fs/ufs/ufs_symlink.cstruct buffer_head * bh = NULL;
bh45fs/ufs/ufs_symlink.cbh = bread(inode->i_dev, block, BLOCK_SIZE);
bh46fs/ufs/ufs_symlink.cif (!bh) {
bh53fs/ufs/ufs_symlink.clink = bh->b_data;
bh64fs/ufs/ufs_symlink.cif (bh)
bh65fs/ufs/ufs_symlink.cbrelse (bh);
bh80fs/ufs/ufs_symlink.cstruct buffer_head * bh;
bh83fs/ufs/ufs_symlink.cbh = NULL;
bh113fs/ufs/ufs_symlink.cbh = bread(inode->i_dev, block, BLOCK_SIZE);
bh114fs/ufs/ufs_symlink.cif (bh == NULL) {
bh122fs/ufs/ufs_symlink.clink = bh->b_data;
bh131fs/ufs/ufs_symlink.cif (bh) {
bh132fs/ufs/ufs_symlink.cbrelse (bh);
bh547fs/vfat/namei.cstruct buffer_head *bh;
bh557fs/vfat/namei.cbh = NULL;
bh559fs/vfat/namei.cino = fat_get_entry(dir,&curr,&bh,&de);
bh576fs/vfat/namei.cbrelse(bh);
bh584fs/vfat/namei.cino = fat_get_entry(dir,&curr,&bh,&de);
bh589fs/vfat/namei.cino = fat_get_entry(dir,&curr,&bh,&de);
bh808fs/vfat/namei.cstruct buffer_head *bh;
bh851fs/vfat/namei.cbh = NULL;
bh862fs/vfat/namei.cbh = NULL;
bh865fs/vfat/namei.csinfo_out->ino = fat_get_entry(dir,&offset,&bh,&de);
bh871fs/vfat/namei.cmark_buffer_dirty(bh, 1);
bh891fs/vfat/namei.cmark_buffer_dirty(bh, 1);
bh892fs/vfat/namei.cbrelse(bh);
bh985fs/vfat/namei.cstruct buffer_head *bh;
bh998fs/vfat/namei.cbh = NULL;
bh999fs/vfat/namei.cino = fat_get_entry(dir, &offset, &bh, &de);
bh1002fs/vfat/namei.cif (bh) brelse(bh);
bh1009fs/vfat/namei.cbrelse(bh);
bh1038fs/vfat/namei.cstruct buffer_head *bh,
bh1061fs/vfat/namei.cmark_buffer_dirty(bh, 1);
bh1087fs/vfat/namei.cstruct buffer_head *bh;
bh1096fs/vfat/namei.cbh = NULL;
bh1097fs/vfat/namei.cif ((res = fat_get_entry(dir,&offset,&bh,&de)) < 0) return res;
bh1100fs/vfat/namei.cres = vfat_create_a_dotdir(dir, parent, bh, de, res, MSDOS_DOT, 1);
bh1103fs/vfat/namei.cbrelse(bh);
bh1108fs/vfat/namei.cif ((res = fat_get_entry(dir,&offset,&bh,&de)) < 0) {
bh1109fs/vfat/namei.cbrelse(bh);
bh1114fs/vfat/namei.cres = vfat_create_a_dotdir(dir, parent, bh, de, res, MSDOS_DOTDOT, 0);
bh1116fs/vfat/namei.cbrelse(bh);
bh1126fs/vfat/namei.cstruct buffer_head *bh;
bh1133fs/vfat/namei.cbh = NULL;
bh1134fs/vfat/namei.cwhile (fat_get_entry(dir,&pos,&bh,&de) > -1) {
bh1141fs/vfat/namei.cbrelse(bh);
bh1145fs/vfat/namei.cif (bh)
bh1146fs/vfat/namei.cbrelse(bh);
bh1151fs/vfat/namei.cstatic int vfat_rmdir_free_ino(struct inode *dir,struct buffer_head *bh,
bh1179fs/vfat/namei.cmark_buffer_dirty(bh, 1);
bh1185fs/vfat/namei.cstatic int vfat_unlink_free_ino(struct inode *dir,struct buffer_head *bh,
bh1202fs/vfat/namei.cmark_buffer_dirty(bh, 1);
bh1209fs/vfat/namei.cstruct buffer_head **bh,struct msdos_dir_entry **de,
bh1218fs/vfat/namei.cres = fat_get_entry(dir, &offset, bh, de);
bh1221fs/vfat/namei.cres = vfat_rmdir_free_ino(dir,*bh,*de,res);
bh1223fs/vfat/namei.cres = vfat_unlink_free_ino(dir,*bh,*de,res,nospc);
bh1230fs/vfat/namei.cres = fat_get_entry(dir, &offset, bh, de);
bh1237fs/vfat/namei.cmark_buffer_dirty(*bh, 1);
bh1247fs/vfat/namei.cstruct buffer_head *bh;
bh1251fs/vfat/namei.cbh = NULL;
bh1258fs/vfat/namei.cres = vfat_remove_entry(dir,&sinfo,&bh,&de,1,0);
bh1268fs/vfat/namei.cbrelse(bh);
bh1290fs/vfat/namei.cstruct buffer_head *bh;
bh1294fs/vfat/namei.cbh = NULL;
bh1299fs/vfat/namei.cres = vfat_remove_entry(dir,&sinfo,&bh,&de,0,nospc);
bh1308fs/vfat/namei.cbrelse(bh);
bh28fs/xiafs/bitmap.cstatic int find_first_zero(struct buffer_head *bh, int start_bit, int end_bit) 
bh39fs/xiafs/bitmap.cbmap=(u_long *)bh->b_data;
bh61fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh65fs/xiafs/bitmap.cstatic void clear_buf(struct buffer_head * bh) 
bh70fs/xiafs/bitmap.clp=(long *)bh->b_data;
bh71fs/xiafs/bitmap.cfor (i= bh->b_size >> 2; i-- > 0; )
bh172fs/xiafs/bitmap.cstruct buffer_head * bh;
bh195fs/xiafs/bitmap.cbh = get__map_zone(sb, bmap_buf, bznr, cache, first_zone, 
bh197fs/xiafs/bitmap.cif (!bh)
bh199fs/xiafs/bitmap.ctmp=find_first_zero(bh, start_bit, end_bit);
bh216fs/xiafs/bitmap.cstruct buffer_head * bh;
bh228fs/xiafs/bitmap.cbh = get_hash_table(sb->s_dev, d_addr, XIAFS_ZSIZE(sb));
bh229fs/xiafs/bitmap.cif (bh)
bh230fs/xiafs/bitmap.cmark_buffer_clean(bh);
bh231fs/xiafs/bitmap.cbrelse(bh);
bh233fs/xiafs/bitmap.cbh = get_zmap_zone(sb, bit, NULL);
bh234fs/xiafs/bitmap.cif (!bh)
bh237fs/xiafs/bitmap.cif (!clear_bit(offset, bh->b_data))
bh241fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh247fs/xiafs/bitmap.cstruct buffer_head * bh;
bh263fs/xiafs/bitmap.cif (!(bh = getblk(sb->s_dev, tmp, XIAFS_ZSIZE(sb)))) {
bh267fs/xiafs/bitmap.cif (bh->b_count != 1) {
bh271fs/xiafs/bitmap.cclear_buf(bh);
bh272fs/xiafs/bitmap.cmark_buffer_uptodate(bh, 1);
bh273fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh274fs/xiafs/bitmap.cbrelse(bh);
bh280fs/xiafs/bitmap.cstruct buffer_head * bh;
bh294fs/xiafs/bitmap.cbh = get_imap_zone(sb, ino, NULL);
bh295fs/xiafs/bitmap.cif (!bh)
bh298fs/xiafs/bitmap.cif (!clear_bit(ino & (XIAFS_BITS_PER_Z(sb)-1), bh->b_data))
bh302fs/xiafs/bitmap.cmark_buffer_dirty(bh, 1);
bh340fs/xiafs/bitmap.cstatic u_long count_zone(struct buffer_head * bh)
bh346fs/xiafs/bitmap.cfor (i=bh->b_size; i-- > 0; ) {
bh347fs/xiafs/bitmap.ctmp=bh->b_data[i];
bh355fs/xiafs/bitmap.cstruct buffer_head * bh;
bh362fs/xiafs/bitmap.cbh=get_imap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
bh363fs/xiafs/bitmap.cif (bh) {
bh364fs/xiafs/bitmap.csum += count_zone(bh);
bh374fs/xiafs/bitmap.cstruct buffer_head * bh;
bh381fs/xiafs/bitmap.cbh=get_zmap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
bh382fs/xiafs/bitmap.cif (bh) {
bh383fs/xiafs/bitmap.csum += count_zone(bh);
bh72fs/xiafs/dir.cstruct buffer_head * bh;
bh81fs/xiafs/dir.cbh = xiafs_bread(inode, filp->f_pos >> XIAFS_ZSIZE_BITS(inode->i_sb),0);
bh82fs/xiafs/dir.cif (!bh) {
bh87fs/xiafs/dir.cde = (struct xiafs_direct *) (bh->b_data + i);
bh93fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
bh98fs/xiafs/dir.c(char *)de+de->d_rec_len > XIAFS_ZSIZE(inode->i_sb)+bh->b_data ||
bh103fs/xiafs/dir.cbrelse(bh);
bh112fs/xiafs/dir.cbrelse(bh);
bh118fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
bh120fs/xiafs/dir.cbrelse(bh);
bh197fs/xiafs/file.cstruct buffer_head * bh;
bh218fs/xiafs/file.cbh = xiafs_getblk(inode, pos >> XIAFS_ZSIZE_BITS(inode->i_sb), 1);
bh219fs/xiafs/file.cif (!bh) {
bh227fs/xiafs/file.cif (c != XIAFS_ZSIZE(inode->i_sb) && !buffer_uptodate(bh)) {
bh228fs/xiafs/file.cll_rw_block(READ, 1, &bh);
bh229fs/xiafs/file.cwait_on_buffer(bh);
bh230fs/xiafs/file.cif (!buffer_uptodate(bh)) {
bh231fs/xiafs/file.cbrelse(bh);
bh237fs/xiafs/file.ccp = (pos & (XIAFS_ZSIZE(inode->i_sb)-1)) + bh->b_data;
bh247fs/xiafs/file.cmark_buffer_uptodate(bh, 1);
bh248fs/xiafs/file.cmark_buffer_dirty(bh, 0);
bh249fs/xiafs/file.cbrelse(bh);
bh31fs/xiafs/fsync.cstruct buffer_head * bh;
bh37fs/xiafs/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh38fs/xiafs/fsync.cif (!bh)
bh41fs/xiafs/fsync.cbrelse (bh);
bh44fs/xiafs/fsync.cif (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
bh45fs/xiafs/fsync.cbrelse(bh);
bh48fs/xiafs/fsync.cif (wait || !buffer_uptodate(bh) || !buffer_dirty(bh))
bh50fs/xiafs/fsync.cbrelse(bh);
bh53fs/xiafs/fsync.cll_rw_block(WRITE, 1, &bh);
bh54fs/xiafs/fsync.cbh->b_count--;
bh59fs/xiafs/fsync.cstruct buffer_head **bh, int wait) 
bh63fs/xiafs/fsync.c*bh = NULL;
bh70fs/xiafs/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh72fs/xiafs/fsync.cbrelse(*bh);
bh73fs/xiafs/fsync.c*bh = NULL;
bh76fs/xiafs/fsync.cif (!*bh)
bh65fs/xiafs/inode.cstruct buffer_head *bh;
bh76fs/xiafs/inode.cif (!(bh = bread(dev, 0, BLOCK_SIZE))) {
bh83fs/xiafs/inode.csp = (struct xiafs_super_block *) bh->b_data;
bh88fs/xiafs/inode.cbrelse(bh);
bh100fs/xiafs/inode.cbrelse(bh);
bh102fs/xiafs/inode.cbh = bread (dev, 0,  s->s_blocksize);
bh103fs/xiafs/inode.cif(!bh) {
bh107fs/xiafs/inode.csp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
bh117fs/xiafs/inode.cbrelse(bh);
bh184fs/xiafs/inode.cstatic int zone_bmap(struct buffer_head * bh, int nr)
bh188fs/xiafs/inode.cif (!bh)
bh190fs/xiafs/inode.ctmp = ((u_long *) bh->b_data)[nr];
bh191fs/xiafs/inode.cbrelse(bh);
bh274fs/xiafs/inode.cindt_getblk(struct inode * inode, struct buffer_head * bh, 
bh281fs/xiafs/inode.cif (!bh)
bh283fs/xiafs/inode.cif (!buffer_uptodate(bh)) {
bh284fs/xiafs/inode.cll_rw_block(READ, 1, &bh);
bh285fs/xiafs/inode.cwait_on_buffer(bh);
bh286fs/xiafs/inode.cif (!buffer_uptodate(bh)) {
bh287fs/xiafs/inode.cbrelse(bh);
bh291fs/xiafs/inode.clp = nr + (u_long *) bh->b_data;
bh294fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh296fs/xiafs/inode.cbrelse(bh);
bh303fs/xiafs/inode.cbrelse(bh);
bh308fs/xiafs/inode.cbrelse(bh);
bh311fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh319fs/xiafs/inode.cmark_buffer_dirty(bh, 1);
bh320fs/xiafs/inode.cbrelse(bh);
bh326fs/xiafs/inode.cstruct buffer_head * bh;
bh344fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_ind_zone), create, prev_addr);
bh345fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone, create, prev_addr);
bh346fs/xiafs/inode.creturn bh;
bh349fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_dind_zone), create, prev_addr);
bh350fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb), 
bh352fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone&(XIAFS_ADDRS_PER_Z(inode->i_sb)-1), 
bh354fs/xiafs/inode.creturn bh;
bh359fs/xiafs/inode.cstruct buffer_head * bh;
bh361fs/xiafs/inode.cbh = xiafs_getblk(inode, zone, create);
bh362fs/xiafs/inode.cif (!bh || buffer_uptodate(bh))
bh363fs/xiafs/inode.creturn bh;
bh364fs/xiafs/inode.cll_rw_block(READ, 1, &bh);
bh365fs/xiafs/inode.cwait_on_buffer(bh);
bh366fs/xiafs/inode.cif (buffer_uptodate(bh))
bh367fs/xiafs/inode.creturn bh;
bh368fs/xiafs/inode.cbrelse(bh);
bh374fs/xiafs/inode.cstruct buffer_head * bh;
bh389fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
bh393fs/xiafs/inode.craw_inode = ((struct xiafs_inode *) bh->b_data) + 
bh414fs/xiafs/inode.cbrelse(bh);
bh431fs/xiafs/inode.cstruct buffer_head * bh;
bh451fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
bh456fs/xiafs/inode.craw_inode = ((struct xiafs_inode *)bh->b_data) +
bh479fs/xiafs/inode.cmark_buffer_dirty(bh, 1);
bh480fs/xiafs/inode.creturn bh;
bh486fs/xiafs/inode.cstruct buffer_head * bh;
bh487fs/xiafs/inode.cbh = xiafs_update_inode(inode);
bh488fs/xiafs/inode.cbrelse (bh);
bh494fs/xiafs/inode.cstruct buffer_head *bh;
bh496fs/xiafs/inode.cbh = xiafs_update_inode(inode);
bh497fs/xiafs/inode.cif (bh && buffer_dirty(bh))
bh499fs/xiafs/inode.cll_rw_block(WRITE, 1, &bh);
bh500fs/xiafs/inode.cwait_on_buffer(bh);
bh501fs/xiafs/inode.cif (buffer_req(bh) && !buffer_uptodate(bh))
bh508fs/xiafs/inode.celse if (!bh)
bh510fs/xiafs/inode.cbrelse (bh);
bh62fs/xiafs/namei.cstruct buffer_head * bh;
bh77fs/xiafs/namei.cbh = xiafs_bread(inode, i, 0);
bh78fs/xiafs/namei.cif (!bh)
bh80fs/xiafs/namei.cdep_pre=dep=(struct xiafs_direct *)bh->b_data;
bh84fs/xiafs/namei.cbrelse(bh);
bh91fs/xiafs/namei.cdep->d_rec_len+(char *)dep > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
bh94fs/xiafs/namei.cbrelse(bh);
bh101fs/xiafs/namei.creturn bh;
bh105fs/xiafs/namei.cdep=(struct xiafs_direct *)(bh->b_data + pos);
bh107fs/xiafs/namei.cbrelse(bh);
bh121fs/xiafs/namei.cstruct buffer_head * bh;
bh130fs/xiafs/namei.cif (!(bh = xiafs_find_entry(dir, name, len, &dep, NULL))) {
bh135fs/xiafs/namei.cbrelse(bh);
bh159fs/xiafs/namei.cstruct buffer_head * bh;
bh172fs/xiafs/namei.cbh =  xiafs_bread(dir, pos >> XIAFS_ZSIZE_BITS(dir->i_sb), pos ? 1:0);
bh173fs/xiafs/namei.cif (!bh)
bh175fs/xiafs/namei.cde_pre=de=(struct xiafs_direct *)bh->b_data;
bh180fs/xiafs/namei.cbrelse(bh);
bh184fs/xiafs/namei.cde_pre=de=(struct xiafs_direct *)(bh->b_data+12);
bh198fs/xiafs/namei.c(char *)de+de->d_rec_len > bh->b_data+XIAFS_ZSIZE(dir->i_sb) ||
bh202fs/xiafs/namei.cbrelse(bh);
bh225fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh229fs/xiafs/namei.creturn bh;
bh233fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
bh235fs/xiafs/namei.cbrelse(bh);
bh249fs/xiafs/namei.cstruct buffer_head * bh;
bh263fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh264fs/xiafs/namei.cif (!bh) {
bh272fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh273fs/xiafs/namei.cbrelse(bh);
bh282fs/xiafs/namei.cstruct buffer_head * bh;
bh287fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
bh288fs/xiafs/namei.cif (bh) {
bh289fs/xiafs/namei.cbrelse(bh);
bh320fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh321fs/xiafs/namei.cif (!bh) {
bh329fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh330fs/xiafs/namei.cbrelse(bh);
bh339fs/xiafs/namei.cstruct buffer_head * bh, *dir_block;
bh342fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
bh343fs/xiafs/namei.cif (bh) {
bh344fs/xiafs/namei.cbrelse(bh);
bh386fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh387fs/xiafs/namei.cif (!bh) {
bh394fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh399fs/xiafs/namei.cbrelse(bh);
bh409fs/xiafs/namei.cstruct buffer_head * bh;
bh419fs/xiafs/namei.cbh =  xiafs_bread(inode, i, 0);
bh421fs/xiafs/namei.cif (!bh) {
bh425fs/xiafs/namei.cde=(struct xiafs_direct *)bh->b_data;
bh429fs/xiafs/namei.cbrelse(bh);
bh432fs/xiafs/namei.cde=(struct xiafs_direct *)(12 + bh->b_data);
bh435fs/xiafs/namei.cbrelse(bh);
bh442fs/xiafs/namei.cif (!bh)
bh445fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
bh448fs/xiafs/namei.c(char *)de+de->d_rec_len > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
bh452fs/xiafs/namei.cbrelse(bh);
bh456fs/xiafs/namei.cbrelse(bh);
bh461fs/xiafs/namei.cbrelse(bh);
bh490fs/xiafs/namei.cstruct buffer_head * bh;
bh494fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
bh496fs/xiafs/namei.cif (!bh)
bh524fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh534fs/xiafs/namei.cbrelse(bh);
bh542fs/xiafs/namei.cstruct buffer_head * bh;
bh548fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
bh549fs/xiafs/namei.cif (!bh)
bh558fs/xiafs/namei.cbrelse(bh);
bh572fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh579fs/xiafs/namei.cbrelse(bh);
bh590fs/xiafs/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh594fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
bh595fs/xiafs/namei.cif (bh) {
bh596fs/xiafs/namei.cbrelse(bh);
bh621fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh622fs/xiafs/namei.cif (!bh) {
bh630fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh631fs/xiafs/namei.cbrelse(bh);
bh641fs/xiafs/namei.cstruct buffer_head * bh;
bh653fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
bh654fs/xiafs/namei.cif (bh) {
bh655fs/xiafs/namei.cbrelse(bh);
bh660fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh661fs/xiafs/namei.cif (!bh) {
bh667fs/xiafs/namei.cmark_buffer_dirty(bh, 1);
bh668fs/xiafs/namei.cbrelse(bh);
bh51fs/xiafs/symlink.cstruct buffer_head * bh;
bh61fs/xiafs/symlink.cbh = xiafs_bread(inode, 0, 0);
bh67fs/xiafs/symlink.cif (!bh)
bh69fs/xiafs/symlink.cfor (i=0; i < buflen && (c=bh->b_data[i]); i++)
bh73fs/xiafs/symlink.cbrelse(bh);
bh81fs/xiafs/symlink.cstruct buffer_head * bh;
bh106fs/xiafs/symlink.cif (!(bh = xiafs_bread(inode, 0, 0))) {
bh113fs/xiafs/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh115fs/xiafs/symlink.cbrelse(bh);
bh41fs/xiafs/truncate.cstruct buffer_head * bh;
bh52fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh54fs/xiafs/truncate.cbrelse(bh);
bh57fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *lp)
bh65fs/xiafs/truncate.cbrelse(bh);
bh75fs/xiafs/truncate.cstruct buffer_head * bh, * ind_bh;
bh98fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh100fs/xiafs/truncate.cbrelse(bh);
bh103fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *indp)
bh111fs/xiafs/truncate.cbrelse(bh);
bh27include/linux/affs_fs.hstruct buffer_head *bh;
bh30include/linux/affs_fs.hbh = bread (dev, sector >> (BLOCK_SIZE_BITS - AFFS_BLOCK_BITS), 1024);
bh31include/linux/affs_fs.hif (!bh)
bh34include/linux/affs_fs.h*start = bh->b_data + ((sector & mask) << AFFS_BLOCK_BITS);
bh35include/linux/affs_fs.hreturn bh;
bh98include/linux/affs_fs.hextern void leak_check_brelse(struct buffer_head * bh);
bh359include/linux/blk.hif (CURRENT->bh) { \
bh360include/linux/blk.hif (!buffer_locked(CURRENT->bh)) \
bh382include/linux/blk.hstruct buffer_head * bh;
bh394include/linux/blk.hif ((bh = req->bh) != NULL) {
bh395include/linux/blk.hreq->bh = bh->b_reqnext;
bh396include/linux/blk.hbh->b_reqnext = NULL;
bh397include/linux/blk.hmark_buffer_uptodate(bh, uptodate);
bh398include/linux/blk.hunlock_buffer(bh);
bh399include/linux/blk.hif ((bh = req->bh) != NULL) {
bh400include/linux/blk.hreq->current_nr_sectors = bh->b_size >> 9;
bh405include/linux/blk.hreq->buffer = bh->b_data;
bh31include/linux/blkdev.hstruct buffer_head * bh;
bh181include/linux/fs.hstatic inline int buffer_uptodate(struct buffer_head * bh)
bh183include/linux/fs.hreturn test_bit(BH_Uptodate, &bh->b_state);
bh186include/linux/fs.hstatic inline int buffer_dirty(struct buffer_head * bh)
bh188include/linux/fs.hreturn test_bit(BH_Dirty, &bh->b_state);
bh191include/linux/fs.hstatic inline int buffer_locked(struct buffer_head * bh)
bh193include/linux/fs.hreturn test_bit(BH_Lock, &bh->b_state);
bh196include/linux/fs.hstatic inline int buffer_req(struct buffer_head * bh)
bh198include/linux/fs.hreturn test_bit(BH_Req, &bh->b_state);
bh201include/linux/fs.hstatic inline int buffer_touched(struct buffer_head * bh)
bh203include/linux/fs.hreturn test_bit(BH_Touched, &bh->b_state);
bh206include/linux/fs.hstatic inline int buffer_has_aged(struct buffer_head * bh)
bh208include/linux/fs.hreturn test_bit(BH_Has_aged, &bh->b_state);
bh211include/linux/fs.hstatic inline int buffer_protected(struct buffer_head * bh)
bh213include/linux/fs.hreturn test_bit(BH_Protected, &bh->b_state);
bh576include/linux/fs.hvoid mark_buffer_uptodate(struct buffer_head * bh, int on);
bh578include/linux/fs.hextern inline void mark_buffer_clean(struct buffer_head * bh)
bh580include/linux/fs.hif (clear_bit(BH_Dirty, &bh->b_state)) {
bh581include/linux/fs.hif (bh->b_list == BUF_DIRTY)
bh582include/linux/fs.hrefile_buffer(bh);
bh586include/linux/fs.hextern inline void mark_buffer_dirty(struct buffer_head * bh, int flag)
bh588include/linux/fs.hif (!set_bit(BH_Dirty, &bh->b_state)) {
bh589include/linux/fs.hset_writetime(bh, flag);
bh590include/linux/fs.hif (bh->b_list != BUF_DIRTY)
bh591include/linux/fs.hrefile_buffer(bh);
bh625include/linux/fs.hextern void ll_rw_block(int rw, int nr, struct buffer_head * bh[]);
bh204include/linux/iso_fs.hextern void leak_check_brelse(struct buffer_head * bh);
bh23include/linux/locks.hextern inline void wait_on_buffer(struct buffer_head * bh)
bh25include/linux/locks.hif (test_bit(BH_Lock, &bh->b_state))
bh26include/linux/locks.h__wait_on_buffer(bh);
bh29include/linux/locks.hextern inline void lock_buffer(struct buffer_head * bh)
bh31include/linux/locks.hif (set_bit(BH_Lock, &bh->b_state))
bh32include/linux/locks.h__wait_on_buffer(bh);
bh182include/linux/msdos_fs.hextern int fat_get_entry(struct inode *dir,loff_t *pos,struct buffer_head **bh,
bh24include/linux/stats206.hx(bh), x(open), x(ioctl_multisession)
bh36kernel/softirq.cvoid (**bh)(void);
bh39kernel/softirq.cbh = bh_base;
bh41kernel/softirq.cfor (mask = 1, left = ~0 ; left & active ; bh++,mask += mask,left += left) {
bh45kernel/softirq.cfn = *bh;
bh119mm/filemap.cstruct buffer_head *tmp, *bh;
bh131mm/filemap.cbh = page->buffers;
bh132mm/filemap.cif (bh) {
bh133mm/filemap.ctmp = bh;
bh140mm/filemap.c} while (tmp != bh);
bh164mm/filemap.cif (bh && try_to_free_buffer(bh, &bh, 6))
bh808mm/filemap.cstruct buffer_head * bh;
bh810mm/filemap.cbh = mem_map[MAP_NR(page)].buffers;
bh811mm/filemap.cif (bh) {
bh813mm/filemap.cstruct buffer_head * tmp = bh;
bh817mm/filemap.c} while (tmp != bh);