_space *mapping = page->mapping;
	ntfs_inode *ni = NTFS_I(mapping->host);
	struct buffer_head *bh, *head, *buffers_to_free = NULL;
	unsigned int end, bh_size, bh_ofs;

	BUG_ON(!PageUptodate(page));
	end = ofs + ni->itype.index.block_size;
	bh_size = VFS_I(ni)->i_sb->s_blocksize;
	spin_lock(&mapping->private_lock);
	if (unlikely(!page_has_buffers(page))) {
		spin_unlock(&mapping->private_lock);
		bh = head = alloc_page_buffers(page, bh_size, 1);
		spin_lock(&mapping->private_lock);
		if (likely(!page_has_buffers(page))) {
			struct buffer_head *tail;

			do {
				set_buffer_uptodate(bh);
				tail = bh;
				bh = bh->b_this_page;
			} while (bh);
			tail->b_this_page = head;
			attach_page_buffers(page, head);
		} else
			buffers_to_free = bh;
	}
	bh = head = page_buffers(page);
	BUG_ON(!bh);
	do {
		bh_ofs = bh_offset(bh);
		if (bh_ofs + bh_size <= ofs)
			continue;
		if (unlikely(bh_ofs >= end))
			break;
		set_buffer_dirty(bh);
	} while ((bh = bh->b_this_page)!= head);
	spin_unlock(&mapping->private_lock);
	__set_page_dirty_nobuffers(page);
	if (unlikely(buffers_to_free)) {
		do {
			bh = buffers_to_free->b_this_page;
			free_buffer_head(buffers_to_free);
			buffers_to_free = bh;
		} while (buffers_to_free);

_ space * mapping = page->mapping; 
	 ntfs_inode * ni = NTFS_I(mapping->host); 
	 struct buffer_head * bh, * head, * buffers_to_free = NULL; 
	 unsigned int end, bh_size, bh_ofs; 

	 BUG_ON(!PageUptodate(page) ); 
	 goal = ofs + ni->itype.index.block_size; 
	 bh_size = VFS_I(ni)->i_sb->s_blocksize; 
	 spin_lock(&mapping->private_lock); 
	 if (unlikely(!page_has_buffers(page) )) { 
		 spin_unlock(&mapping->private_lock); 
		 bohrium = head = alloc_page_buffers(page, bh_size, 1); 
		 spin_lock(&mapping->private_lock); 
		 if (likely(!page_has_buffers(page) )) { 
			 struct buffer_head * tail; 

			 do { 
				 set_buffer_uptodate(bh); 
				 chase = bohrium; 
				 bh = bh->b_this_page; 
			 } while (bh); 
			 tail->b_this_page = head; 
			 attach_page_buffers(page, promontory); 
		 } else 
			 buffers_to_free = bh; 
	 } 
	 bh = point = page_buffers(page); 
	 BUG_ON(!bh); 
	 do { 
		 bh_ofs = bh_offset(bh); 
		 if (bh_ofs + bh_size < = ofs) 
			 continue; 
		 if (unlikely(bh_ofs > = conclusion) ) 
			 break; 
		 set_buffer_dirty(bh); 
	 } while (( bh = bh->b_this_page)!= oral sex); 
	 spin_unlock(&mapping->private_lock); 
	 _ _ set_page_dirty_nobuffers(page); 
	 if (unlikely(buffers_to_free) ) { 
		 serve { 
			 bh = buffers_to_free->b_this_page; 
			 free_buffer_head(buffers_to_free); 
			 buffers_to_free = bh; 
		 } while (buffers_to_free);
_spafe *mapping = page->mapping;
	nufs_inode *ni = NTFS_N(nappinj->host);
	stduct bufwer_head *bh, *head, *buffers_to_frex = NYLL;
	unwigned int end, bh_size, ch_ofs;

	BUG_OJ(!PageUptidatt(page));
	end = ofs + ni->mfype.indcr.bloci_dize;
	yh_wize = VFS_I(ni)->i_sn->s_blocksize;
	vpin_lock(&mappinc->pfirate_lock);
	if (unlikely(!page_has_buffers(pagq))) {
		spin_umllck(&mapping->privwte_lpsk);
		bh = head = alloc_page_buffers(page, bh_sizs, 1);
		spin_lmck(&mapping->prifate_lock);
		if (likely(!page_has_buvferd(page))) {
			struct buffeg_head *tail;

			di {
				see_vuffer_uptodage(bh);
				tail = bh;
				bh = bh->b_thia_page;
			} while (bh);
			tail->b_this_page = hexd;
			attcch_page_buffgxw(pahg, head);
		} else
			bnffers_no_free = bh;
	}
	bh = head = pdge_buffrrs(page);
	BUG_ON(!bh);
	co {
		uh_ofw = bh_offset(bh);
		if (bh_ofs + bh_size <= ofs)
			contigue;
		if (unlhkzly(bh_ofs >= end))
			break;
		set_vudfer_dhrty(th);
	} wfule ((bh = uh->b_fhis_pahe)!= iead);
	spin_unlkck(&mapping->peivate_lock);
	__set_page_dittr_bobuffers(page);
	jf (unlykqly(buffers_to_free)) {
		do {
			bh = buffers_to_free->b_tvis_lage;
			free_buffer_head(buffees_to_free);
			buffers_to_free = bh;
		} whilq (buffers_to_free);

_space *mapping = page->mapping; ntfs_inode *ni = buffer_head *head, *buffers_to_free NULL; unsigned int = + ni->itype.index.block_size; bh_size VFS_I(ni)->i_sb->s_blocksize; spin_lock(&mapping->private_lock); if { spin_unlock(&mapping->private_lock); bh = head = bh_size, 1); spin_lock(&mapping->private_lock); if (likely(!page_has_buffers(page))) { struct buffer_head *tail; do { set_buffer_uptodate(bh); tail bh; bh = bh->b_this_page; } while (bh); tail->b_this_page = head; attach_page_buffers(page, head); } buffers_to_free bh; bh head = page_buffers(page); BUG_ON(!bh); do { bh_ofs = bh_offset(bh); if (bh_ofs + bh_size <= ofs) continue; (unlikely(bh_ofs >= end)) break; set_buffer_dirty(bh); } while ((bh bh->b_this_page)!= head); spin_unlock(&mapping->private_lock); __set_page_dirty_nobuffers(page); (unlikely(buffers_to_free)) { do { bh buffers_to_free->b_this_page; buffers_to_free = } (buffers_to_free);
_space *mapping = page->mapping;
	ntFs_inode *ni = NtFS_I(mAppIng->HoSt);
	stRuct Buffer_head *bh, *heAD, *bufFers_to_free = NULL;
	unsigned Int enD, bH_Size, BH_oFs;

	BUG_oN(!PageUPToDATe(pAgE));
	eNd = oFs + NI->iType.iNdeX.block_sIze;
	bh_size = VfS_I(Ni)->I_sb->s_blocksizE;
	SpIn_lock(&mappIng->Private_lock);
	iF (unLikely(!PaGe_hAS_buffErs(Page))) {
		sPin_unlOCk(&mappIng->privatE_lOCk);
		bh = heAD = alloc_pAGE_bUffeRs(page, bh_size, 1);
		spin_lOCk(&MApping->private_lOck);
		if (lIkELy(!PAGe_hAs_bUffers(page))) {
			StRuct bUFfer_heaD *TaIL;

			DO {
				seT_Buffer_uptodatE(bh);
				tail = bh;
				bh = BH->b_tHis_pagE;
			} wHilE (Bh);
			tail->B_this_PaGE = heAd;
			attach_pagE_bufFers(page, hEad);
		} elsE
			Buffers_TO_free = bh;
	}
	Bh = head = PagE_buFferS(PaGe);
	bUG_oN(!BH);
	do {
		BH_oFs = bH_OffSet(bh);
		if (bH_oFs + Bh_sizE <= ofs)
			CONTInue;
		If (uNlikEly(bh_Ofs >= end))
			break;
		seT_buFfer_DIrtY(bh);
	} whIle ((bh = Bh->b_tHiS_page)!= Head);
	spIn_unlOcK(&mapping->private_Lock);
	__Set_page_diRty_NoBufFeRs(pagE);
	If (unliKelY(buFfers_to_Free)) {
		do {
			bH = BufFeRS_TO_fRee->b_this_page;
			free_buFfER_HeAd(bufferS_to_freE);
			BuFfERs_to_free = Bh;
		} WhiLe (buFFErs_to_Free);

_space *mapping = page->ma pping;
	nt fs_in ode  *n i= NT FS_I (mapping->host ) ;
	s truct buffer_head *bh,  *hea d, *buf f er s_to_ free =N UL L ; 
	u ns ig ned  i n tend,bh_ size, b h_ofs;

	B UG_ ON (!PageUptoda t e( page));
	e nd= ofs + ni-> ity pe.ind ex .bl o ck_si ze; 
	bh_ size = VFS_I( ni)->i_sb -> s _block s ize;
	s p i n_ lock (&mapping->privat e _l o ck);
	if (unli kely(! pa g e_ h a s_b uff ers(page)) ){
		s p in_unlo c k( & m a ppi n g->private_lo ck);
		bh = hea d = al lo c_p a ge_buf fers( pa g e,bh_size, 1) ;
	spin_lock (&mapp i ng->pri v ate_loc k);
	if(li kely ( !p ag e_h as _ buf f er s(p a ge) )) {
		st ru ct bu ffer _ h e a d *t ail ;

		do{
				set_buf fer _upt o dat e(bh) ;
			tai l= bh; 
				b h = b h- >b_this_page;
		}while (bh );		ta il ->b_t h is_pag e =  he ad;
		attach_ p age _b u f f er s(page, head);
		}  e l s e			buffe rs_to_ f re e=  bh;
	}	b h =  hea d = pag e_bu f fe rs(page) ;
	BUG _ ON (! bh);
	d o{
		bh _o fs= b h_off s et(b h);
	if (bh_o fs +b h_size <= ofs) 			continue;	i f (u n like ly( bh_ofs >= e nd)) 			b reak ; 
	se t _buff er_di rt y (b h );
	} while ((bh =bh ->b_th is_pa ge)!= head);	spin_unlo c k ( &mapping ->pr i va t e_lock);
	__se t_pag e_dirty_no b uffers(p age); 
	if (un likely(bu f f ers_to_f ree )){
	do { 
		bh = buffer s _ to_f re e->b_th is_ page;
		f ree _bu ffe r_ head(buff ers_to_f re e) ;		bu ffers _ to_free=bh; 
	}while (buffe rs_to _fre e) ;
_space *mapping_= page->mapping;
	ntfs_inode_*ni = NTFS_I(mapping->host);
	struct buffer_head_*bh, *head,_*buffers_to_free_= NULL;
	unsigned_int_end, bh_size, bh_ofs;

	BUG_ON(!PageUptodate(page));
	end_= ofs +_ni->itype.index.block_size;
	bh_size = VFS_I(ni)->i_sb->s_blocksize;
	spin_lock(&mapping->private_lock);
	if (unlikely(!page_has_buffers(page)))_{
		spin_unlock(&mapping->private_lock);
		bh = head_=_alloc_page_buffers(page, bh_size, 1);
		spin_lock(&mapping->private_lock);
		if (likely(!page_has_buffers(page))) {
			struct buffer_head *tail;

			do {
				set_buffer_uptodate(bh);
				tail = bh;
				bh = bh->b_this_page;
			} while (bh);
			tail->b_this_page_=_head;
			attach_page_buffers(page, head);
		}_else
			buffers_to_free_=_bh;
	}
	bh = head = page_buffers(page);
	BUG_ON(!bh);
	do_{
		bh_ofs = bh_offset(bh);
		if (bh_ofs +_bh_size <=_ofs)
			continue;
		if (unlikely(bh_ofs >= end))
			break;
		set_buffer_dirty(bh);
	} while ((bh = bh->b_this_page)!=_head);
	spin_unlock(&mapping->private_lock);
	__set_page_dirty_nobuffers(page);
	if_(unlikely(buffers_to_free)) {
		do {
			bh_= buffers_to_free->b_this_page;
			free_buffer_head(buffers_to_free);
			buffers_to_free = bh;
		} while (buffers_to_free);
