Attachment #27371 for bug #64492

View | Details | Raw Unified | Return to bug 64492
Collapse All | Expand All




	end = PAGE_ALIGN(end);
	if (end <= start)
		return;
	do_brk_unlocked(start, end - start);
}




	/* Map the last of the bss segment */
	if (last_bss > len) {
		do_brk_unlocked(len, (last_bss - len));
	}
	kfree(elf_phdata);


	unsigned long v;
	struct prda *pp;

	v =  do_brk_unlocked (PRDA_ADDRESS, PAGE_SIZE);

	if (v < 0)
		return;

	len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
	if (bss > len)
	  do_brk_unlocked(len, bss-len);
	kfree(elf_phdata);
	return 0;
}




	end = PAGE_ALIGN(end);
	if (end <= start)
		return;
	do_brk_unlocked(start, end - start);
}

/*

	if (N_MAGIC(ex) == NMAGIC) {
		loff_t pos = fd_offset;
		/* Fuck me plenty... */
		error = do_brk_unlocked(N_TXTADDR(ex), ex.a_text);
		bprm->file->f_op->read(bprm->file, (char __user *)N_TXTADDR(ex),
			  ex.a_text, &pos);
		error = do_brk_unlocked(N_DATADDR(ex), ex.a_data);
		bprm->file->f_op->read(bprm->file, (char __user *)N_DATADDR(ex),
			  ex.a_data, &pos);
		goto beyond_if;


	if (N_MAGIC(ex) == OMAGIC) {
		loff_t pos = fd_offset;
		do_brk_unlocked(N_TXTADDR(ex) & PAGE_MASK,
			ex.a_text+ex.a_data + PAGE_SIZE - 1);
		bprm->file->f_op->read(bprm->file, (char __user *)N_TXTADDR(ex),
			  ex.a_text+ex.a_data, &pos);


		if (!bprm->file->f_op->mmap) {
			loff_t pos = fd_offset;
			do_brk_unlocked(0, ex.a_text+ex.a_data);
			bprm->file->f_op->read(bprm->file,
				  (char __user *)N_TXTADDR(ex),
				  ex.a_text+ex.a_data, &pos);

	len = PAGE_ALIGN(ex.a_text + ex.a_data);
	bss = ex.a_text + ex.a_data + ex.a_bss;
	if (bss > len) {
		error = do_brk_unlocked(start_addr + len, bss - len);
		retval = error;
		if (error != start_addr + len)
			goto out;




	start = PAGE_ALIGN(start);
	end = PAGE_ALIGN(end);
	if (end > start) {
		unsigned long addr = do_brk_unlocked(start, end - start);
		if (BAD_ADDR(addr))
			return addr;
	}

		pos = 32;
		map_size = ex.a_text+ex.a_data;

		error = do_brk_unlocked(text_addr & PAGE_MASK, map_size);
		if (error != (text_addr & PAGE_MASK)) {
			send_sig(SIGKILL, current, 0);
			return error;


		if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {
			loff_t pos = fd_offset;
			do_brk_unlocked(N_TXTADDR(ex), ex.a_text+ex.a_data);
			bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),
					ex.a_text+ex.a_data, &pos);
			flush_icache_range((unsigned long) N_TXTADDR(ex),

		}
#endif

		do_brk_unlocked(start_addr, ex.a_text + ex.a_data + ex.a_bss);
		
		file->f_op->read(file, (char *)start_addr,
			ex.a_text + ex.a_data, &pos);

	len = PAGE_ALIGN(ex.a_text + ex.a_data);
	bss = ex.a_text + ex.a_data + ex.a_bss;
	if (bss > len) {
		error = do_brk_unlocked(start_addr + len, bss - len);
		retval = error;
		if (error != start_addr + len)
			goto out;




	start = PAGE_ALIGN(start);
	end = PAGE_ALIGN(end);
	if (end > start) {
		unsigned long addr = do_brk_unlocked(start, end - start);
		if (BAD_ADDR(addr))
			return addr;
	}

		loff_t pos = fd_offset;
		/* Fuck me plenty... */
		/* <AOL></AOL> */
		error = do_brk_unlocked(N_TXTADDR(ex), ex.a_text);
		bprm->file->f_op->read(bprm->file, (char *) N_TXTADDR(ex),
			  ex.a_text, &pos);
		error = do_brk_unlocked(N_DATADDR(ex), ex.a_data);
		bprm->file->f_op->read(bprm->file, (char *) N_DATADDR(ex),
			  ex.a_data, &pos);
		goto beyond_if;

		map_size = ex.a_text+ex.a_data;
#endif

		error = do_brk_unlocked(text_addr & PAGE_MASK, map_size);
		if (error != (text_addr & PAGE_MASK)) {
			send_sig(SIGKILL, current, 0);
			return error;


		if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {
			loff_t pos = fd_offset;
			do_brk_unlocked(N_TXTADDR(ex), ex.a_text+ex.a_data);
			bprm->file->f_op->read(bprm->file,
					(char __user *)N_TXTADDR(ex),
					ex.a_text+ex.a_data, &pos);

			error_time = jiffies;
		}

		do_brk_unlocked(start_addr, ex.a_text + ex.a_data + ex.a_bss);
		
		file->f_op->read(file, (char __user *)start_addr,
			ex.a_text + ex.a_data, &pos);

	len = PAGE_ALIGN(ex.a_text + ex.a_data);
	bss = ex.a_text + ex.a_data + ex.a_bss;
	if (bss > len) {
		error = do_brk_unlocked(start_addr + len, bss - len);
		retval = error;
		if (error != start_addr + len)
			goto out;




	start = ELF_PAGEALIGN(start);
	end = ELF_PAGEALIGN(end);
	if (end > start) {
		unsigned long addr = do_brk_unlocked(start, end - start);
		if (BAD_ADDR(addr))
			return addr;
	}


	/* Map the last of the bss segment */
	if (last_bss > elf_bss) {
		error = do_brk_unlocked(elf_bss, last_bss - elf_bss);
		if (BAD_ADDR(error))
			goto out_close;
	}

		goto out;
	}

	do_brk_unlocked(0, text_data);
	if (!interpreter->f_op || !interpreter->f_op->read)
		goto out;
	if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)

	flush_icache_range((unsigned long)addr,
	                   (unsigned long)addr + text_data);

	do_brk_unlocked(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
		interp_ex->a_bss);
	elf_entry = interp_ex->a_entry;


	len = ELF_PAGESTART(elf_phdata->p_filesz + elf_phdata->p_vaddr + ELF_MIN_ALIGN - 1);
	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
	if (bss > len)
		do_brk_unlocked(len, bss - len);
	error = 0;

out_free_ph:

Lines 712-717 out: Link Here

(-)x/include/linux/mm.h.orig (+1 lines)
712	extern int do_munmap(struct mm_struct *, unsigned long, size_t);	712	extern int do_munmap(struct mm_struct *, unsigned long, size_t);
713		713
714	extern unsigned long do_brk(unsigned long, unsigned long);	714	extern unsigned long do_brk(unsigned long, unsigned long);
		715	extern unsigned long do_brk_unlocked(unsigned long, unsigned long);
715		716
716	/* filemap.c */	717	/* filemap.c */
717	extern unsigned long page_unuse(struct page *);	718	extern unsigned long page_unuse(struct page *);





EXPORT_SYMBOL(do_brk);

unsigned long do_brk_unlocked(unsigned long addr, unsigned long len)
{
	unsigned long ret;

	down_write(&current->mm->mmap_sem);
	ret = do_brk(addr, len);
	up_write(&current->mm->mmap_sem);

	return ret;
}

EXPORT_SYMBOL(do_brk_unlocked);

/* Release all mmaps. */
void exit_mmap(struct mm_struct *mm)
{

Return to bug 64492

Lines 127-133 static void set_brk(unsigned long start, Link Here

(-)x/arch/mips/kernel/irixelf.c.orig (-4 / +4 lines)
127	end = PAGE_ALIGN(end);	127	end = PAGE_ALIGN(end);
128	if (end <= start)	128	if (end <= start)
129	return;	129	return;
130	do_brk(start, end - start);	130	do_brk_unlocked(start, end - start);
131	}	131	}
132		132
133		133
Lines 376-382 static unsigned int load_irix_interp(str Link Here
376		376
377	/* Map the last of the bss segment */	377	/* Map the last of the bss segment */
378	if (last_bss > len) {	378	if (last_bss > len) {
379	do_brk(len, (last_bss - len));	379	do_brk_unlocked(len, (last_bss - len));
380	}	380	}
381	kfree(elf_phdata);	381	kfree(elf_phdata);
382		382
Lines 564-570 void irix_map_prda_page (void) Link Here
564	unsigned long v;	564	unsigned long v;
565	struct prda *pp;	565	struct prda *pp;
566		566
567	v = do_brk (PRDA_ADDRESS, PAGE_SIZE);	567	v = do_brk_unlocked (PRDA_ADDRESS, PAGE_SIZE);
568		568
569	if (v < 0)	569	if (v < 0)
570	return;	570	return;
Lines 856-862 static int load_irix_library(struct file Link Here
856	len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;	856	len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
857	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;	857	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
858	if (bss > len)	858	if (bss > len)
859	do_brk(len, bss-len);	859	do_brk_unlocked(len, bss-len);
860	kfree(elf_phdata);	860	kfree(elf_phdata);
861	return 0;	861	return 0;
862	}	862	}

Lines 49-55 static void set_brk(unsigned long start, Link Here

(-)x/arch/sparc64/kernel/binfmt_aout32.c.orig (-6 / +6 lines)
49	end = PAGE_ALIGN(end);	49	end = PAGE_ALIGN(end);
50	if (end <= start)	50	if (end <= start)
51	return;	51	return;
52	do_brk(start, end - start);	52	do_brk_unlocked(start, end - start);
53	}	53	}
54		54
55	/*	55	/*
Lines 246-255 static int load_aout32_binary(struct lin Link Here
246	if (N_MAGIC(ex) == NMAGIC) {	246	if (N_MAGIC(ex) == NMAGIC) {
247	loff_t pos = fd_offset;	247	loff_t pos = fd_offset;
248	/* Fuck me plenty... */	248	/* Fuck me plenty... */
249	error = do_brk(N_TXTADDR(ex), ex.a_text);	249	error = do_brk_unlocked(N_TXTADDR(ex), ex.a_text);
250	bprm->file->f_op->read(bprm->file, (char __user *)N_TXTADDR(ex),	250	bprm->file->f_op->read(bprm->file, (char __user *)N_TXTADDR(ex),
251	ex.a_text, &pos);	251	ex.a_text, &pos);
252	error = do_brk(N_DATADDR(ex), ex.a_data);	252	error = do_brk_unlocked(N_DATADDR(ex), ex.a_data);
253	bprm->file->f_op->read(bprm->file, (char __user *)N_DATADDR(ex),	253	bprm->file->f_op->read(bprm->file, (char __user *)N_DATADDR(ex),
254	ex.a_data, &pos);	254	ex.a_data, &pos);
255	goto beyond_if;	255	goto beyond_if;
Lines 257-263 static int load_aout32_binary(struct lin Link Here
257		257
258	if (N_MAGIC(ex) == OMAGIC) {	258	if (N_MAGIC(ex) == OMAGIC) {
259	loff_t pos = fd_offset;	259	loff_t pos = fd_offset;
260	do_brk(N_TXTADDR(ex) & PAGE_MASK,	260	do_brk_unlocked(N_TXTADDR(ex) & PAGE_MASK,
261	ex.a_text+ex.a_data + PAGE_SIZE - 1);	261	ex.a_text+ex.a_data + PAGE_SIZE - 1);
262	bprm->file->f_op->read(bprm->file, (char __user *)N_TXTADDR(ex),	262	bprm->file->f_op->read(bprm->file, (char __user *)N_TXTADDR(ex),
263	ex.a_text+ex.a_data, &pos);	263	ex.a_text+ex.a_data, &pos);
Lines 272-278 static int load_aout32_binary(struct lin Link Here
272		272
273	if (!bprm->file->f_op->mmap) {	273	if (!bprm->file->f_op->mmap) {
274	loff_t pos = fd_offset;	274	loff_t pos = fd_offset;
275	do_brk(0, ex.a_text+ex.a_data);	275	do_brk_unlocked(0, ex.a_text+ex.a_data);
276	bprm->file->f_op->read(bprm->file,	276	bprm->file->f_op->read(bprm->file,
277	(char __user *)N_TXTADDR(ex),	277	(char __user *)N_TXTADDR(ex),
278	ex.a_text+ex.a_data, &pos);	278	ex.a_text+ex.a_data, &pos);
Lines 389-395 static int load_aout32_library(struct fi Link Here
389	len = PAGE_ALIGN(ex.a_text + ex.a_data);	389	len = PAGE_ALIGN(ex.a_text + ex.a_data);
390	bss = ex.a_text + ex.a_data + ex.a_bss;	390	bss = ex.a_text + ex.a_data + ex.a_bss;
391	if (bss > len) {	391	if (bss > len) {
392	error = do_brk(start_addr + len, bss - len);	392	error = do_brk_unlocked(start_addr + len, bss - len);
393	retval = error;	393	retval = error;
394	if (error != start_addr + len)	394	if (error != start_addr + len)
395	goto out;	395	goto out;

Lines 114-120 static int set_brk(unsigned long start, Link Here

(-)x/arch/x86_64/ia32/ia32_aout.c.orig (-5 / +5 lines)
114	start = PAGE_ALIGN(start);	114	start = PAGE_ALIGN(start);
115	end = PAGE_ALIGN(end);	115	end = PAGE_ALIGN(end);
116	if (end > start) {	116	if (end > start) {
117	unsigned long addr = do_brk(start, end - start);	117	unsigned long addr = do_brk_unlocked(start, end - start);
118	if (BAD_ADDR(addr))	118	if (BAD_ADDR(addr))
119	return addr;	119	return addr;
120	}	120	}
Lines 328-334 static int load_aout_binary(struct linux Link Here
328	pos = 32;	328	pos = 32;
329	map_size = ex.a_text+ex.a_data;	329	map_size = ex.a_text+ex.a_data;
330		330
331	error = do_brk(text_addr & PAGE_MASK, map_size);	331	error = do_brk_unlocked(text_addr & PAGE_MASK, map_size);
332	if (error != (text_addr & PAGE_MASK)) {	332	if (error != (text_addr & PAGE_MASK)) {
333	send_sig(SIGKILL, current, 0);	333	send_sig(SIGKILL, current, 0);
334	return error;	334	return error;
Lines 364-370 static int load_aout_binary(struct linux Link Here
364		364
365	if (!bprm->file->f_op->mmap\|\|((fd_offset & ~PAGE_MASK) != 0)) {	365	if (!bprm->file->f_op->mmap\|\|((fd_offset & ~PAGE_MASK) != 0)) {
366	loff_t pos = fd_offset;	366	loff_t pos = fd_offset;
367	do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);	367	do_brk_unlocked(N_TXTADDR(ex), ex.a_text+ex.a_data);
368	bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),	368	bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),
369	ex.a_text+ex.a_data, &pos);	369	ex.a_text+ex.a_data, &pos);
370	flush_icache_range((unsigned long) N_TXTADDR(ex),	370	flush_icache_range((unsigned long) N_TXTADDR(ex),
Lines 477-483 static int load_aout_library(struct file Link Here
477	}	477	}
478	#endif	478	#endif
479		479
480	do_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);	480	do_brk_unlocked(start_addr, ex.a_text + ex.a_data + ex.a_bss);
481		481
482	file->f_op->read(file, (char *)start_addr,	482	file->f_op->read(file, (char *)start_addr,
483	ex.a_text + ex.a_data, &pos);	483	ex.a_text + ex.a_data, &pos);
Lines 501-507 static int load_aout_library(struct file Link Here
501	len = PAGE_ALIGN(ex.a_text + ex.a_data);	501	len = PAGE_ALIGN(ex.a_text + ex.a_data);
502	bss = ex.a_text + ex.a_data + ex.a_bss;	502	bss = ex.a_text + ex.a_data + ex.a_bss;
503	if (bss > len) {	503	if (bss > len) {
504	error = do_brk(start_addr + len, bss - len);	504	error = do_brk_unlocked(start_addr + len, bss - len);
505	retval = error;	505	retval = error;
506	if (error != start_addr + len)	506	if (error != start_addr + len)
507	goto out;	507	goto out;

Lines 50-56 static int set_brk(unsigned long start, Link Here

(-)x/fs/binfmt_aout.c.orig (-7 / +7 lines)
50	start = PAGE_ALIGN(start);	50	start = PAGE_ALIGN(start);
51	end = PAGE_ALIGN(end);	51	end = PAGE_ALIGN(end);
52	if (end > start) {	52	if (end > start) {
53	unsigned long addr = do_brk(start, end - start);	53	unsigned long addr = do_brk_unlocked(start, end - start);
54	if (BAD_ADDR(addr))	54	if (BAD_ADDR(addr))
55	return addr;	55	return addr;
56	}	56	}
Lines 323-332 static int load_aout_binary(struct linux Link Here
323	loff_t pos = fd_offset;	323	loff_t pos = fd_offset;
324	/* Fuck me plenty... */	324	/* Fuck me plenty... */
325	/* <AOL></AOL> */	325	/* <AOL></AOL> */
326	error = do_brk(N_TXTADDR(ex), ex.a_text);	326	error = do_brk_unlocked(N_TXTADDR(ex), ex.a_text);
327	bprm->file->f_op->read(bprm->file, (char *) N_TXTADDR(ex),	327	bprm->file->f_op->read(bprm->file, (char *) N_TXTADDR(ex),
328	ex.a_text, &pos);	328	ex.a_text, &pos);
329	error = do_brk(N_DATADDR(ex), ex.a_data);	329	error = do_brk_unlocked(N_DATADDR(ex), ex.a_data);
330	bprm->file->f_op->read(bprm->file, (char *) N_DATADDR(ex),	330	bprm->file->f_op->read(bprm->file, (char *) N_DATADDR(ex),
331	ex.a_data, &pos);	331	ex.a_data, &pos);
332	goto beyond_if;	332	goto beyond_if;
Lines 347-353 static int load_aout_binary(struct linux Link Here
347	map_size = ex.a_text+ex.a_data;	347	map_size = ex.a_text+ex.a_data;
348	#endif	348	#endif
349		349
350	error = do_brk(text_addr & PAGE_MASK, map_size);	350	error = do_brk_unlocked(text_addr & PAGE_MASK, map_size);
351	if (error != (text_addr & PAGE_MASK)) {	351	if (error != (text_addr & PAGE_MASK)) {
352	send_sig(SIGKILL, current, 0);	352	send_sig(SIGKILL, current, 0);
353	return error;	353	return error;
Lines 382-388 static int load_aout_binary(struct linux Link Here
382		382
383	if (!bprm->file->f_op->mmap\|\|((fd_offset & ~PAGE_MASK) != 0)) {	383	if (!bprm->file->f_op->mmap\|\|((fd_offset & ~PAGE_MASK) != 0)) {
384	loff_t pos = fd_offset;	384	loff_t pos = fd_offset;
385	do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);	385	do_brk_unlocked(N_TXTADDR(ex), ex.a_text+ex.a_data);
386	bprm->file->f_op->read(bprm->file,	386	bprm->file->f_op->read(bprm->file,
387	(char __user *)N_TXTADDR(ex),	387	(char __user *)N_TXTADDR(ex),
388	ex.a_text+ex.a_data, &pos);	388	ex.a_text+ex.a_data, &pos);
Lines 488-494 static int load_aout_library(struct file Link Here
488	error_time = jiffies;	488	error_time = jiffies;
489	}	489	}
490		490
491	do_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);	491	do_brk_unlocked(start_addr, ex.a_text + ex.a_data + ex.a_bss);
492		492
493	file->f_op->read(file, (char __user *)start_addr,	493	file->f_op->read(file, (char __user *)start_addr,
494	ex.a_text + ex.a_data, &pos);	494	ex.a_text + ex.a_data, &pos);
Lines 512-518 static int load_aout_library(struct file Link Here
512	len = PAGE_ALIGN(ex.a_text + ex.a_data);	512	len = PAGE_ALIGN(ex.a_text + ex.a_data);
513	bss = ex.a_text + ex.a_data + ex.a_bss;	513	bss = ex.a_text + ex.a_data + ex.a_bss;
514	if (bss > len) {	514	if (bss > len) {
515	error = do_brk(start_addr + len, bss - len);	515	error = do_brk_unlocked(start_addr + len, bss - len);
516	retval = error;	516	retval = error;
517	if (error != start_addr + len)	517	if (error != start_addr + len)
518	goto out;	518	goto out;

Lines 88-94 static int set_brk(unsigned long start, Link Here

(-)x/fs/binfmt_elf.c.orig (-5 / +5 lines)
88	start = ELF_PAGEALIGN(start);	88	start = ELF_PAGEALIGN(start);
89	end = ELF_PAGEALIGN(end);	89	end = ELF_PAGEALIGN(end);
90	if (end > start) {	90	if (end > start) {
91	unsigned long addr = do_brk(start, end - start);	91	unsigned long addr = do_brk_unlocked(start, end - start);
92	if (BAD_ADDR(addr))	92	if (BAD_ADDR(addr))
93	return addr;	93	return addr;
94	}	94	}
Lines 408-414 static unsigned long load_elf_interp(str Link Here
408		408
409	/* Map the last of the bss segment */	409	/* Map the last of the bss segment */
410	if (last_bss > elf_bss) {	410	if (last_bss > elf_bss) {
411	error = do_brk(elf_bss, last_bss - elf_bss);	411	error = do_brk_unlocked(elf_bss, last_bss - elf_bss);
412	if (BAD_ADDR(error))	412	if (BAD_ADDR(error))
413	goto out_close;	413	goto out_close;
414	}	414	}
Lines 448-454 static unsigned long load_aout_interp(st Link Here
448	goto out;	448	goto out;
449	}	449	}
450		450
451	do_brk(0, text_data);	451	do_brk_unlocked(0, text_data);
452	if (!interpreter->f_op \|\| !interpreter->f_op->read)	452	if (!interpreter->f_op \|\| !interpreter->f_op->read)
453	goto out;	453	goto out;
454	if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)	454	if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)
Lines 456-462 static unsigned long load_aout_interp(st Link Here
456	flush_icache_range((unsigned long)addr,	456	flush_icache_range((unsigned long)addr,
457	(unsigned long)addr + text_data);	457	(unsigned long)addr + text_data);
458		458
459	do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),	459	do_brk_unlocked(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
460	interp_ex->a_bss);	460	interp_ex->a_bss);
461	elf_entry = interp_ex->a_entry;	461	elf_entry = interp_ex->a_entry;
462		462
Lines 1015-1021 static int load_elf_library(struct file Link Here
1015	len = ELF_PAGESTART(elf_phdata->p_filesz + elf_phdata->p_vaddr + ELF_MIN_ALIGN - 1);	1015	len = ELF_PAGESTART(elf_phdata->p_filesz + elf_phdata->p_vaddr + ELF_MIN_ALIGN - 1);
1016	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;	1016	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
1017	if (bss > len)	1017	if (bss > len)
1018	do_brk(len, bss - len);	1018	do_brk_unlocked(len, bss - len);
1019	error = 0;	1019	error = 0;
1020		1020
1021	out_free_ph:	1021	out_free_ph:

Lines 1838-1843 out: Link Here

(-)x/mm/mmap.c.orig (+13 lines)
1838		1838
1839	EXPORT_SYMBOL(do_brk);	1839	EXPORT_SYMBOL(do_brk);
1840		1840
		1841	unsigned long do_brk_unlocked(unsigned long addr, unsigned long len)
		1842	{
		1843	unsigned long ret;
		1844
		1845	down_write(&current->mm->mmap_sem);
		1846	ret = do_brk(addr, len);
		1847	up_write(&current->mm->mmap_sem);
		1848
		1849	return ret;
		1850	}
		1851
		1852	EXPORT_SYMBOL(do_brk_unlocked);
		1853
1841	/* Release all mmaps. */	1854	/* Release all mmaps. */
1842	void exit_mmap(struct mm_struct *mm)	1855	void exit_mmap(struct mm_struct *mm)
1843	{	1856	{