taglinefilesource code
bh36drivers/block/blk.hstruct buffer_head * bh;
bh238drivers/block/blk.hstruct buffer_head * bh;
bh253drivers/block/blk.hif ((bh = req->bh) != NULL) {
bh254drivers/block/blk.hreq->bh = bh->b_reqnext;
bh255drivers/block/blk.hbh->b_reqnext = NULL;
bh256drivers/block/blk.hbh->b_uptodate = uptodate;
bh257drivers/block/blk.hunlock_buffer(bh);
bh258drivers/block/blk.hif ((bh = req->bh) != NULL) {
bh259drivers/block/blk.hreq->current_nr_sectors = bh->b_size >> 9;
bh264drivers/block/blk.hreq->buffer = bh->b_data;
bh294drivers/block/blk.hif (CURRENT->bh) { \
bh295drivers/block/blk.hif (!CURRENT->bh->b_lock) \
bh392drivers/block/floppy.cint floppy_change(struct buffer_head * bh)
bh394drivers/block/floppy.cunsigned int mask = 1 << (bh->b_dev & 0x03);
bh396drivers/block/floppy.cif (MAJOR(bh->b_dev) != MAJOR_NR) {
bh413drivers/block/floppy.cif (!bh)
bh415drivers/block/floppy.cif (bh->b_dirt)
bh416drivers/block/floppy.cll_rw_block(WRITE, 1, &bh);
bh419drivers/block/floppy.cbh->b_uptodate = 0;
bh420drivers/block/floppy.cll_rw_block(READ, 1, &bh);
bh423drivers/block/floppy.cwhile (bh->b_lock)
bh424drivers/block/floppy.csleep_on(&bh->b_wait);
bh1016drivers/block/floppy.cif (CURRENT->bh) {
bh1017drivers/block/floppy.cif (!CURRENT->bh->b_lock)
bh38drivers/block/genhd.cstruct buffer_head *bh;
bh49drivers/block/genhd.cif (!(bh = bread(dev,0,1024)))
bh55drivers/block/genhd.cbh->b_dirt=0;
bh56drivers/block/genhd.cbh->b_uptodate=0;
bh57drivers/block/genhd.cif (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
bh58drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
bh85drivers/block/genhd.cbrelse(bh);
bh90drivers/block/genhd.cbrelse(bh);
bh97drivers/block/genhd.cstruct buffer_head *bh;
bh106drivers/block/genhd.cif (!(bh = bread(dev,0,1024))) {
bh112drivers/block/genhd.cif (*(unsigned short *) (bh->b_data+510) == 0xAA55) {
bh113drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
bh130drivers/block/genhd.cif (*(unsigned short *) (bh->b_data+0xfc) == 0x55AA) {
bh131drivers/block/genhd.cp = (struct partition *) (0x1BE + bh->b_data);
bh148drivers/block/genhd.cbrelse(bh);
bh353drivers/block/hd.cif (!i || (CURRENT->bh && !SUBSECTOR(i)))
bh397drivers/block/hd.cif (!i || (CURRENT->bh && !SUBSECTOR(i)))
bh153drivers/block/ll_rw_blk.cif (req->bh)
bh154drivers/block/ll_rw_blk.creq->bh->b_dirt = 0;
bh177drivers/block/ll_rw_blk.cstatic void make_request(int major,int rw, struct buffer_head * bh)
bh187drivers/block/ll_rw_blk.cif (bh->b_lock)
bh198drivers/block/ll_rw_blk.ccount = bh->b_size >> 9;
bh199drivers/block/ll_rw_blk.csector = bh->b_blocknr * count;
bh201drivers/block/ll_rw_blk.cif (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
bh202drivers/block/ll_rw_blk.cbh->b_dirt = bh->b_uptodate = 0;
bh205drivers/block/ll_rw_blk.clock_buffer(bh);
bh206drivers/block/ll_rw_blk.cif ((rw == WRITE && !bh->b_dirt) || (rw == READ && bh->b_uptodate)) {
bh207drivers/block/ll_rw_blk.cunlock_buffer(bh);
bh234drivers/block/ll_rw_blk.cif (req->dev == bh->b_dev &&
bh240drivers/block/ll_rw_blk.creq->bhtail->b_reqnext = bh;
bh241drivers/block/ll_rw_blk.creq->bhtail = bh;
bh243drivers/block/ll_rw_blk.cbh->b_dirt = 0;
bh248drivers/block/ll_rw_blk.cif (req->dev == bh->b_dev &&
bh255drivers/block/ll_rw_blk.cbh->b_reqnext = req->bh;
bh256drivers/block/ll_rw_blk.creq->buffer = bh->b_data;
bh259drivers/block/ll_rw_blk.cbh->b_dirt = 0;
bh260drivers/block/ll_rw_blk.creq->bh = bh;
bh270drivers/block/ll_rw_blk.creq = get_request(max_req, bh->b_dev);
bh276drivers/block/ll_rw_blk.cunlock_buffer(bh);
bh293drivers/block/ll_rw_blk.creq->buffer = bh->b_data;
bh295drivers/block/ll_rw_blk.creq->bh = bh;
bh296drivers/block/ll_rw_blk.creq->bhtail = bh;
bh327drivers/block/ll_rw_blk.creq->bh = NULL;
bh338drivers/block/ll_rw_blk.cvoid ll_rw_block(int rw, int nr, struct buffer_head * bh[])
bh348drivers/block/ll_rw_blk.cwhile (!*bh) {
bh349drivers/block/ll_rw_blk.cbh++;
bh355drivers/block/ll_rw_blk.cif ((major = MAJOR(bh[0]->b_dev)) < MAX_BLKDEV)
bh360drivers/block/ll_rw_blk.c(unsigned long) bh[0]->b_dev, bh[0]->b_blocknr);
bh367drivers/block/ll_rw_blk.ci = blksize_size[major][MINOR(bh[0]->b_dev)];
bh374drivers/block/ll_rw_blk.cif (bh[i] && bh[i]->b_size != correct_size) {
bh377drivers/block/ll_rw_blk.ccorrect_size, bh[i]->b_size);
bh382drivers/block/ll_rw_blk.cif ((rw == WRITE || rw == WRITEA) && is_read_only(bh[0]->b_dev)) {
bh383drivers/block/ll_rw_blk.cprintk("Can't write to read-only device 0x%X\n",bh[0]->b_dev);
bh402drivers/block/ll_rw_blk.cif (bh[i]) {
bh403drivers/block/ll_rw_blk.cbh[i]->b_req = 1;
bh404drivers/block/ll_rw_blk.cmake_request(major, rw, bh[i]);
bh417drivers/block/ll_rw_blk.cif (bh[i])
bh418drivers/block/ll_rw_blk.cbh[i]->b_dirt = bh[i]->b_uptodate = 0;
bh458drivers/block/ll_rw_blk.creq->bh = NULL;
bh104drivers/block/ramdisk.cstruct buffer_head *bh;
bh129drivers/block/ramdisk.cbh = breada(ROOT_DEV,block+1,block,block+2,-1);
bh130drivers/block/ramdisk.cif (!bh) {
bh137drivers/block/ramdisk.c*((struct minix_super_block *) bh->b_data);
bh138drivers/block/ramdisk.cbrelse(bh);
bh157drivers/block/ramdisk.cbh = breada(ROOT_DEV, block, block+1, block+2, -1);
bh159drivers/block/ramdisk.cbh = bread(ROOT_DEV, block, BLOCK_SIZE);
bh160drivers/block/ramdisk.cif (!bh) {
bh165drivers/block/ramdisk.c(void) memcpy(cp, bh->b_data, BLOCK_SIZE);
bh166drivers/block/ramdisk.cbrelse(bh);
bh526drivers/scsi/scsi.cstruct buffer_head * bh;
bh550drivers/scsi/scsi.cbh = req->bh;
bh551drivers/scsi/scsi.cif(!tablesize) bh = NULL;
bh554drivers/scsi/scsi.cwhile(req->nr_sectors && bh){
bh556drivers/scsi/scsi.creq->nr_sectors -= bh->b_size >> 9;
bh557drivers/scsi/scsi.creq->sector += bh->b_size >> 9;
bh559drivers/scsi/scsi.cbh = bh->b_reqnext;
bh561drivers/scsi/scsi.cif(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
bh562drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
bh563drivers/scsi/scsi.creq->bh = bh->b_reqnext; /* Divide request */
bh564drivers/scsi/scsi.cbh->b_reqnext = NULL;
bh565drivers/scsi/scsi.cbh = req->bh;
bh569drivers/scsi/scsi.creq->current_nr_sectors = bh->b_size >> 9;
bh570drivers/scsi/scsi.creq->buffer = bh->b_data;
bh601drivers/scsi/scsi.cstruct buffer_head * bh;
bh647drivers/scsi/scsi.cbh = req->bh;
bh648drivers/scsi/scsi.cif(!tablesize) bh = NULL;
bh651drivers/scsi/scsi.cwhile(req->nr_sectors && bh){
bh653drivers/scsi/scsi.creq->nr_sectors -= bh->b_size >> 9;
bh654drivers/scsi/scsi.creq->sector += bh->b_size >> 9;
bh656drivers/scsi/scsi.cbh = bh->b_reqnext;
bh658drivers/scsi/scsi.cif(req->nr_sectors && bh && bh->b_reqnext){  /* Any leftovers? */
bh659drivers/scsi/scsi.cSCpnt->request.bhtail = bh;
bh660drivers/scsi/scsi.creq->bh = bh->b_reqnext; /* Divide request */
bh661drivers/scsi/scsi.cbh->b_reqnext = NULL;
bh662drivers/scsi/scsi.cbh = req->bh;
bh665drivers/scsi/scsi.creq->current_nr_sectors = bh->b_size >> 9;
bh666drivers/scsi/scsi.creq->buffer = bh->b_data;
bh453drivers/scsi/scsi.hstruct buffer_head * bh;
bh464drivers/scsi/scsi.hif ((bh = req->bh) != NULL) {
bh465drivers/scsi/scsi.hreq->bh = bh->b_reqnext;
bh466drivers/scsi/scsi.hreq->nr_sectors -= bh->b_size >> 9;
bh467drivers/scsi/scsi.hreq->sector += bh->b_size >> 9;
bh468drivers/scsi/scsi.hbh->b_reqnext = NULL;
bh469drivers/scsi/scsi.hbh->b_uptodate = uptodate;
bh470drivers/scsi/scsi.hunlock_buffer(bh);
bh471drivers/scsi/scsi.hsectors -= bh->b_size >> 9;
bh472drivers/scsi/scsi.hif ((bh = req->bh) != NULL) {
bh473drivers/scsi/scsi.hreq->current_nr_sectors = bh->b_size >> 9;
bh480drivers/scsi/scsi.h} while(sectors && bh);
bh481drivers/scsi/scsi.hif (req->bh){
bh482drivers/scsi/scsi.hreq->buffer = bh->b_data;
bh510drivers/scsi/scsi.hif (CURRENT->bh) { \
bh511drivers/scsi/scsi.hif (!CURRENT->bh->b_lock) \
bh50drivers/scsi/scsi_debug.cif (bh){              \
bh51drivers/scsi/scsi_debug.cif (bh->b_size != 1024) panic ("Wrong bh size");  \
bh52drivers/scsi/scsi_debug.cif ((bh->b_blocknr << 1) + start != block)           \
bh53drivers/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",bh->b_blocknr, block);  \
bh55drivers/scsi/scsi_debug.cif (bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
bh75drivers/scsi/scsi_debug.cif (SCpnt->request.bh){              \
bh76drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_size != 1024) panic ("Wrong bh size");  \
bh77drivers/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
bh78drivers/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
bh80drivers/scsi/scsi_debug.cif (SCpnt->request.bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
bh142drivers/scsi/scsi_debug.cstruct buffer_head * bh = NULL;
bh229drivers/scsi/scsi_debug.cbh = SCpnt->request.bh;
bh280drivers/scsi/scsi_debug.cmemcpy(buff+128, bh, sizeof(struct buffer_head));
bh282drivers/scsi/scsi_debug.cbh = bh->b_reqnext;
bh285drivers/scsi/scsi_debug.cif(!bh) panic("Too few blocks for linked request.");
bh292drivers/scsi/scsi_debug.cif(bh) scsi_dump(SCpnt, 0);
bh195drivers/scsi/sd.cif (!SCpnt->request.bh)
bh443drivers/scsi/sd.cif (!SCpnt->request.bh || 
bh474drivers/scsi/sd.cstruct buffer_head * bh;
bh477drivers/scsi/sd.cbh = SCpnt->request.bh;
bh481drivers/scsi/sd.cwhile(bh && count < SCpnt->host->sg_tablesize) {
bh482drivers/scsi/sd.cif ((this_count + (bh->b_size >> 9)) > this_count_max) break;
bh483drivers/scsi/sd.cthis_count += (bh->b_size >> 9);
bh485drivers/scsi/sd.cbh = bh->b_reqnext;
bh501drivers/scsi/sd.cbh = SCpnt->request.bh;
bh502drivers/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh; count < SCpnt->use_sg; 
bh503drivers/scsi/sd.ccount++, bh = bh->b_reqnext) {
bh504drivers/scsi/sd.csgpnt[count].address = bh->b_data;
bh506drivers/scsi/sd.csgpnt[count].length = bh->b_size;
bh513drivers/scsi/sd.cif(dma_free_sectors < (bh->b_size >> 9) + 5) {
bh119drivers/scsi/sr.cprintk("sr.c done: %x %x\n",result, SCpnt->request.bh->b_data);
bh137drivers/scsi/sr.cSCpnt->request.bh &&
bh138drivers/scsi/sr.cSCpnt->request.bh->b_reqnext &&
bh139drivers/scsi/sr.cSCpnt->request.bh->b_reqnext->b_size == 1024) {
bh140drivers/scsi/sr.cmemcpy((char *)SCpnt->request.bh->b_reqnext->b_data, 
bh168drivers/scsi/sr.cprintk("(%x %x %x) ",SCpnt->request.bh, SCpnt->request.nr_sectors, 
bh174drivers/scsi/sr.cif (!SCpnt->request.bh)
bh423drivers/scsi/sr.cstruct buffer_head * bh;
bh426drivers/scsi/sr.cbh = SCpnt->request.bh;
bh434drivers/scsi/sr.cwhile(bh && count < SCpnt->host->sg_tablesize) {
bh435drivers/scsi/sr.cif ((this_count + (bh->b_size >> 9)) > this_count_max) break;
bh436drivers/scsi/sr.cthis_count += (bh->b_size >> 9);
bh438drivers/scsi/sr.cbh = bh->b_reqnext;
bh464drivers/scsi/sr.cbh = SCpnt->request.bh;
bh473drivers/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
bh474drivers/scsi/sr.ccount++, bh = bh->b_reqnext) {
bh475drivers/scsi/sr.cif (bh) { /* Need a placeholder at the end of the record? */
bh476drivers/scsi/sr.csgpnt[count].address = bh->b_data;
bh477drivers/scsi/sr.csgpnt[count].length = bh->b_size;
bh531drivers/scsi/sr.cif (!SCpnt->request.bh)    
bh534drivers/scsi/sr.cthis_count = (SCpnt->request.bh->b_size >> 9);
bh26fs/block_dev.cstruct buffer_head * bh;
bh55fs/block_dev.cbh = getblk(dev, block, blocksize);
bh57fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
bh59fs/block_dev.cif (!bh)
bh61fs/block_dev.cp = offset + bh->b_data;
bh69fs/block_dev.cbh->b_uptodate = 1;
bh70fs/block_dev.cbh->b_dirt = 1;
bh71fs/block_dev.cbrelse(bh);
bh71fs/buffer.cvoid __wait_on_buffer(struct buffer_head * bh)
bh75fs/buffer.cbh->b_count++;
bh76fs/buffer.cadd_wait_queue(&bh->b_wait, &wait);
bh79fs/buffer.cif (bh->b_lock) {
bh83fs/buffer.cremove_wait_queue(&bh->b_wait, &wait);
bh84fs/buffer.cbh->b_count--;
bh95fs/buffer.cstruct buffer_head * bh;
bh104fs/buffer.cbh = free_list;
bh105fs/buffer.cfor (i = nr_buffers*2 ; i-- > 0 ; bh = bh->b_next_free) {
bh106fs/buffer.cif (dev && bh->b_dev != dev)
bh109fs/buffer.cif (bh->b_req && !bh->b_lock &&
bh110fs/buffer.c!bh->b_dirt && !bh->b_uptodate)
bh112fs/buffer.cbh->b_blocknr, bh->b_dev);
bh114fs/buffer.cif (bh->b_lock)
bh122fs/buffer.cwait_on_buffer (bh);
bh126fs/buffer.cif (wait && bh->b_req && !bh->b_lock &&
bh127fs/buffer.c!bh->b_dirt && !bh->b_uptodate)
bh134fs/buffer.cif (!bh->b_dirt || pass>=2)
bh136fs/buffer.cbh->b_count++;
bh137fs/buffer.cll_rw_block(WRITE, 1, &bh);
bh138fs/buffer.cbh->b_count--;
bh194fs/buffer.cstruct buffer_head * bh;
bh196fs/buffer.cbh = free_list;
bh197fs/buffer.cfor (i = nr_buffers*2 ; --i > 0 ; bh = bh->b_next_free) {
bh198fs/buffer.cif (bh->b_dev != dev)
bh200fs/buffer.cwait_on_buffer(bh);
bh201fs/buffer.cif (bh->b_dev == dev)
bh202fs/buffer.cbh->b_uptodate = bh->b_dirt = bh->b_req = 0;
bh223fs/buffer.cstruct buffer_head * bh;
bh227fs/buffer.cif (!(bh = getblk(dev,0,1024)))
bh229fs/buffer.ci = floppy_change(bh);
bh230fs/buffer.cbrelse(bh);
bh282fs/buffer.cstatic inline void remove_from_hash_queue(struct buffer_head * bh)
bh284fs/buffer.cif (bh->b_next)
bh285fs/buffer.cbh->b_next->b_prev = bh->b_prev;
bh286fs/buffer.cif (bh->b_prev)
bh287fs/buffer.cbh->b_prev->b_next = bh->b_next;
bh288fs/buffer.cif (hash(bh->b_dev,bh->b_blocknr) == bh)
bh289fs/buffer.chash(bh->b_dev,bh->b_blocknr) = bh->b_next;
bh290fs/buffer.cbh->b_next = bh->b_prev = NULL;
bh293fs/buffer.cstatic inline void remove_from_free_list(struct buffer_head * bh)
bh295fs/buffer.cif (!(bh->b_prev_free) || !(bh->b_next_free))
bh297fs/buffer.cbh->b_prev_free->b_next_free = bh->b_next_free;
bh298fs/buffer.cbh->b_next_free->b_prev_free = bh->b_prev_free;
bh299fs/buffer.cif (free_list == bh)
bh300fs/buffer.cfree_list = bh->b_next_free;
bh301fs/buffer.cbh->b_next_free = bh->b_prev_free = NULL;
bh304fs/buffer.cstatic inline void remove_from_queues(struct buffer_head * bh)
bh306fs/buffer.cremove_from_hash_queue(bh);
bh307fs/buffer.cremove_from_free_list(bh);
bh310fs/buffer.cstatic inline void put_first_free(struct buffer_head * bh)
bh312fs/buffer.cif (!bh || (bh == free_list))
bh314fs/buffer.cremove_from_free_list(bh);
bh316fs/buffer.cbh->b_next_free = free_list;
bh317fs/buffer.cbh->b_prev_free = free_list->b_prev_free;
bh318fs/buffer.cfree_list->b_prev_free->b_next_free = bh;
bh319fs/buffer.cfree_list->b_prev_free = bh;
bh320fs/buffer.cfree_list = bh;
bh323fs/buffer.cstatic inline void put_last_free(struct buffer_head * bh)
bh325fs/buffer.cif (!bh)
bh327fs/buffer.cif (bh == free_list) {
bh328fs/buffer.cfree_list = bh->b_next_free;
bh331fs/buffer.cremove_from_free_list(bh);
bh333fs/buffer.cbh->b_next_free = free_list;
bh334fs/buffer.cbh->b_prev_free = free_list->b_prev_free;
bh335fs/buffer.cfree_list->b_prev_free->b_next_free = bh;
bh336fs/buffer.cfree_list->b_prev_free = bh;
bh339fs/buffer.cstatic inline void insert_into_queues(struct buffer_head * bh)
bh342fs/buffer.cbh->b_next_free = free_list;
bh343fs/buffer.cbh->b_prev_free = free_list->b_prev_free;
bh344fs/buffer.cfree_list->b_prev_free->b_next_free = bh;
bh345fs/buffer.cfree_list->b_prev_free = bh;
bh347fs/buffer.cbh->b_prev = NULL;
bh348fs/buffer.cbh->b_next = NULL;
bh349fs/buffer.cif (!bh->b_dev)
bh351fs/buffer.cbh->b_next = hash(bh->b_dev,bh->b_blocknr);
bh352fs/buffer.chash(bh->b_dev,bh->b_blocknr) = bh;
bh353fs/buffer.cif (bh->b_next)
bh354fs/buffer.cbh->b_next->b_prev = bh;
bh382fs/buffer.cstruct buffer_head * bh;
bh385fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
bh387fs/buffer.cbh->b_count++;
bh388fs/buffer.cwait_on_buffer(bh);
bh389fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
bh390fs/buffer.creturn bh;
bh391fs/buffer.cbh->b_count--;
bh398fs/buffer.cstruct buffer_head * bh, *bhnext;
bh420fs/buffer.cbh = free_list;
bh421fs/buffer.cfor (i = nr_buffers*2 ; --i > 0 ; bh = bhnext) {
bh422fs/buffer.cbhnext = bh->b_next_free; 
bh423fs/buffer.cif (bh->b_dev != dev)
bh425fs/buffer.cif (bh->b_size == size)
bh428fs/buffer.cwait_on_buffer(bh);
bh429fs/buffer.cif (bh->b_dev == dev && bh->b_size != size)
bh430fs/buffer.cbh->b_uptodate = bh->b_dirt = 0;
bh431fs/buffer.cremove_from_hash_queue(bh);
bh446fs/buffer.c#define BADNESS(bh) (((bh)->b_dirt<<1)+(bh)->b_lock)
bh449fs/buffer.cstruct buffer_head * bh, * tmp;
bh454fs/buffer.cbh = get_hash_table(dev, block, size);
bh455fs/buffer.cif (bh) {
bh456fs/buffer.cif (bh->b_uptodate && !bh->b_dirt)
bh457fs/buffer.cput_last_free(bh);
bh458fs/buffer.creturn bh;
bh466fs/buffer.cbh = NULL;
bh473fs/buffer.cif (!bh || BADNESS(tmp)<BADNESS(bh)) {
bh474fs/buffer.cbh = tmp;
bh487fs/buffer.cif (!bh && nr_free_pages > 5) {
bh493fs/buffer.cif (!bh) {
bh498fs/buffer.cwait_on_buffer(bh);
bh499fs/buffer.cif (bh->b_count || bh->b_size != size)
bh501fs/buffer.cif (bh->b_dirt) {
bh511fs/buffer.cbh->b_count=1;
bh512fs/buffer.cbh->b_dirt=0;
bh513fs/buffer.cbh->b_uptodate=0;
bh514fs/buffer.cbh->b_req=0;
bh515fs/buffer.cremove_from_queues(bh);
bh516fs/buffer.cbh->b_dev=dev;
bh517fs/buffer.cbh->b_blocknr=block;
bh518fs/buffer.cinsert_into_queues(bh);
bh519fs/buffer.creturn bh;
bh542fs/buffer.cstruct buffer_head * bh;
bh544fs/buffer.cif (!(bh = getblk(dev, block, size))) {
bh549fs/buffer.cif (bh->b_uptodate)
bh550fs/buffer.creturn bh;
bh551fs/buffer.cll_rw_block(READ, 1, &bh);
bh552fs/buffer.cwait_on_buffer(bh);
bh553fs/buffer.cif (bh->b_uptodate)
bh554fs/buffer.creturn bh;
bh555fs/buffer.cbrelse(bh);
bh568fs/buffer.cstruct buffer_head * bh, *tmp;
bh576fs/buffer.cif (!(bh = getblk(dev, first, blocksize))) {
bh581fs/buffer.cif (!bh->b_uptodate)
bh582fs/buffer.cll_rw_block(READ, 1, &bh);
bh592fs/buffer.cwait_on_buffer(bh);
bh593fs/buffer.cif (bh->b_uptodate)
bh594fs/buffer.creturn bh;
bh595fs/buffer.cbrelse(bh);
bh602fs/buffer.cstatic void put_unused_buffer_head(struct buffer_head * bh)
bh606fs/buffer.cwait = ((volatile struct buffer_head *) bh)->b_wait;
bh607fs/buffer.cmemset((void *) bh,0,sizeof(*bh));
bh608fs/buffer.c((volatile struct buffer_head *) bh)->b_wait = wait;
bh609fs/buffer.cbh->b_next_free = unused_list;
bh610fs/buffer.cunused_list = bh;
bh616fs/buffer.cstruct buffer_head * bh;
bh621fs/buffer.cif(! (bh = (struct buffer_head*) get_free_page(GFP_BUFFER)))
bh624fs/buffer.cfor (nr_buffer_heads+=i=PAGE_SIZE/sizeof*bh ; i>0; i--) {
bh625fs/buffer.cbh->b_next_free = unused_list;  /* only make link */
bh626fs/buffer.cunused_list = bh++;
bh632fs/buffer.cstruct buffer_head * bh;
bh637fs/buffer.cbh = unused_list;
bh638fs/buffer.cunused_list = bh->b_next_free;
bh639fs/buffer.cbh->b_next_free = NULL;
bh640fs/buffer.cbh->b_data = NULL;
bh641fs/buffer.cbh->b_size = 0;
bh642fs/buffer.cbh->b_req = 0;
bh643fs/buffer.creturn bh;
bh654fs/buffer.cstruct buffer_head *bh, *head;
bh660fs/buffer.cbh = get_unused_buffer_head();
bh661fs/buffer.cif (!bh)
bh663fs/buffer.cbh->b_this_page = head;
bh664fs/buffer.chead = bh;
bh665fs/buffer.cbh->b_data = (char *) (page+offset);
bh666fs/buffer.cbh->b_size = size;
bh673fs/buffer.cbh = head;
bh674fs/buffer.cwhile (bh) {
bh675fs/buffer.chead = bh;
bh676fs/buffer.cbh = bh->b_this_page;
bh682fs/buffer.cstatic void read_buffers(struct buffer_head * bh[], int nrbuf)
bh689fs/buffer.cif (bh[i] && !bh[i]->b_uptodate)
bh690fs/buffer.cbhr[bhnum++] = bh[i];
bh695fs/buffer.cif (bh[i]) {
bh696fs/buffer.cwait_on_buffer(bh[i]);
bh704fs/buffer.cstruct buffer_head * bh[8];
bh716fs/buffer.cbh[0] = first;
bh725fs/buffer.cbh[nrbuf++] = first;
bh729fs/buffer.cread_buffers(bh,nrbuf);    /* make sure they are actually read correctly */
bh731fs/buffer.cbrelse(bh[nrbuf]);
bh737fs/buffer.cbrelse(bh[nrbuf]);
bh745fs/buffer.cstruct buffer_head * bh, * tmp, * arr[8];
bh750fs/buffer.cbh = create_buffers(address, size);
bh751fs/buffer.cif (!bh)
bh764fs/buffer.ctmp = bh;
bh768fs/buffer.carr[block++] = bh;
bh769fs/buffer.cbh->b_count = 1;
bh770fs/buffer.cbh->b_dirt = 0;
bh771fs/buffer.cbh->b_uptodate = 0;
bh772fs/buffer.cbh->b_dev = dev;
bh773fs/buffer.cbh->b_blocknr = *(p++);
bh775fs/buffer.cinsert_into_queues(bh);
bh776fs/buffer.cif (bh->b_this_page)
bh777fs/buffer.cbh = bh->b_this_page;
bh782fs/buffer.cbh->b_this_page = tmp;
bh790fs/buffer.cwhile ((tmp = bh) != NULL) {
bh791fs/buffer.cbh = bh->b_this_page;
bh811fs/buffer.cstruct buffer_head * bh;
bh817fs/buffer.cbh = get_hash_table(dev, block, size);
bh818fs/buffer.cif (bh)
bh819fs/buffer.creturn check_aligned(bh, address, dev, b, size);
bh837fs/buffer.cstruct buffer_head * bh[8];
bh848fs/buffer.cbh[i] = NULL;
bh850fs/buffer.cbh[i] = getblk(dev, b[i], size);
bh852fs/buffer.cread_buffers(bh,i);
bh855fs/buffer.cif (bh[i]) {
bh856fs/buffer.cif (bh[i]->b_uptodate)
bh857fs/buffer.cCOPYBLK(size, (unsigned long) bh[i]->b_data,address);
bh858fs/buffer.cbrelse(bh[i]);
bh871fs/buffer.cstruct buffer_head *bh, *tmp;
bh879fs/buffer.cbh = create_buffers(page, size);
bh880fs/buffer.cif (!bh) {
bh884fs/buffer.ctmp = bh;
bh902fs/buffer.ctmp->b_this_page = bh;
bh911fs/buffer.cstatic int try_to_free(struct buffer_head * bh, struct buffer_head ** bhp)
bh916fs/buffer.c*bhp = bh;
bh917fs/buffer.cpage = (unsigned long) bh->b_data;
bh919fs/buffer.ctmp = bh;
bh926fs/buffer.c} while (tmp != bh);
bh927fs/buffer.ctmp = bh;
bh936fs/buffer.c} while (tmp != bh);
bh951fs/buffer.cstruct buffer_head *bh;
bh956fs/buffer.cbh = free_list;
bh958fs/buffer.cfor ( ; i-- > 0 ; bh = bh->b_next_free) {
bh959fs/buffer.cif (bh->b_count || !bh->b_this_page)
bh961fs/buffer.cif (bh->b_lock)
bh965fs/buffer.cwait_on_buffer(bh);
bh966fs/buffer.cif (bh->b_dirt) {
bh967fs/buffer.cbh->b_count++;
bh968fs/buffer.cll_rw_block(WRITEA, 1, &bh);
bh969fs/buffer.cbh->b_count--;
bh972fs/buffer.cif (try_to_free(bh, &bh))
bh69fs/ext/dir.cstruct buffer_head * bh;
bh78fs/ext/dir.cbh = ext_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
bh79fs/ext/dir.cif (!bh) {
bh83fs/ext/dir.cde = (struct ext_dir_entry *) (offset + bh->b_data);
bh108fs/ext/dir.cbrelse(bh);
bh115fs/ext/dir.cbrelse(bh);
bh200fs/ext/file.cstruct buffer_head * bh;
bh221fs/ext/file.cbh = ext_getblk(inode,pos/BLOCK_SIZE,1);
bh222fs/ext/file.cif (!bh) {
bh230fs/ext/file.cif (c != BLOCK_SIZE && !bh->b_uptodate) {
bh231fs/ext/file.cll_rw_block(READ, 1, &bh);
bh232fs/ext/file.cwait_on_buffer(bh);
bh233fs/ext/file.cif (!bh->b_uptodate) {
bh234fs/ext/file.cbrelse(bh);
bh240fs/ext/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
bh249fs/ext/file.cbh->b_uptodate = 1;
bh250fs/ext/file.cbh->b_dirt = 1;
bh251fs/ext/file.cbrelse(bh);
bh49fs/ext/freelists.cstruct buffer_head * bh;
bh62fs/ext/freelists.cbh = get_hash_table(sb->s_dev, block, sb->s_blocksize);
bh63fs/ext/freelists.cif (bh)
bh64fs/ext/freelists.cbh->b_dirt=0;
bh65fs/ext/freelists.cbrelse(bh);
bh93fs/ext/freelists.cstruct buffer_head * bh;
bh132fs/ext/freelists.cif (!(bh=getblk(sb->s_dev, j, sb->s_blocksize))) {
bh136fs/ext/freelists.cclear_block(bh->b_data);
bh137fs/ext/freelists.cbh->b_uptodate = 1;
bh138fs/ext/freelists.cbh->b_dirt = 1;
bh139fs/ext/freelists.cbrelse(bh);
bh150fs/ext/freelists.cstruct buffer_head * bh;
bh162fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
bh166fs/ext/freelists.cefb = (struct ext_free_block *) bh->b_data;
bh169fs/ext/freelists.cbrelse (bh);
bh184fs/ext/freelists.cstruct buffer_head * bh;
bh229fs/ext/freelists.cif (!(bh = bread(dev, block, sb->s_blocksize)))
bh231fs/ext/freelists.cefi = ((struct ext_free_inode *) bh->b_data) +
bh236fs/ext/freelists.csb->u.ext_sb.s_firstfreeinodeblock = bh;
bh310fs/ext/freelists.cstruct buffer_head * bh;
bh329fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
bh333fs/ext/freelists.cefi = ((struct ext_free_inode *) bh->b_data) +
bh337fs/ext/freelists.cbrelse (bh);
bh33fs/ext/fsync.cstruct buffer_head * bh;
bh39fs/ext/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh40fs/ext/fsync.cif (!bh)
bh43fs/ext/fsync.cbrelse (bh);
bh46fs/ext/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh47fs/ext/fsync.cbrelse(bh);
bh50fs/ext/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt)
bh52fs/ext/fsync.cbrelse(bh);
bh55fs/ext/fsync.cll_rw_block(WRITE, 1, &bh);
bh56fs/ext/fsync.cbh->b_count--;
bh61fs/ext/fsync.cstruct buffer_head **bh, int wait) 
bh65fs/ext/fsync.c*bh = NULL;
bh72fs/ext/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh74fs/ext/fsync.cbrelse(*bh);
bh75fs/ext/fsync.c*bh = NULL;
bh78fs/ext/fsync.cif (!*bh)
bh60fs/ext/inode.cstruct buffer_head *bh;
bh66fs/ext/inode.cif (!(bh = bread(dev, 1, BLOCK_SIZE))) {
bh72fs/ext/inode.ces = (struct ext_super_block *) bh->b_data;
bh85fs/ext/inode.cbrelse(bh);
bh130fs/ext/inode.cstruct buffer_head * bh;
bh133fs/ext/inode.cif (!(bh = bread(sb->s_dev, 1, BLOCK_SIZE))) {
bh137fs/ext/inode.ces = (struct ext_super_block *) bh->b_data;
bh142fs/ext/inode.cbh->b_dirt = 1;
bh143fs/ext/inode.cbrelse (bh);
bh166fs/ext/inode.cstatic int block_bmap(struct buffer_head * bh, int nr)
bh170fs/ext/inode.cif (!bh)
bh172fs/ext/inode.ctmp = ((unsigned long *) bh->b_data)[nr];
bh173fs/ext/inode.cbrelse(bh);
bh255fs/ext/inode.cstruct buffer_head * bh, int nr, int create)
bh261fs/ext/inode.cif (!bh)
bh263fs/ext/inode.cif (!bh->b_uptodate) {
bh264fs/ext/inode.cll_rw_block(READ, 1, &bh);
bh265fs/ext/inode.cwait_on_buffer(bh);
bh266fs/ext/inode.cif (!bh->b_uptodate) {
bh267fs/ext/inode.cbrelse(bh);
bh271fs/ext/inode.cp = nr + (unsigned long *) bh->b_data;
bh275fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh277fs/ext/inode.cbrelse(bh);
bh284fs/ext/inode.cbrelse(bh);
bh289fs/ext/inode.cbrelse(bh);
bh292fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh299fs/ext/inode.cbh->b_dirt = 1;
bh300fs/ext/inode.cbrelse(bh);
bh306fs/ext/inode.cstruct buffer_head * bh;
bh320fs/ext/inode.cbh = inode_getblk(inode,9,create);
bh321fs/ext/inode.creturn block_getblk(inode,bh,block,create);
bh325fs/ext/inode.cbh = inode_getblk(inode,10,create);
bh326fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
bh327fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
bh330fs/ext/inode.cbh = inode_getblk(inode,11,create);
bh331fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
bh332fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
bh333fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
bh338fs/ext/inode.cstruct buffer_head * bh;
bh340fs/ext/inode.cbh = ext_getblk(inode,block,create);
bh341fs/ext/inode.cif (!bh || bh->b_uptodate) 
bh342fs/ext/inode.creturn bh;
bh343fs/ext/inode.cll_rw_block(READ, 1, &bh);
bh344fs/ext/inode.cwait_on_buffer(bh);
bh345fs/ext/inode.cif (bh->b_uptodate)
bh346fs/ext/inode.creturn bh;
bh347fs/ext/inode.cbrelse(bh);
bh353fs/ext/inode.cstruct buffer_head * bh;
bh358fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
bh360fs/ext/inode.craw_inode = ((struct ext_inode *) bh->b_data) +
bh373fs/ext/inode.cbrelse(bh);
bh391fs/ext/inode.cstruct buffer_head * bh;
bh396fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
bh398fs/ext/inode.craw_inode = ((struct ext_inode *)bh->b_data) +
bh410fs/ext/inode.cbh->b_dirt=1;
bh412fs/ext/inode.creturn bh;
bh417fs/ext/inode.cstruct buffer_head *bh;
bh418fs/ext/inode.cbh = ext_update_inode (inode);
bh419fs/ext/inode.cbrelse(bh);
bh425fs/ext/inode.cstruct buffer_head *bh;
bh427fs/ext/inode.cbh = ext_update_inode(inode);
bh428fs/ext/inode.cif (bh && bh->b_dirt)
bh430fs/ext/inode.cll_rw_block(WRITE, 1, &bh);
bh431fs/ext/inode.cwait_on_buffer(bh);
bh432fs/ext/inode.cif (bh->b_req && !bh->b_uptodate)
bh439fs/ext/inode.celse if (!bh)
bh441fs/ext/inode.cbrelse (bh);
bh92fs/ext/namei.cstruct buffer_head * bh;
bh105fs/ext/namei.cbh = ext_bread(dir,0,0);
bh106fs/ext/namei.cif (!bh)
bh113fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh115fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data) {
bh116fs/ext/namei.cbrelse(bh);
bh117fs/ext/namei.cbh = NULL;
bh118fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
bh119fs/ext/namei.cif (!bh)
bh121fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh127fs/ext/namei.c(((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) {
bh131fs/ext/namei.cde = (struct ext_dir_entry *) (bh->b_data+BLOCK_SIZE);
bh141fs/ext/namei.c((char *)de) + de->rec_len < BLOCK_SIZE+bh->b_data)
bh146fs/ext/namei.creturn bh;
bh153fs/ext/namei.cbrelse(bh);
bh162fs/ext/namei.cstruct buffer_head * bh;
bh171fs/ext/namei.cif (!(bh = ext_find_entry(dir,name,len,&de,NULL,NULL))) {
bh176fs/ext/namei.cbrelse(bh);
bh201fs/ext/namei.cstruct buffer_head * bh;
bh216fs/ext/namei.cbh = ext_bread(dir,0,0);
bh217fs/ext/namei.cif (!bh)
bh221fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh223fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) {
bh227fs/ext/namei.cbrelse(bh);
bh228fs/ext/namei.cbh = NULL;
bh229fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
bh230fs/ext/namei.cif (!bh)
bh232fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh252fs/ext/namei.cbh->b_dirt = 1;
bh254fs/ext/namei.cbrelse (bh);
bh255fs/ext/namei.cbh = NULL;
bh259fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,1);
bh260fs/ext/namei.cif (!bh)
bh262fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh275fs/ext/namei.c(((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) {
bh279fs/ext/namei.cbrelse (bh);
bh299fs/ext/namei.cbh->b_dirt = 1;
bh301fs/ext/namei.creturn bh;
bh306fs/ext/namei.cbrelse(bh);
bh314fs/ext/namei.cstruct buffer_head * bh;
bh328fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh329fs/ext/namei.cif (!bh) {
bh337fs/ext/namei.cbh->b_dirt = 1;
bh338fs/ext/namei.cbrelse(bh);
bh347fs/ext/namei.cstruct buffer_head * bh;
bh352fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh353fs/ext/namei.cif (bh) {
bh354fs/ext/namei.cbrelse(bh);
bh387fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh388fs/ext/namei.cif (!bh) {
bh396fs/ext/namei.cbh->b_dirt = 1;
bh397fs/ext/namei.cbrelse(bh);
bh406fs/ext/namei.cstruct buffer_head * bh, *dir_block;
bh409fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh410fs/ext/namei.cif (bh) {
bh411fs/ext/namei.cbrelse(bh);
bh454fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh455fs/ext/namei.cif (!bh) {
bh462fs/ext/namei.cbh->b_dirt = 1;
bh467fs/ext/namei.cbrelse(bh);
bh477fs/ext/namei.cstruct buffer_head * bh;
bh480fs/ext/namei.cif (inode->i_size < 2 * 12 || !(bh = ext_bread(inode,0,0))) {
bh484fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh494fs/ext/namei.cif ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) {
bh495fs/ext/namei.cbrelse(bh);
bh496fs/ext/namei.cbh = ext_bread(inode, offset >> BLOCK_SIZE_BITS,1);
bh497fs/ext/namei.cif (!bh) {
bh501fs/ext/namei.cde = (struct ext_dir_entry *) bh->b_data;
bh508fs/ext/namei.cbrelse (bh);
bh512fs/ext/namei.cbrelse(bh);
bh518fs/ext/namei.cbrelse(bh);
bh535fs/ext/namei.cstruct buffer_head * bh;
bh539fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
bh541fs/ext/namei.cif (!bh)
bh570fs/ext/namei.cbh->b_dirt = 1;
bh580fs/ext/namei.cbrelse(bh);
bh588fs/ext/namei.cstruct buffer_head * bh;
bh593fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
bh594fs/ext/namei.cif (!bh)
bh613fs/ext/namei.cbh->b_dirt = 1;
bh621fs/ext/namei.cbrelse(bh);
bh631fs/ext/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh657fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh658fs/ext/namei.cif (bh) {
bh662fs/ext/namei.cbrelse(bh);
bh666fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh667fs/ext/namei.cif (!bh) {
bh675fs/ext/namei.cbh->b_dirt = 1;
bh676fs/ext/namei.cbrelse(bh);
bh685fs/ext/namei.cstruct buffer_head * bh;
bh697fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
bh698fs/ext/namei.cif (bh) {
bh699fs/ext/namei.cbrelse(bh);
bh704fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
bh705fs/ext/namei.cif (!bh) {
bh711fs/ext/namei.cbh->b_dirt = 1;
bh712fs/ext/namei.cbrelse(bh);
bh51fs/ext/symlink.cstruct buffer_head * bh;
bh72fs/ext/symlink.cif (!(bh = ext_bread(inode, 0, 0))) {
bh79fs/ext/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh81fs/ext/symlink.cbrelse(bh);
bh87fs/ext/symlink.cstruct buffer_head * bh;
bh97fs/ext/symlink.cbh = ext_bread(inode, 0, 0);
bh99fs/ext/symlink.cif (!bh)
bh102fs/ext/symlink.cwhile (i<buflen && (c = bh->b_data[i])) {
bh106fs/ext/symlink.cbrelse(bh);
bh37fs/ext/truncate.cstruct buffer_head * bh;
bh46fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
bh48fs/ext/truncate.cbrelse(bh);
bh51fs/ext/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh53fs/ext/truncate.cbrelse(bh);
bh58fs/ext/truncate.cbrelse(bh);
bh67fs/ext/truncate.cstruct buffer_head * bh;
bh95fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
bh97fs/ext/truncate.cbrelse(bh);
bh100fs/ext/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh102fs/ext/truncate.cbrelse(bh);
bh107fs/ext/truncate.cbrelse(bh);
bh119fs/ext2/balloc.cstruct buffer_head * bh;
bh130fs/ext2/balloc.cbh = bread (sb->s_dev, gdp[desc].bg_block_bitmap, sb->s_blocksize);
bh131fs/ext2/balloc.cif (!bh)
bh139fs/ext2/balloc.csb->u.ext2_sb.s_block_bitmap[bitmap_nr] = bh;
bh230fs/ext2/balloc.cstruct buffer_head * bh;
bh255fs/ext2/balloc.cbh = get_hash_table (sb->s_dev, block, sb->s_blocksize);
bh256fs/ext2/balloc.cif (bh)
bh257fs/ext2/balloc.cbh->b_dirt = 0;
bh258fs/ext2/balloc.cbrelse (bh);
bh264fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh265fs/ext2/balloc.cif (!bh)
bh269fs/ext2/balloc.cif (!clear_bit (bit, bh->b_data))
bh286fs/ext2/balloc.cbh->b_dirt = 1;
bh288fs/ext2/balloc.cll_rw_block (WRITE, 1, &bh);
bh289fs/ext2/balloc.cwait_on_buffer (bh);
bh305fs/ext2/balloc.cstruct buffer_head * bh;
bh350fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh351fs/ext2/balloc.cif (!bh) {
bh361fs/ext2/balloc.cif (!test_bit(j, bh->b_data)) {
bh371fs/ext2/balloc.clmap = ((((unsigned long *) bh->b_data)[j >> 5]) >>
bh374fs/ext2/balloc.clmap |= (((unsigned long *) bh->b_data)[(j >> 5) + 1]) <<
bh399fs/ext2/balloc.cp = ((char *) bh->b_data) + (j >> 3);
bh402fs/ext2/balloc.ck = (r - ((char *) bh->b_data)) << 3;
bh407fs/ext2/balloc.ck = find_next_zero_bit ((unsigned long *) bh->b_data, 
bh451fs/ext2/balloc.cbh = sb->u.ext2_sb.s_block_bitmap[bitmap_nr];
bh452fs/ext2/balloc.cif (!bh)
bh455fs/ext2/balloc.cr = find_first_zero_byte (bh->b_data, 
bh457fs/ext2/balloc.cj = (r - bh->b_data) << 3;
bh459fs/ext2/balloc.cj = find_first_zero_bit ((unsigned long *) bh->b_data,
bh473fs/ext2/balloc.cif (set_bit (j, bh->b_data)) {
bh478fs/ext2/balloc.cbh->b_dirt = 1;
bh480fs/ext2/balloc.cll_rw_block (WRITE, 1, &bh);
bh481fs/ext2/balloc.cwait_on_buffer (bh);
bh494fs/ext2/balloc.cif (!(bh = getblk (sb->s_dev, j, sb->s_blocksize))) {
bh499fs/ext2/balloc.cclear_block (bh->b_data, sb->s_blocksize);
bh500fs/ext2/balloc.cbh->b_uptodate = 1;
bh501fs/ext2/balloc.cbh->b_dirt = 1;
bh502fs/ext2/balloc.cbrelse (bh);
bh69fs/ext2/dir.cstruct ext2_dir_entry * de, struct buffer_head * bh,
bh80fs/ext2/dir.celse if (dir && ((char *) de - bh->b_data) + de->rec_len >
bh97fs/ext2/dir.cstruct buffer_head * bh;
bh107fs/ext2/dir.cbh = ext2_bread (inode, (filp->f_pos) >> EXT2_BLOCK_SIZE_BITS(sb),
bh109fs/ext2/dir.cif (!bh) {
bh113fs/ext2/dir.cde = (struct ext2_dir_entry *) (offset + bh->b_data);
bh116fs/ext2/dir.cbh, offset)) {
bh117fs/ext2/dir.cbrelse (bh);
bh134fs/ext2/dir.cbrelse (bh);
bh144fs/ext2/dir.cbrelse (bh);
bh210fs/ext2/file.cstruct buffer_head * bh;
bh235fs/ext2/file.cbh = ext2_getblk (inode, pos / sb->s_blocksize, 1, &err);
bh236fs/ext2/file.cif (!bh) {
bh244fs/ext2/file.cif (c != sb->s_blocksize && !bh->b_uptodate) {
bh245fs/ext2/file.cll_rw_block (READ, 1, &bh);
bh246fs/ext2/file.cwait_on_buffer (bh);
bh247fs/ext2/file.cif (!bh->b_uptodate) {
bh248fs/ext2/file.cbrelse (bh);
bh254fs/ext2/file.cp = (pos % sb->s_blocksize) + bh->b_data;
bh263fs/ext2/file.cbh->b_uptodate = 1;
bh264fs/ext2/file.cbh->b_dirt = 1;
bh265fs/ext2/file.cbrelse (bh);
bh30fs/ext2/fsync.cstruct buffer_head * bh;
bh36fs/ext2/fsync.cbh = get_hash_table (inode->i_dev, *block, blocksize);
bh37fs/ext2/fsync.cif (!bh)
bh40fs/ext2/fsync.cbrelse (bh);
bh43fs/ext2/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh44fs/ext2/fsync.cbrelse (bh);
bh47fs/ext2/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt) {
bh48fs/ext2/fsync.cbrelse (bh);
bh51fs/ext2/fsync.cll_rw_block (WRITE, 1, &bh);
bh52fs/ext2/fsync.cbh->b_count--;
bh57fs/ext2/fsync.cstruct buffer_head ** bh, int wait) 
bh61fs/ext2/fsync.c*bh = NULL;
bh68fs/ext2/fsync.c*bh = bread (inode->i_dev, tmp, blocksize);
bh70fs/ext2/fsync.cbrelse (*bh);
bh71fs/ext2/fsync.c*bh = NULL;
bh74fs/ext2/fsync.cif (!*bh)
bh69fs/ext2/ialloc.cstruct buffer_head * bh;
bh79fs/ext2/ialloc.cbh = bread (sb->s_dev, gdp[desc].bg_inode_bitmap, sb->s_blocksize);
bh80fs/ext2/ialloc.cif (!bh)
bh85fs/ext2/ialloc.csb->u.ext2_sb.s_inode_bitmap[bitmap_nr] = bh;
bh168fs/ext2/ialloc.cstruct buffer_head * bh;
bh174fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
bh175fs/ext2/ialloc.cif (!bh)
bh180fs/ext2/ialloc.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh186fs/ext2/ialloc.cbh->b_dirt = 1;
bh188fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh189fs/ext2/ialloc.cwait_on_buffer (bh);
bh191fs/ext2/ialloc.cbrelse (bh);
bh197fs/ext2/ialloc.cstruct buffer_head * bh;
bh243fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
bh244fs/ext2/ialloc.cif (!bh)
bh247fs/ext2/ialloc.cif (!clear_bit (bit, bh->b_data))
bh267fs/ext2/ialloc.cbh->b_dirt = 1;
bh269fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh270fs/ext2/ialloc.cwait_on_buffer (bh);
bh288fs/ext2/ialloc.cstruct buffer_head * bh;
bh294fs/ext2/ialloc.cbh = bread (inode->i_sb->s_dev, inode_block, inode->i_sb->s_blocksize);
bh295fs/ext2/ialloc.cif (!bh) {
bh303fs/ext2/ialloc.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh309fs/ext2/ialloc.cbh->b_dirt = 1;
bh310fs/ext2/ialloc.cbrelse (bh);
bh342fs/ext2/ialloc.cstruct buffer_head * bh;
bh430fs/ext2/ialloc.cbh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
bh431fs/ext2/ialloc.cif (!bh)
bh434fs/ext2/ialloc.cif ((j = find_first_zero_bit ((unsigned long *) bh->b_data,
bh437fs/ext2/ialloc.cif (set_bit (j, bh->b_data)) {
bh442fs/ext2/ialloc.cbh->b_dirt = 1;
bh444fs/ext2/ialloc.cll_rw_block (WRITE, 1, &bh);
bh445fs/ext2/ialloc.cwait_on_buffer (bh);
bh40fs/ext2/inode.cstatic int block_bmap (struct buffer_head * bh, int nr)
bh44fs/ext2/inode.cif (!bh)
bh46fs/ext2/inode.ctmp = ((unsigned long *) bh->b_data)[nr];
bh47fs/ext2/inode.cbrelse (bh);
bh172fs/ext2/inode.cstruct buffer_head * bh, int nr,
bh181fs/ext2/inode.cif (!bh)
bh183fs/ext2/inode.cif (!bh->b_uptodate) {
bh184fs/ext2/inode.cll_rw_block (READ, 1, &bh);
bh185fs/ext2/inode.cwait_on_buffer (bh);
bh186fs/ext2/inode.cif (!bh->b_uptodate) {
bh187fs/ext2/inode.cbrelse (bh);
bh191fs/ext2/inode.cp = (unsigned long *) bh->b_data + nr;
bh195fs/ext2/inode.cresult = getblk (bh->b_dev, tmp, blocksize);
bh197fs/ext2/inode.cbrelse (bh);
bh206fs/ext2/inode.cbrelse (bh);
bh214fs/ext2/inode.cif (((unsigned long *) bh->b_data)[tmp]) {
bh215fs/ext2/inode.cgoal = ((unsigned long *)bh->b_data)[tmp];
bh220fs/ext2/inode.cgoal = bh->b_blocknr + 1;
bh224fs/ext2/inode.cbrelse (bh);
bh227fs/ext2/inode.cresult = getblk (bh->b_dev, tmp, blocksize);
bh234fs/ext2/inode.cbh->b_dirt = 1;
bh236fs/ext2/inode.cll_rw_block (WRITE, 1, &bh);
bh237fs/ext2/inode.cwait_on_buffer (bh);
bh244fs/ext2/inode.cbrelse (bh);
bh251fs/ext2/inode.cstruct buffer_head * bh;
bh285fs/ext2/inode.cbh = inode_getblk (inode, EXT2_IND_BLOCK, create, b, err);
bh286fs/ext2/inode.creturn block_getblk (inode, bh, block, create,
bh291fs/ext2/inode.cbh = inode_getblk (inode, EXT2_DIND_BLOCK, create, b, err);
bh292fs/ext2/inode.cbh = block_getblk (inode, bh, block / addr_per_block, create,
bh294fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1),
bh298fs/ext2/inode.cbh = inode_getblk (inode, EXT2_TIND_BLOCK, create, b, err);
bh299fs/ext2/inode.cbh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
bh301fs/ext2/inode.cbh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
bh303fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1), create,
bh310fs/ext2/inode.cstruct buffer_head * bh;
bh312fs/ext2/inode.cbh = ext2_getblk (inode, block, create, err);
bh313fs/ext2/inode.cif (!bh || bh->b_uptodate)
bh314fs/ext2/inode.creturn bh;
bh315fs/ext2/inode.cll_rw_block (READ, 1, &bh);
bh316fs/ext2/inode.cwait_on_buffer (bh);
bh317fs/ext2/inode.cif (bh->b_uptodate)
bh318fs/ext2/inode.creturn bh;
bh319fs/ext2/inode.cbrelse (bh);
bh326fs/ext2/inode.cstruct buffer_head * bh;
bh347fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
bh348fs/ext2/inode.cif (!bh)
bh351fs/ext2/inode.cgdp = (struct ext2_group_desc *) bh->b_data;
bh355fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
bh359fs/ext2/inode.craw_inode = ((struct ext2_inode *) bh->b_data) +
bh386fs/ext2/inode.cbrelse (bh);
bh409fs/ext2/inode.cstruct buffer_head * bh;
bh429fs/ext2/inode.cbh = inode->i_sb->u.ext2_sb.s_group_desc[group_desc];
bh430fs/ext2/inode.cif (!bh)
bh433fs/ext2/inode.cgdp = (struct ext2_group_desc *) bh->b_data;
bh437fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
bh441fs/ext2/inode.craw_inode = ((struct ext2_inode *)bh->b_data) +
bh464fs/ext2/inode.cbh->b_dirt = 1;
bh466fs/ext2/inode.creturn bh;
bh471fs/ext2/inode.cstruct buffer_head * bh;
bh472fs/ext2/inode.cbh = ext2_update_inode (inode);
bh473fs/ext2/inode.cbrelse (bh);
bh479fs/ext2/inode.cstruct buffer_head *bh;
bh481fs/ext2/inode.cbh = ext2_update_inode (inode);
bh482fs/ext2/inode.cif (bh && bh->b_dirt)
bh484fs/ext2/inode.cll_rw_block (WRITE, 1, &bh);
bh485fs/ext2/inode.cwait_on_buffer (bh);
bh486fs/ext2/inode.cif (bh->b_req && !bh->b_uptodate)
bh493fs/ext2/inode.celse if (!bh)
bh495fs/ext2/inode.cbrelse (bh);
bh70fs/ext2/namei.cstruct buffer_head * bh;
bh86fs/ext2/namei.cbh = ext2_bread (dir, 0, 0, &err);
bh87fs/ext2/namei.cif (!bh)
bh90fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh92fs/ext2/namei.cif (!bh || (char *)de >= sb->s_blocksize + bh->b_data) {
bh93fs/ext2/namei.cbrelse (bh);
bh94fs/ext2/namei.cbh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 0, &err);
bh95fs/ext2/namei.cif (!bh) {
bh99fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh101fs/ext2/namei.cif (! ext2_check_dir_entry ("ext2_find_entry", dir, de, bh,
bh103fs/ext2/namei.cbrelse (bh);
bh108fs/ext2/namei.creturn bh;
bh113fs/ext2/namei.cbrelse (bh);
bh122fs/ext2/namei.cstruct buffer_head * bh;
bh134fs/ext2/namei.cif (!(bh = ext2_find_entry (dir, name, len, &de))) {
bh143fs/ext2/namei.cbrelse (bh);
bh172fs/ext2/namei.cstruct buffer_head * bh;
bh197fs/ext2/namei.cbh = ext2_bread (dir, 0, 0, err);
bh198fs/ext2/namei.cif (!bh)
bh202fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh205fs/ext2/namei.cif ((char *)de >= sb->s_blocksize + bh->b_data) {
bh206fs/ext2/namei.cbrelse (bh);
bh207fs/ext2/namei.cbh = NULL;
bh208fs/ext2/namei.cbh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, err);
bh209fs/ext2/namei.cif (!bh)
bh219fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh231fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh234fs/ext2/namei.cif (! ext2_check_dir_entry ("ext2_add_entry", dir, de, bh,
bh237fs/ext2/namei.cbrelse (bh);
bh242fs/ext2/namei.cbrelse (bh);
bh272fs/ext2/namei.cbh->b_dirt = 1;
bh275fs/ext2/namei.creturn bh;
bh280fs/ext2/namei.cbrelse (bh);
bh289fs/ext2/namei.cstruct buffer_head * bh)
bh296fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh297fs/ext2/namei.cwhile (i < bh->b_size) {
bh299fs/ext2/namei.cde, bh, i))
bh319fs/ext2/namei.cstruct buffer_head * bh;
bh334fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh335fs/ext2/namei.cif (!bh) {
bh347fs/ext2/namei.cbh->b_dirt = 1;
bh349fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh350fs/ext2/namei.cwait_on_buffer (bh);
bh352fs/ext2/namei.cbrelse (bh);
bh362fs/ext2/namei.cstruct buffer_head * bh;
bh368fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh369fs/ext2/namei.cif (bh) {
bh370fs/ext2/namei.cbrelse (bh);
bh408fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh409fs/ext2/namei.cif (!bh) {
bh421fs/ext2/namei.cbh->b_dirt = 1;
bh423fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh424fs/ext2/namei.cwait_on_buffer (bh);
bh426fs/ext2/namei.cbrelse (bh);
bh435fs/ext2/namei.cstruct buffer_head * bh, * dir_block;
bh441fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh442fs/ext2/namei.cif (bh) {
bh443fs/ext2/namei.cbrelse (bh);
bh487fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh488fs/ext2/namei.cif (!bh) {
bh500fs/ext2/namei.cbh->b_dirt = 1;
bh502fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh503fs/ext2/namei.cwait_on_buffer (bh);
bh509fs/ext2/namei.cbrelse (bh);
bh519fs/ext2/namei.cstruct buffer_head * bh;
bh526fs/ext2/namei.c!(bh = ext2_bread (inode, 0, 0, &err))) {
bh531fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh542fs/ext2/namei.cif ((void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
bh543fs/ext2/namei.cbrelse (bh);
bh544fs/ext2/namei.cbh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, &err);
bh545fs/ext2/namei.cif (!bh) {
bh549fs/ext2/namei.cde = (struct ext2_dir_entry *) bh->b_data;
bh551fs/ext2/namei.cif (! ext2_check_dir_entry ("empty_dir", inode, de, bh,
bh553fs/ext2/namei.cbrelse (bh);
bh557fs/ext2/namei.cbrelse (bh);
bh563fs/ext2/namei.cbrelse (bh);
bh571fs/ext2/namei.cstruct buffer_head * bh;
bh578fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh580fs/ext2/namei.cif (!bh)
bh589fs/ext2/namei.cbrelse(bh);
bh618fs/ext2/namei.cretval = ext2_delete_entry (de, bh);
bh621fs/ext2/namei.cbh->b_dirt = 1;
bh623fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh624fs/ext2/namei.cwait_on_buffer (bh);
bh645fs/ext2/namei.cbrelse (bh);
bh653fs/ext2/namei.cstruct buffer_head * bh;
bh661fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh662fs/ext2/namei.cif (!bh)
bh671fs/ext2/namei.cbrelse(bh);
bh686fs/ext2/namei.cretval = ext2_delete_entry (de, bh);
bh689fs/ext2/namei.cbh->b_dirt = 1;
bh691fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh692fs/ext2/namei.cwait_on_buffer (bh);
bh704fs/ext2/namei.cbrelse (bh);
bh715fs/ext2/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh759fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh760fs/ext2/namei.cif (bh) {
bh764fs/ext2/namei.cbrelse (bh);
bh768fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh769fs/ext2/namei.cif (!bh) {
bh781fs/ext2/namei.cbh->b_dirt = 1;
bh783fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh784fs/ext2/namei.cwait_on_buffer (bh);
bh786fs/ext2/namei.cbrelse (bh);
bh796fs/ext2/namei.cstruct buffer_head * bh;
bh809fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
bh810fs/ext2/namei.cif (bh) {
bh811fs/ext2/namei.cbrelse (bh);
bh816fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
bh817fs/ext2/namei.cif (!bh) {
bh827fs/ext2/namei.cbh->b_dirt = 1;
bh829fs/ext2/namei.cll_rw_block (WRITE, 1, &bh);
bh830fs/ext2/namei.cwait_on_buffer (bh);
bh832fs/ext2/namei.cbrelse (bh);
bh129fs/ext2/super.cstruct buffer_head * bh)
bh138fs/ext2/super.ces = (struct ext2_super_block *) bh->b_data;
bh161fs/ext2/super.cbh->b_dirt = 1;
bh204fs/ext2/super.cstruct buffer_head * bh;
bh224fs/ext2/super.cif (!(bh = bread (dev, sb_block, BLOCK_SIZE))) {
bh230fs/ext2/super.ces = (struct ext2_super_block *) bh->b_data;
bh242fs/ext2/super.cbrelse (bh);
bh255fs/ext2/super.cbrelse (bh);
bh259fs/ext2/super.cbh = bread (dev, logic_sb_block, s->s_blocksize);
bh260fs/ext2/super.cif(!bh)
bh262fs/ext2/super.ces = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
bh267fs/ext2/super.cbrelse (bh);
bh286fs/ext2/super.cs->u.ext2_sb.s_sbh = bh;
bh297fs/ext2/super.cbrelse (bh);
bh307fs/ext2/super.cbrelse (bh);
bh311fs/ext2/super.cif (!convert_pre_02b_fs (s, bh)) {
bh314fs/ext2/super.cbrelse (bh);
bh325fs/ext2/super.cbrelse (bh);
bh331fs/ext2/super.cif (s->s_blocksize != bh->b_size) {
bh334fs/ext2/super.cbrelse (bh);
bh344fs/ext2/super.cbrelse (bh);
bh361fs/ext2/super.cbrelse (bh);
bh373fs/ext2/super.cbrelse (bh);
bh395fs/ext2/super.cbrelse (bh);
bh405fs/ext2/super.cbh->b_dirt = 1;
bh52fs/ext2/symlink.cstruct buffer_head * bh = NULL;
bh75fs/ext2/symlink.cif (!(bh = ext2_bread (inode, 0, 0, &error))) {
bh80fs/ext2/symlink.clink = bh->b_data;
bh87fs/ext2/symlink.cif (bh)
bh88fs/ext2/symlink.cbrelse (bh);
bh94fs/ext2/symlink.cstruct buffer_head * bh = NULL;
bh106fs/ext2/symlink.cbh = ext2_bread (inode, 0, 0, &err);
bh107fs/ext2/symlink.cif (!bh) {
bh111fs/ext2/symlink.clink = bh->b_data;
bh121fs/ext2/symlink.cif (bh)
bh122fs/ext2/symlink.cbrelse (bh);
bh46fs/ext2/truncate.cstruct buffer_head * bh;
bh60fs/ext2/truncate.cbh = getblk (inode->i_dev, tmp,
bh63fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp,
bh66fs/ext2/truncate.cbrelse (bh);
bh69fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh71fs/ext2/truncate.cbrelse (bh);
bh78fs/ext2/truncate.cclear_block (bh->b_data, inode->i_sb->s_blocksize,
bh80fs/ext2/truncate.cbh->b_dirt = 1;
bh82fs/ext2/truncate.cbrelse (bh);
bh91fs/ext2/truncate.cstruct buffer_head * bh;
bh123fs/ext2/truncate.cbh = getblk (inode->i_dev, tmp,
bh126fs/ext2/truncate.cbh = get_hash_table (inode->i_dev, tmp,
bh129fs/ext2/truncate.cbrelse (bh);
bh132fs/ext2/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh134fs/ext2/truncate.cbrelse (bh);
bh140fs/ext2/truncate.cclear_block (bh->b_data, inode->i_sb->s_blocksize,
bh142fs/ext2/truncate.cbh->b_dirt = 1;
bh144fs/ext2/truncate.cbrelse (bh);
bh224fs/hpfs/hpfs_fs.cstruct buffer_head *bh[4];
bh866fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh898fs/hpfs/hpfs_fs.cblock = map_sector(inode->i_dev, hpfs_bmap(inode, q), &bh);
bh926fs/hpfs/hpfs_fs.cbrelse(bh);
bh997fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1013fs/hpfs/hpfs_fs.cfnode = map_fnode(inode->i_dev, inode->i_ino, &bh);
bh1017fs/hpfs/hpfs_fs.cfile_secno, &bh);
bh1018fs/hpfs/hpfs_fs.cbrelse(bh);
bh1570fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1574fs/hpfs/hpfs_fs.cfnode = map_fnode(dev, ino, &bh);
bh1579fs/hpfs/hpfs_fs.cbrelse(bh);
bh1652fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1654fs/hpfs/hpfs_fs.cif ((*bhp = bh = bread(dev, secno, 512)) != 0)
bh1655fs/hpfs/hpfs_fs.creturn bh->b_data;
bh1667fs/hpfs/hpfs_fs.cstruct buffer_head *bh;
bh1679fs/hpfs/hpfs_fs.cqbh->bh[0] = bh = breada(dev,
bh1681fs/hpfs/hpfs_fs.cif (!bh)
bh1683fs/hpfs/hpfs_fs.cmemcpy(data, bh->b_data, 512);
bh1685fs/hpfs/hpfs_fs.cqbh->bh[1] = bh = bread(dev, secno + 1, 512);
bh1686fs/hpfs/hpfs_fs.cif (!bh)
bh1688fs/hpfs/hpfs_fs.cmemcpy(data + 512, bh->b_data, 512);
bh1690fs/hpfs/hpfs_fs.cqbh->bh[2] = bh = bread(dev, secno + 2, 512);
bh1691fs/hpfs/hpfs_fs.cif (!bh)
bh1693fs/hpfs/hpfs_fs.cmemcpy(data + 2 * 512, bh->b_data, 512);
bh1695fs/hpfs/hpfs_fs.cqbh->bh[3] = bh = bread(dev, secno + 3, 512);
bh1696fs/hpfs/hpfs_fs.cif (!bh)
bh1698fs/hpfs/hpfs_fs.cmemcpy(data + 3 * 512, bh->b_data, 512);
bh1703fs/hpfs/hpfs_fs.cbrelse(qbh->bh[2]);
bh1705fs/hpfs/hpfs_fs.cbrelse(qbh->bh[1]);
bh1707fs/hpfs/hpfs_fs.cbrelse(qbh->bh[0]);
bh1719fs/hpfs/hpfs_fs.cbrelse(qbh->bh[3]);
bh1720fs/hpfs/hpfs_fs.cbrelse(qbh->bh[2]);
bh1721fs/hpfs/hpfs_fs.cbrelse(qbh->bh[1]);
bh1722fs/hpfs/hpfs_fs.cbrelse(qbh->bh[0]);
bh72fs/isofs/dir.cstruct buffer_head * bh;
bh84fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,bufsize)))
bh92fs/isofs/dir.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh100fs/isofs/dir.cbrelse(bh);
bh106fs/isofs/dir.c|| !(bh = bread(inode->i_dev,block,bufsize)))
bh122fs/isofs/dir.cmemcpy(cpnt, bh->b_data, bufsize);
bh125fs/isofs/dir.cbrelse(bh);
bh129fs/isofs/dir.c|| !(bh = bread(inode->i_dev,block,bufsize))) {
bh133fs/isofs/dir.cmemcpy((char *)cpnt+bufsize, bh->b_data, bufsize);
bh225fs/isofs/dir.cbrelse(bh);
bh234fs/isofs/dir.cbrelse(bh);
bh93fs/isofs/file.cstruct buffer_head * bh;
bh97fs/isofs/file.cif (block && (bh = bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode)))) {
bh98fs/isofs/file.cpnt = (unsigned char *) bh->b_data;
bh109fs/isofs/file.cbrelse(bh);
bh123fs/isofs/inode.cstruct buffer_head *bh;
bh158fs/isofs/inode.cif (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits), blocksize))) {
bh166fs/isofs/inode.cvdp = (struct iso_volume_descriptor *)bh->b_data;
bh167fs/isofs/inode.chdp = (struct hs_volume_descriptor *)bh->b_data;
bh193fs/isofs/inode.cbrelse(bh);
bh242fs/isofs/inode.cbrelse(bh);
bh293fs/isofs/inode.cbrelse(bh);
bh325fs/isofs/inode.cstruct buffer_head * bh;
bh334fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, bufsize)))
bh337fs/isofs/inode.cpnt = ((unsigned char *) bh->b_data
bh344fs/isofs/inode.cmemcpy(cpnt, bh->b_data, bufsize);
bh345fs/isofs/inode.cbrelse(bh);
bh346fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, bufsize)))
bh348fs/isofs/inode.cmemcpy((char *)cpnt + bufsize, bh->b_data, bufsize);
bh462fs/isofs/inode.cbrelse(bh);
bh512fs/isofs/inode.cstruct buffer_head * bh;
bh517fs/isofs/inode.cif (!(bh = bread(parent->i_dev, block, bufsize)))  return -1;
bh520fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh523fs/isofs/inode.cbrelse(bh);
bh533fs/isofs/inode.cbrelse(bh);
bh540fs/isofs/inode.cbrelse(bh);
bh555fs/isofs/inode.cif (!block || !(bh = bread(parent->i_dev,block, bufsize)))
bh560fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh569fs/isofs/inode.cbrelse(bh);
bh574fs/isofs/inode.c|| !(bh = bread(parent->i_dev,block, bufsize)))
bh590fs/isofs/inode.cmemcpy(cpnt, bh->b_data, bufsize);
bh593fs/isofs/inode.cbrelse(bh);
bh596fs/isofs/inode.cif (!(bh = bread(parent->i_dev,block,bufsize))) {
bh600fs/isofs/inode.cmemcpy((char *)cpnt+bufsize, bh->b_data, bufsize);
bh622fs/isofs/inode.cbrelse(bh);
bh652fs/isofs/inode.cvoid leak_check_brelse(struct buffer_head * bh){
bh654fs/isofs/inode.creturn brelse(bh);
bh71fs/isofs/namei.cstruct buffer_head * bh;
bh90fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) return NULL;
bh93fs/isofs/namei.cde = (struct iso_directory_record *) (bh->b_data + offset);
bh101fs/isofs/namei.cbrelse(bh);
bh106fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize)))
bh119fs/isofs/namei.cmemcpy(cpnt, bh->b_data, bufsize);
bh122fs/isofs/namei.cbrelse(bh);
bh125fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) {
bh129fs/isofs/namei.cmemcpy((char *)cpnt+bufsize,bh->b_data,bufsize);
bh200fs/isofs/namei.creturn bh;
bh206fs/isofs/namei.cbrelse(bh);
bh214fs/isofs/namei.cstruct buffer_head * bh;
bh244fs/isofs/namei.cif (!(bh = isofs_find_entry(dir,name,len, &ino, &ino_back))) {
bh248fs/isofs/namei.cbrelse(bh);
bh57fs/isofs/rock.cstruct buffer_head * bh; \
bh66fs/isofs/rock.cbh = bread(DEV->i_dev, block, ISOFS_BUFFER_SIZE(DEV)); \
bh67fs/isofs/rock.cif(bh){       \
bh68fs/isofs/rock.cmemcpy(buffer, bh->b_data, cont_size); \
bh69fs/isofs/rock.cbrelse(bh); \
bh372fs/isofs/rock.cstruct buffer_head * bh;
bh391fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, bufsize)))
bh394fs/isofs/rock.cpnt = ((unsigned char *) bh->b_data) + (inode->i_ino & (bufsize - 1));
bh400fs/isofs/rock.cmemcpy(cpnt, bh->b_data, bufsize);
bh401fs/isofs/rock.cbrelse(bh);
bh402fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, bufsize)))
bh404fs/isofs/rock.cmemcpy((char *)cpnt+bufsize, bh->b_data, bufsize);
bh471fs/isofs/rock.cbrelse(bh);
bh45fs/minix/bitmap.cstruct buffer_head *bh;
bh48fs/minix/bitmap.cif (!(bh=map[i])) 
bh57fs/minix/bitmap.ctmp = bh->b_data[end] & ((1<<numbits)-1);
bh62fs/minix/bitmap.csum += nibblemap[bh->b_data[j] & 0xf] 
bh63fs/minix/bitmap.c+ nibblemap[(bh->b_data[j]>>4)&0xf];
bh70fs/minix/bitmap.cstruct buffer_head * bh;
bh82fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
bh83fs/minix/bitmap.cif (bh)
bh84fs/minix/bitmap.cbh->b_dirt=0;
bh85fs/minix/bitmap.cbrelse(bh);
bh89fs/minix/bitmap.cbh = sb->u.minix_sb.s_zmap[zone];
bh90fs/minix/bitmap.cif (!bh) {
bh94fs/minix/bitmap.cif (!clear_bit(bit,bh->b_data))
bh96fs/minix/bitmap.cbh->b_dirt = 1;
bh102fs/minix/bitmap.cstruct buffer_head * bh;
bh112fs/minix/bitmap.cif ((bh=sb->u.minix_sb.s_zmap[i]) != NULL)
bh113fs/minix/bitmap.cif ((j=find_first_zero(bh->b_data))<8192)
bh115fs/minix/bitmap.cif (i>=8 || !bh || j>=8192)
bh117fs/minix/bitmap.cif (set_bit(j,bh->b_data)) {
bh121fs/minix/bitmap.cbh->b_dirt = 1;
bh126fs/minix/bitmap.cif (!(bh = getblk(sb->s_dev,j,BLOCK_SIZE))) {
bh130fs/minix/bitmap.cclear_block(bh->b_data);
bh131fs/minix/bitmap.cbh->b_uptodate = 1;
bh132fs/minix/bitmap.cbh->b_dirt = 1;
bh133fs/minix/bitmap.cbrelse(bh);
bh145fs/minix/bitmap.cstruct buffer_head * bh;
bh171fs/minix/bitmap.cif (!(bh=inode->i_sb->u.minix_sb.s_imap[ino >> 13])) {
bh176fs/minix/bitmap.cif (!clear_bit(ino & 8191, bh->b_data))
bh178fs/minix/bitmap.cbh->b_dirt = 1;
bh185fs/minix/bitmap.cstruct buffer_head * bh;
bh195fs/minix/bitmap.cif ((bh = inode->i_sb->u.minix_sb.s_imap[i]) != NULL)
bh196fs/minix/bitmap.cif ((j=find_first_zero(bh->b_data))<8192)
bh198fs/minix/bitmap.cif (!bh || j >= 8192) {
bh202fs/minix/bitmap.cif (set_bit(j,bh->b_data)) {  /* shouldn't happen */
bh207fs/minix/bitmap.cbh->b_dirt = 1;
bh62fs/minix/dir.cstruct buffer_head * bh;
bh73fs/minix/dir.cbh = minix_bread(inode,(filp->f_pos)>>BLOCK_SIZE_BITS,0);
bh74fs/minix/dir.cif (!bh) {
bh79fs/minix/dir.cde = (struct minix_dir_entry *) (offset + bh->b_data);
bh92fs/minix/dir.cbrelse(bh);
bh97fs/minix/dir.cbrelse(bh);
bh192fs/minix/file.cstruct buffer_head * bh;
bh213fs/minix/file.cbh = minix_getblk(inode,pos/BLOCK_SIZE,1);
bh214fs/minix/file.cif (!bh) {
bh222fs/minix/file.cif (c != BLOCK_SIZE && !bh->b_uptodate) {
bh223fs/minix/file.cll_rw_block(READ, 1, &bh);
bh224fs/minix/file.cwait_on_buffer(bh);
bh225fs/minix/file.cif (!bh->b_uptodate) {
bh226fs/minix/file.cbrelse(bh);
bh232fs/minix/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
bh241fs/minix/file.cbh->b_uptodate = 1;
bh242fs/minix/file.cbh->b_dirt = 1;
bh243fs/minix/file.cbrelse(bh);
bh30fs/minix/fsync.cstruct buffer_head * bh;
bh36fs/minix/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh37fs/minix/fsync.cif (!bh)
bh40fs/minix/fsync.cbrelse (bh);
bh43fs/minix/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh44fs/minix/fsync.cbrelse(bh);
bh47fs/minix/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt)
bh49fs/minix/fsync.cbrelse(bh);
bh52fs/minix/fsync.cll_rw_block(WRITE, 1, &bh);
bh53fs/minix/fsync.cbh->b_count--;
bh58fs/minix/fsync.cstruct buffer_head **bh, int wait) 
bh63fs/minix/fsync.c*bh = NULL;
bh70fs/minix/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh72fs/minix/fsync.cbrelse(*bh);
bh73fs/minix/fsync.c*bh = NULL;
bh76fs/minix/fsync.cif (!*bh)
bh56fs/minix/inode.cstruct buffer_head *bh;
bh63fs/minix/inode.cif (!(bh = bread(dev,1,BLOCK_SIZE))) {
bh69fs/minix/inode.cms = (struct minix_super_block *) bh->b_data;
bh80fs/minix/inode.cbrelse(bh);
bh155fs/minix/inode.cstatic int block_bmap(struct buffer_head * bh, int nr)
bh159fs/minix/inode.cif (!bh)
bh161fs/minix/inode.ctmp = ((unsigned short *) bh->b_data)[nr];
bh162fs/minix/inode.cbrelse(bh);
bh231fs/minix/inode.cstruct buffer_head * bh, int nr, int create)
bh237fs/minix/inode.cif (!bh)
bh239fs/minix/inode.cif (!bh->b_uptodate) {
bh240fs/minix/inode.cll_rw_block(READ, 1, &bh);
bh241fs/minix/inode.cwait_on_buffer(bh);
bh242fs/minix/inode.cif (!bh->b_uptodate) {
bh243fs/minix/inode.cbrelse(bh);
bh247fs/minix/inode.cp = nr + (unsigned short *) bh->b_data;
bh251fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh253fs/minix/inode.cbrelse(bh);
bh260fs/minix/inode.cbrelse(bh);
bh265fs/minix/inode.cbrelse(bh);
bh268fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
bh275fs/minix/inode.cbh->b_dirt = 1;
bh276fs/minix/inode.cbrelse(bh);
bh282fs/minix/inode.cstruct buffer_head * bh;
bh296fs/minix/inode.cbh = inode_getblk(inode,7,create);
bh297fs/minix/inode.creturn block_getblk(inode, bh, block, create);
bh300fs/minix/inode.cbh = inode_getblk(inode,8,create);
bh301fs/minix/inode.cbh = block_getblk(inode, bh, block>>9, create);
bh302fs/minix/inode.creturn block_getblk(inode, bh, block & 511, create);
bh307fs/minix/inode.cstruct buffer_head * bh;
bh309fs/minix/inode.cbh = minix_getblk(inode,block,create);
bh310fs/minix/inode.cif (!bh || bh->b_uptodate)
bh311fs/minix/inode.creturn bh;
bh312fs/minix/inode.cll_rw_block(READ, 1, &bh);
bh313fs/minix/inode.cwait_on_buffer(bh);
bh314fs/minix/inode.cif (bh->b_uptodate)
bh315fs/minix/inode.creturn bh;
bh316fs/minix/inode.cbrelse(bh);
bh322fs/minix/inode.cstruct buffer_head * bh;
bh337fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
bh342fs/minix/inode.craw_inode = ((struct minix_inode *) bh->b_data) +
bh355fs/minix/inode.cbrelse(bh);
bh372fs/minix/inode.cstruct buffer_head * bh;
bh385fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
bh390fs/minix/inode.craw_inode = ((struct minix_inode *)bh->b_data) +
bh403fs/minix/inode.cbh->b_dirt=1;
bh404fs/minix/inode.creturn bh;
bh409fs/minix/inode.cstruct buffer_head *bh;
bh410fs/minix/inode.cbh = minix_update_inode(inode);
bh411fs/minix/inode.cbrelse(bh);
bh417fs/minix/inode.cstruct buffer_head *bh;
bh419fs/minix/inode.cbh = minix_update_inode(inode);
bh420fs/minix/inode.cif (bh && bh->b_dirt)
bh422fs/minix/inode.cll_rw_block(WRITE, 1, &bh);
bh423fs/minix/inode.cwait_on_buffer(bh);
bh424fs/minix/inode.cif (bh->b_req && !bh->b_uptodate)
bh431fs/minix/inode.celse if (!bh)
bh433fs/minix/inode.cbrelse (bh);
bh45fs/minix/namei.cstruct buffer_head * bh, unsigned long * offset,
bh50fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + *offset);
bh72fs/minix/namei.cstruct buffer_head * bh;
bh86fs/minix/namei.cbh = NULL;
bh89fs/minix/namei.cif (!bh) {
bh90fs/minix/namei.cbh = minix_bread(dir,block,0);
bh91fs/minix/namei.cif (!bh) {
bh96fs/minix/namei.c*res_dir = (struct minix_dir_entry *) (bh->b_data + offset);
bh97fs/minix/namei.cif (minix_match(namelen,name,bh,&offset,info))
bh98fs/minix/namei.creturn bh;
bh99fs/minix/namei.cif (offset < bh->b_size)
bh101fs/minix/namei.cbrelse(bh);
bh102fs/minix/namei.cbh = NULL;
bh106fs/minix/namei.cbrelse(bh);
bh116fs/minix/namei.cstruct buffer_head * bh;
bh125fs/minix/namei.cif (!(bh = minix_find_entry(dir,name,len,&de))) {
bh130fs/minix/namei.cbrelse(bh);
bh156fs/minix/namei.cstruct buffer_head * bh;
bh174fs/minix/namei.cbh = NULL;
bh177fs/minix/namei.cif (!bh) {
bh178fs/minix/namei.cbh = minix_bread(dir,block,1);
bh179fs/minix/namei.cif (!bh)
bh182fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
bh184fs/minix/namei.cif (block*bh->b_size + offset > dir->i_size) {
bh186fs/minix/namei.cdir->i_size = block*bh->b_size + offset;
bh191fs/minix/namei.cbrelse(bh);
bh198fs/minix/namei.cbh->b_dirt = 1;
bh202fs/minix/namei.cif (offset < bh->b_size)
bh204fs/minix/namei.cbrelse(bh);
bh205fs/minix/namei.cbh = NULL;
bh209fs/minix/namei.c*res_buf = bh;
bh218fs/minix/namei.cstruct buffer_head * bh;
bh232fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
bh241fs/minix/namei.cbh->b_dirt = 1;
bh242fs/minix/namei.cbrelse(bh);
bh252fs/minix/namei.cstruct buffer_head * bh;
bh257fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh258fs/minix/namei.cif (bh) {
bh259fs/minix/namei.cbrelse(bh);
bh289fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh298fs/minix/namei.cbh->b_dirt = 1;
bh299fs/minix/namei.cbrelse(bh);
bh309fs/minix/namei.cstruct buffer_head * bh, *dir_block;
bh318fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh319fs/minix/namei.cif (bh) {
bh320fs/minix/namei.cbrelse(bh);
bh356fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh364fs/minix/namei.cbh->b_dirt = 1;
bh369fs/minix/namei.cbrelse(bh);
bh379fs/minix/namei.cstruct buffer_head * bh;
bh387fs/minix/namei.cbh = NULL;
bh393fs/minix/namei.cbh = minix_bread(inode,0,0);
bh394fs/minix/namei.cif (!bh)
bh396fs/minix/namei.cde = (struct minix_dir_entry *) bh->b_data;
bh399fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + info->s_dirsize);
bh403fs/minix/namei.cif (!bh) {
bh404fs/minix/namei.cbh = minix_bread(inode,block,0);
bh405fs/minix/namei.cif (!bh) {
bh410fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
bh413fs/minix/namei.cbrelse(bh);
bh416fs/minix/namei.cif (offset < bh->b_size)
bh418fs/minix/namei.cbrelse(bh);
bh419fs/minix/namei.cbh = NULL;
bh423fs/minix/namei.cbrelse(bh);
bh426fs/minix/namei.cbrelse(bh);
bh435fs/minix/namei.cstruct buffer_head * bh;
bh439fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh441fs/minix/namei.cif (!bh)
bh472fs/minix/namei.cbh->b_dirt = 1;
bh482fs/minix/namei.cbrelse(bh);
bh490fs/minix/namei.cstruct buffer_head * bh;
bh496fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh497fs/minix/namei.cif (!bh)
bh506fs/minix/namei.cbrelse(bh);
bh525fs/minix/namei.cbh->b_dirt = 1;
bh533fs/minix/namei.cbrelse(bh);
bh543fs/minix/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh569fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh570fs/minix/namei.cif (bh) {
bh574fs/minix/namei.cbrelse(bh);
bh578fs/minix/namei.ci = minix_add_entry(dir, name, len, &bh, &de);
bh587fs/minix/namei.cbh->b_dirt = 1;
bh588fs/minix/namei.cbrelse(bh);
bh598fs/minix/namei.cstruct buffer_head * bh;
bh610fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
bh611fs/minix/namei.cif (bh) {
bh612fs/minix/namei.cbrelse(bh);
bh617fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
bh624fs/minix/namei.cbh->b_dirt = 1;
bh625fs/minix/namei.cbrelse(bh);
bh45fs/minix/symlink.cstruct buffer_head * bh;
bh66fs/minix/symlink.cif (!(bh = minix_bread(inode, 0, 0))) {
bh73fs/minix/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh75fs/minix/symlink.cbrelse(bh);
bh81fs/minix/symlink.cstruct buffer_head * bh;
bh91fs/minix/symlink.cbh = minix_bread(inode, 0, 0);
bh93fs/minix/symlink.cif (!bh)
bh96fs/minix/symlink.cwhile (i<buflen && (c = bh->b_data[i])) {
bh100fs/minix/symlink.cbrelse(bh);
bh30fs/minix/truncate.cstruct buffer_head * bh;
bh40fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh42fs/minix/truncate.cbrelse(bh);
bh45fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *p) {
bh47fs/minix/truncate.cbrelse(bh);
bh52fs/minix/truncate.cbrelse(bh);
bh60fs/minix/truncate.cstruct buffer_head * bh;
bh89fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
bh91fs/minix/truncate.cbrelse(bh);
bh94fs/minix/truncate.cif ((bh && bh->b_count != 1) || tmp != *ind) {
bh96fs/minix/truncate.cbrelse(bh);
bh101fs/minix/truncate.cbrelse(bh);
bh62fs/msdos/dir.cstruct buffer_head *bh;
bh80fs/msdos/dir.cbh = NULL;
bh81fs/msdos/dir.cwhile ((ino = msdos_get_entry(inode,&filp->f_pos,&bh,&de)) > -1) {
bh107fs/msdos/dir.cbrelse(bh);
bh112fs/msdos/dir.cif (bh) brelse(bh);
bh20fs/msdos/fat.cstruct buffer_head *bh,*bh2,*c_bh,*c_bh2;
bh31fs/msdos/fat.cif (!(bh = msdos_sread(sb->s_dev,MSDOS_SB(sb)->fat_start+(first >>
bh37fs/msdos/fat.cbh2 = bh;
bh43fs/msdos/fat.cbrelse(bh);
bh77fs/msdos/fat.cbh->b_dirt = 1;
bh84fs/msdos/fat.cif (data != data2 || bh != bh2) {
bh98fs/msdos/fat.cbrelse(bh);
bh86fs/msdos/file.cstruct buffer_head *bh;
bh104fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) break;
bh117fs/msdos/file.cbrelse(bh);
bh126fs/msdos/file.cbrelse(bh);
bh141fs/msdos/file.cstruct buffer_head *bh;
bh168fs/msdos/file.cif (!(bh = msdos_sread(inode->i_dev,sector,&data))) {
bh203fs/msdos/file.cbh->b_dirt = 1;
bh204fs/msdos/file.cbrelse(bh);
bh147fs/msdos/inode.cstruct buffer_head *bh;
bh163fs/msdos/inode.cbh = bread(s->s_dev, 0, BLOCK_SIZE);
bh165fs/msdos/inode.cif (bh == NULL) {
bh170fs/msdos/inode.cb = (struct msdos_boot_sector *) bh->b_data;
bh220fs/msdos/inode.cbrelse(bh);
bh307fs/msdos/inode.cstruct buffer_head *bh;
bh334fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
bh339fs/msdos/inode.craw_entry = &((struct msdos_dir_entry *) (bh->b_data))
bh386fs/msdos/inode.cbrelse(bh);
bh392fs/msdos/inode.cstruct buffer_head *bh;
bh397fs/msdos/inode.cif (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
bh402fs/msdos/inode.craw_entry = &((struct msdos_dir_entry *) (bh->b_data))
bh418fs/msdos/inode.cbh->b_dirt = 1;
bh419fs/msdos/inode.cbrelse(bh);
bh113fs/msdos/misc.cstruct buffer_head *bh;
bh172fs/msdos/misc.cif (!(bh = getblk(inode->i_dev,sector >> 1,
bh176fs/msdos/misc.cmemset(bh->b_data,0,BLOCK_SIZE);
bh177fs/msdos/misc.cbh->b_uptodate = 1;
bh182fs/msdos/misc.cif (!(bh = msdos_sread(inode->i_dev,sector,
bh187fs/msdos/misc.cif (bh) {
bh188fs/msdos/misc.cbh->b_dirt = 1;
bh189fs/msdos/misc.cbrelse(bh);
bh267fs/msdos/misc.cint msdos_get_entry(struct inode *dir, off_t *pos,struct buffer_head **bh,
bh280fs/msdos/misc.cif (*bh)
bh281fs/msdos/misc.cbrelse(*bh);
bh282fs/msdos/misc.cif (!(*bh = msdos_sread(dir->i_dev,sector,&data))) {
bh350fs/msdos/misc.cstruct buffer_head *bh;
bh355fs/msdos/misc.cif (!(bh = msdos_sread(sb->s_dev,sector,(void **) &data))) return -EIO;
bh368fs/msdos/misc.cif (!res_bh) brelse(bh);
bh370fs/msdos/misc.c*res_bh = bh;
bh376fs/msdos/misc.cbrelse(bh);
bh94fs/msdos/namei.cstruct buffer_head **bh,struct msdos_dir_entry **de,int *ino)
bh101fs/msdos/namei.creturn msdos_scan(dir,msdos_name,bh,de,ino);
bh110fs/msdos/namei.cstruct buffer_head *bh;
bh130fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
bh134fs/msdos/namei.cif (bh) brelse(bh);
bh164fs/msdos/namei.cstruct buffer_head *bh;
bh168fs/msdos/namei.cif ((res = msdos_scan(dir,NULL,&bh,&de,&ino)) < 0) {
bh172fs/msdos/namei.cif ((res = msdos_scan(dir,NULL,&bh,&de,&ino)) < 0) return res;
bh184fs/msdos/namei.cbh->b_dirt = 1;
bh187fs/msdos/namei.cbrelse(bh);
bh199fs/msdos/namei.cstruct buffer_head *bh;
bh211fs/msdos/namei.cif (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) {
bh213fs/msdos/namei.cbrelse(bh);
bh246fs/msdos/namei.cstruct buffer_head *bh;
bh258fs/msdos/namei.cif (msdos_scan(dir,msdos_name,&bh,&de,&ino) >= 0) {
bh260fs/msdos/namei.cbrelse(bh);
bh304fs/msdos/namei.cstruct buffer_head *bh;
bh311fs/msdos/namei.cbh = NULL;
bh312fs/msdos/namei.cwhile (msdos_get_entry(dir,&pos,&bh,&de) > -1)
bh316fs/msdos/namei.cbrelse(bh);
bh319fs/msdos/namei.cif (bh)
bh320fs/msdos/namei.cbrelse(bh);
bh329fs/msdos/namei.cstruct buffer_head *bh;
bh333fs/msdos/namei.cbh = NULL;
bh338fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
bh353fs/msdos/namei.cbh->b_dirt = 1;
bh356fs/msdos/namei.cbrelse(bh);
bh366fs/msdos/namei.cstruct buffer_head *bh;
bh370fs/msdos/namei.cbh = NULL;
bh372fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
bh387fs/msdos/namei.cbh->b_dirt = 1;
bh389fs/msdos/namei.cbrelse(bh);
bh32fs/xiafs/bitmap.cstatic int find_first_zero(struct buffer_head *bh, int start_bit, int end_bit) 
bh44fs/xiafs/bitmap.cbmap=(u_long *)bh->b_data;
bh68fs/xiafs/bitmap.cbh->b_dirt=1;
bh72fs/xiafs/bitmap.cstatic void clear_buf(struct buffer_head * bh) 
bh77fs/xiafs/bitmap.clp=(long *)bh->b_data;
bh78fs/xiafs/bitmap.cfor (i= bh->b_size >> 2; i-- > 0; )
bh179fs/xiafs/bitmap.cstruct buffer_head * bh;
bh202fs/xiafs/bitmap.cbh = get__map_zone(sb, bmap_buf, bznr, cache, first_zone, 
bh204fs/xiafs/bitmap.cif (!bh)
bh206fs/xiafs/bitmap.ctmp=find_first_zero(bh, start_bit, end_bit);
bh223fs/xiafs/bitmap.cstruct buffer_head * bh;
bh235fs/xiafs/bitmap.cbh = get_hash_table(sb->s_dev, d_addr, XIAFS_ZSIZE(sb));
bh236fs/xiafs/bitmap.cif (bh)
bh237fs/xiafs/bitmap.cbh->b_dirt=0;
bh238fs/xiafs/bitmap.cbrelse(bh);
bh240fs/xiafs/bitmap.cbh = get_zmap_zone(sb, bit, NULL);
bh241fs/xiafs/bitmap.cif (!bh)
bh244fs/xiafs/bitmap.cif (clear_bit(offset, bh->b_data))
bh248fs/xiafs/bitmap.cbh->b_dirt = 1;
bh254fs/xiafs/bitmap.cstruct buffer_head * bh;
bh270fs/xiafs/bitmap.cif (!(bh = getblk(sb->s_dev, tmp, XIAFS_ZSIZE(sb)))) {
bh274fs/xiafs/bitmap.cif (bh->b_count != 1) {
bh278fs/xiafs/bitmap.cclear_buf(bh);
bh279fs/xiafs/bitmap.cbh->b_uptodate = 1;
bh280fs/xiafs/bitmap.cbh->b_dirt = 1;
bh281fs/xiafs/bitmap.cbrelse(bh);
bh287fs/xiafs/bitmap.cstruct buffer_head * bh;
bh300fs/xiafs/bitmap.cbh = get_imap_zone(sb, ino, NULL);
bh301fs/xiafs/bitmap.cif (!bh)
bh304fs/xiafs/bitmap.cif (clear_bit(ino & (XIAFS_BITS_PER_Z(sb)-1), bh->b_data))
bh308fs/xiafs/bitmap.cbh->b_dirt = 1;
bh346fs/xiafs/bitmap.cstatic u_long count_zone(struct buffer_head * bh)
bh352fs/xiafs/bitmap.cfor (i=bh->b_size; i-- > 0; ) {
bh353fs/xiafs/bitmap.ctmp=bh->b_data[i];
bh361fs/xiafs/bitmap.cstruct buffer_head * bh;
bh368fs/xiafs/bitmap.cbh=get_imap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
bh369fs/xiafs/bitmap.cif (bh) {
bh370fs/xiafs/bitmap.csum += count_zone(bh);
bh380fs/xiafs/bitmap.cstruct buffer_head * bh;
bh387fs/xiafs/bitmap.cbh=get_zmap_zone(sb, i << XIAFS_BITS_PER_Z_BITS(sb), &not_que);
bh388fs/xiafs/bitmap.cif (bh) {
bh389fs/xiafs/bitmap.csum += count_zone(bh);
bh69fs/xiafs/dir.cstruct buffer_head * bh;
bh78fs/xiafs/dir.cbh = xiafs_bread(inode, filp->f_pos >> XIAFS_ZSIZE_BITS(inode->i_sb),0);
bh79fs/xiafs/dir.cif (!bh) {
bh83fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
bh87fs/xiafs/dir.c(char *)de+de->d_rec_len > XIAFS_ZSIZE(inode->i_sb)+bh->b_data ||
bh92fs/xiafs/dir.cbrelse(bh);
bh103fs/xiafs/dir.cbrelse(bh);
bh110fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
bh112fs/xiafs/dir.cbrelse(bh);
bh193fs/xiafs/file.cstruct buffer_head * bh;
bh214fs/xiafs/file.cbh = xiafs_getblk(inode, pos >> XIAFS_ZSIZE_BITS(inode->i_sb), 1);
bh215fs/xiafs/file.cif (!bh) {
bh223fs/xiafs/file.cif (c != XIAFS_ZSIZE(inode->i_sb) && !bh->b_uptodate) {
bh224fs/xiafs/file.cll_rw_block(READ, 1, &bh);
bh225fs/xiafs/file.cwait_on_buffer(bh);
bh226fs/xiafs/file.cif (!bh->b_uptodate) {
bh227fs/xiafs/file.cbrelse(bh);
bh233fs/xiafs/file.ccp = (pos & (XIAFS_ZSIZE(inode->i_sb)-1)) + bh->b_data;
bh242fs/xiafs/file.cbh->b_uptodate = 1;
bh243fs/xiafs/file.cbh->b_dirt = 1;
bh244fs/xiafs/file.cbrelse(bh);
bh32fs/xiafs/fsync.cstruct buffer_head * bh;
bh38fs/xiafs/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
bh39fs/xiafs/fsync.cif (!bh)
bh42fs/xiafs/fsync.cbrelse (bh);
bh45fs/xiafs/fsync.cif (wait && bh->b_req && !bh->b_uptodate) {
bh46fs/xiafs/fsync.cbrelse(bh);
bh49fs/xiafs/fsync.cif (wait || !bh->b_uptodate || !bh->b_dirt)
bh51fs/xiafs/fsync.cbrelse(bh);
bh54fs/xiafs/fsync.cll_rw_block(WRITE, 1, &bh);
bh55fs/xiafs/fsync.cbh->b_count--;
bh60fs/xiafs/fsync.cstruct buffer_head **bh, int wait) 
bh64fs/xiafs/fsync.c*bh = NULL;
bh71fs/xiafs/fsync.c*bh = bread(inode->i_dev, tmp, blocksize);
bh73fs/xiafs/fsync.cbrelse(*bh);
bh74fs/xiafs/fsync.c*bh = NULL;
bh77fs/xiafs/fsync.cif (!*bh)
bh62fs/xiafs/inode.cstruct buffer_head *bh;
bh71fs/xiafs/inode.cif (!(bh = bread(dev, 0, BLOCK_SIZE))) {
bh77fs/xiafs/inode.csp = (struct xiafs_super_block *) bh->b_data;
bh82fs/xiafs/inode.cbrelse(bh);
bh93fs/xiafs/inode.cbrelse(bh);
bh95fs/xiafs/inode.cbh = bread (dev, 0,  s->s_blocksize);
bh96fs/xiafs/inode.cif(!bh) return NULL;
bh97fs/xiafs/inode.csp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
bh107fs/xiafs/inode.cbrelse(bh);
bh174fs/xiafs/inode.cstatic int zone_bmap(struct buffer_head * bh, int nr)
bh178fs/xiafs/inode.cif (!bh)
bh180fs/xiafs/inode.ctmp = ((u_long *) bh->b_data)[nr];
bh181fs/xiafs/inode.cbrelse(bh);
bh264fs/xiafs/inode.cindt_getblk(struct inode * inode, struct buffer_head * bh, 
bh271fs/xiafs/inode.cif (!bh)
bh273fs/xiafs/inode.cif (!bh->b_uptodate) {
bh274fs/xiafs/inode.cll_rw_block(READ, 1, &bh);
bh275fs/xiafs/inode.cwait_on_buffer(bh);
bh276fs/xiafs/inode.cif (!bh->b_uptodate) {
bh277fs/xiafs/inode.cbrelse(bh);
bh281fs/xiafs/inode.clp = nr + (u_long *) bh->b_data;
bh284fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh286fs/xiafs/inode.cbrelse(bh);
bh293fs/xiafs/inode.cbrelse(bh);
bh298fs/xiafs/inode.cbrelse(bh);
bh301fs/xiafs/inode.cresult = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh309fs/xiafs/inode.cbh->b_dirt = 1;
bh310fs/xiafs/inode.cbrelse(bh);
bh316fs/xiafs/inode.cstruct buffer_head * bh;
bh334fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_ind_zone), create, prev_addr);
bh335fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone, create, prev_addr);
bh336fs/xiafs/inode.creturn bh;
bh339fs/xiafs/inode.cbh = dt_getblk(inode, &(inode->u.xiafs_i.i_dind_zone), create, prev_addr);
bh340fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb), 
bh342fs/xiafs/inode.cbh = indt_getblk(inode, bh, zone&(XIAFS_ADDRS_PER_Z(inode->i_sb)-1), 
bh344fs/xiafs/inode.creturn bh;
bh349fs/xiafs/inode.cstruct buffer_head * bh;
bh351fs/xiafs/inode.cbh = xiafs_getblk(inode, zone, create);
bh352fs/xiafs/inode.cif (!bh || bh->b_uptodate)
bh353fs/xiafs/inode.creturn bh;
bh354fs/xiafs/inode.cll_rw_block(READ, 1, &bh);
bh355fs/xiafs/inode.cwait_on_buffer(bh);
bh356fs/xiafs/inode.cif (bh->b_uptodate)
bh357fs/xiafs/inode.creturn bh;
bh358fs/xiafs/inode.cbrelse(bh);
bh364fs/xiafs/inode.cstruct buffer_head * bh;
bh379fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
bh383fs/xiafs/inode.craw_inode = ((struct xiafs_inode *) bh->b_data) + 
bh404fs/xiafs/inode.cbrelse(bh);
bh421fs/xiafs/inode.cstruct buffer_head * bh;
bh441fs/xiafs/inode.cif (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
bh446fs/xiafs/inode.craw_inode = ((struct xiafs_inode *)bh->b_data) +
bh469fs/xiafs/inode.cbh->b_dirt=1;
bh470fs/xiafs/inode.creturn bh;
bh476fs/xiafs/inode.cstruct buffer_head * bh;
bh477fs/xiafs/inode.cbh = xiafs_update_inode(inode);
bh478fs/xiafs/inode.cbrelse (bh);
bh484fs/xiafs/inode.cstruct buffer_head *bh;
bh486fs/xiafs/inode.cbh = xiafs_update_inode(inode);
bh487fs/xiafs/inode.cif (bh && bh->b_dirt)
bh489fs/xiafs/inode.cll_rw_block(WRITE, 1, &bh);
bh490fs/xiafs/inode.cwait_on_buffer(bh);
bh491fs/xiafs/inode.cif (bh->b_req && !bh->b_uptodate)
bh498fs/xiafs/inode.celse if (!bh)
bh500fs/xiafs/inode.cbrelse (bh);
bh61fs/xiafs/namei.cstruct buffer_head * bh;
bh76fs/xiafs/namei.cbh = xiafs_bread(inode, i, 0);
bh77fs/xiafs/namei.cif (!bh)
bh79fs/xiafs/namei.cdep_pre=dep=(struct xiafs_direct *)bh->b_data;
bh83fs/xiafs/namei.cbrelse(bh);
bh90fs/xiafs/namei.cdep->d_rec_len+(char *)dep > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
bh93fs/xiafs/namei.cbrelse(bh);
bh100fs/xiafs/namei.creturn bh;
bh104fs/xiafs/namei.cdep=(struct xiafs_direct *)(bh->b_data + pos);
bh106fs/xiafs/namei.cbrelse(bh);
bh120fs/xiafs/namei.cstruct buffer_head * bh;
bh129fs/xiafs/namei.cif (!(bh = xiafs_find_entry(dir, name, len, &dep, NULL))) {
bh134fs/xiafs/namei.cbrelse(bh);
bh158fs/xiafs/namei.cstruct buffer_head * bh;
bh171fs/xiafs/namei.cbh =  xiafs_bread(dir, pos >> XIAFS_ZSIZE_BITS(dir->i_sb), pos ? 1:0);
bh172fs/xiafs/namei.cif (!bh)
bh174fs/xiafs/namei.cde_pre=de=(struct xiafs_direct *)bh->b_data;
bh179fs/xiafs/namei.cbrelse(bh);
bh183fs/xiafs/namei.cde_pre=de=(struct xiafs_direct *)(bh->b_data+12);
bh197fs/xiafs/namei.c(char *)de+de->d_rec_len > bh->b_data+XIAFS_ZSIZE(dir->i_sb) ||
bh201fs/xiafs/namei.cbrelse(bh);
bh224fs/xiafs/namei.cbh->b_dirt = 1;
bh228fs/xiafs/namei.creturn bh;
bh232fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
bh234fs/xiafs/namei.cbrelse(bh);
bh248fs/xiafs/namei.cstruct buffer_head * bh;
bh262fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh263fs/xiafs/namei.cif (!bh) {
bh271fs/xiafs/namei.cbh->b_dirt = 1;
bh272fs/xiafs/namei.cbrelse(bh);
bh281fs/xiafs/namei.cstruct buffer_head * bh;
bh286fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
bh287fs/xiafs/namei.cif (bh) {
bh288fs/xiafs/namei.cbrelse(bh);
bh319fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh320fs/xiafs/namei.cif (!bh) {
bh328fs/xiafs/namei.cbh->b_dirt = 1;
bh329fs/xiafs/namei.cbrelse(bh);
bh338fs/xiafs/namei.cstruct buffer_head * bh, *dir_block;
bh341fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
bh342fs/xiafs/namei.cif (bh) {
bh343fs/xiafs/namei.cbrelse(bh);
bh384fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh385fs/xiafs/namei.cif (!bh) {
bh392fs/xiafs/namei.cbh->b_dirt = 1;
bh397fs/xiafs/namei.cbrelse(bh);
bh407fs/xiafs/namei.cstruct buffer_head * bh;
bh417fs/xiafs/namei.cbh =  xiafs_bread(inode, i, 0);
bh419fs/xiafs/namei.cif (!bh) {
bh423fs/xiafs/namei.cde=(struct xiafs_direct *)bh->b_data;
bh427fs/xiafs/namei.cbrelse(bh);
bh430fs/xiafs/namei.cde=(struct xiafs_direct *)(12 + bh->b_data);
bh433fs/xiafs/namei.cbrelse(bh);
bh440fs/xiafs/namei.cif (!bh)
bh443fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
bh446fs/xiafs/namei.c(char *)de+de->d_rec_len > bh->b_data+XIAFS_ZSIZE(inode->i_sb) ||
bh450fs/xiafs/namei.cbrelse(bh);
bh454fs/xiafs/namei.cbrelse(bh);
bh459fs/xiafs/namei.cbrelse(bh);
bh488fs/xiafs/namei.cstruct buffer_head * bh;
bh492fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
bh494fs/xiafs/namei.cif (!bh)
bh521fs/xiafs/namei.cbh->b_dirt = 1;
bh531fs/xiafs/namei.cbrelse(bh);
bh539fs/xiafs/namei.cstruct buffer_head * bh;
bh545fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
bh546fs/xiafs/namei.cif (!bh)
bh555fs/xiafs/namei.cbrelse(bh);
bh569fs/xiafs/namei.cbh->b_dirt = 1;
bh576fs/xiafs/namei.cbrelse(bh);
bh587fs/xiafs/namei.cstruct buffer_head * bh = NULL, * name_block = NULL;
bh591fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
bh592fs/xiafs/namei.cif (bh) {
bh593fs/xiafs/namei.cbrelse(bh);
bh618fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh619fs/xiafs/namei.cif (!bh) {
bh627fs/xiafs/namei.cbh->b_dirt = 1;
bh628fs/xiafs/namei.cbrelse(bh);
bh638fs/xiafs/namei.cstruct buffer_head * bh;
bh650fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
bh651fs/xiafs/namei.cif (bh) {
bh652fs/xiafs/namei.cbrelse(bh);
bh657fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
bh658fs/xiafs/namei.cif (!bh) {
bh664fs/xiafs/namei.cbh->b_dirt = 1;
bh665fs/xiafs/namei.cbrelse(bh);
bh49fs/xiafs/symlink.cstruct buffer_head * bh;
bh59fs/xiafs/symlink.cbh = xiafs_bread(inode, 0, 0);
bh65fs/xiafs/symlink.cif (!bh)
bh67fs/xiafs/symlink.cfor (i=0; i < buflen && (c=bh->b_data[i]); i++)
bh71fs/xiafs/symlink.cbrelse(bh);
bh79fs/xiafs/symlink.cstruct buffer_head * bh;
bh104fs/xiafs/symlink.cif (!(bh = xiafs_bread(inode, 0, 0))) {
bh111fs/xiafs/symlink.cerror = open_namei(bh->b_data,flag,mode,res_inode,dir);
bh113fs/xiafs/symlink.cbrelse(bh);
bh42fs/xiafs/truncate.cstruct buffer_head * bh;
bh53fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh55fs/xiafs/truncate.cbrelse(bh);
bh58fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *lp)
bh66fs/xiafs/truncate.cbrelse(bh);
bh76fs/xiafs/truncate.cstruct buffer_head * bh, * ind_bh;
bh99fs/xiafs/truncate.cbh = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
bh101fs/xiafs/truncate.cbrelse(bh);
bh104fs/xiafs/truncate.cif ((bh && bh->b_count != 1) || tmp != *indp)
bh112fs/xiafs/truncate.cbrelse(bh);
bh379include/linux/fs.hextern void ll_rw_block(int rw, int nr, struct buffer_head * bh[]);
bh212include/linux/iso_fs.hextern void leak_check_brelse(struct buffer_head * bh);
bh10include/linux/locks.hextern inline void wait_on_buffer(struct buffer_head * bh)
bh12include/linux/locks.hif (bh->b_lock)
bh13include/linux/locks.h__wait_on_buffer(bh);
bh16include/linux/locks.hextern inline void lock_buffer(struct buffer_head * bh)
bh18include/linux/locks.hif (bh->b_lock)
bh19include/linux/locks.h__wait_on_buffer(bh);
bh20include/linux/locks.hbh->b_lock = 1;
bh23include/linux/locks.hextern inline void unlock_buffer(struct buffer_head * bh)
bh25include/linux/locks.hbh->b_lock = 0;
bh26include/linux/locks.hwake_up(&bh->b_wait);
bh115include/linux/msdos_fs.hstruct buffer_head *bh;
bh117include/linux/msdos_fs.hif (!(bh = bread(dev,sector >> 1, 1024)))
bh119include/linux/msdos_fs.h*start = bh->b_data+((sector & 1) << SECTOR_BITS);
bh120include/linux/msdos_fs.hreturn bh;
bh136include/linux/msdos_fs.hextern int msdos_get_entry(struct inode *dir,off_t *pos,struct buffer_head **bh,
bh94kernel/irq.cstruct bh_struct *bh;
bh96kernel/irq.cbh = bh_base;
bh98kernel/irq.cfor (mask = 1, left = ~0 ; left & active ; bh++,mask += mask,left += left) {
bh102kernel/irq.cfn = bh->routine;
bh105kernel/irq.cfn(bh->data);
bh313mm/mmap.cstruct buffer_head * bh;
bh323mm/mmap.cif (!(bh = bread(inode->i_dev,bmap(inode,0),inode->i_sb->s_blocksize)))
bh329mm/mmap.cbrelse(bh);