Attachment #27370 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;




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

#if CORE_DUMP

		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 713-718 out: Link Here

(-)xx/include/linux/mm.h.~1~ (+1 lines)
713	extern int do_munmap(struct mm_struct *, unsigned long, size_t);	713	extern int do_munmap(struct mm_struct *, unsigned long, size_t);
714		714
715	extern unsigned long do_brk(unsigned long, unsigned long);	715	extern unsigned long do_brk(unsigned long, unsigned long);
		716	extern unsigned long do_brk_unlocked(unsigned long, unsigned long);
716		717
717	/* filemap.c */	718	/* filemap.c */
718	extern unsigned long page_unuse(struct page *);	719	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

(-)xx/arch/mips/kernel/irixelf.c.~1~ (-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 375-381 static unsigned int load_irix_interp(str Link Here
375		375
376	/* Map the last of the bss segment */	376	/* Map the last of the bss segment */
377	if (last_bss > len) {	377	if (last_bss > len) {
378	do_brk(len, (last_bss - len));	378	do_brk_unlocked(len, (last_bss - len));
379	}	379	}
380	kfree(elf_phdata);	380	kfree(elf_phdata);
381		381
Lines 562-568 void irix_map_prda_page (void) Link Here
562	unsigned long v;	562	unsigned long v;
563	struct prda *pp;	563	struct prda *pp;
564		564
565	v = do_brk (PRDA_ADDRESS, PAGE_SIZE);	565	v = do_brk_unlocked (PRDA_ADDRESS, PAGE_SIZE);
566		566
567	if (v < 0)	567	if (v < 0)
568	return;	568	return;
Lines 853-859 static int load_irix_library(struct file Link Here
853	len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;	853	len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
854	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;	854	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
855	if (bss > len)	855	if (bss > len)
856	do_brk(len, bss-len);	856	do_brk_unlocked(len, bss-len);
857	kfree(elf_phdata);	857	kfree(elf_phdata);
858	return 0;	858	return 0;
859	}	859	}

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

(-)xx/arch/sparc64/kernel/binfmt_aout32.c.~1~ (-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 void set_brk(unsigned long start, Link Here

(-)xx/arch/x86_64/ia32/ia32_aout.c.~1~ (-5 / +5 lines)
114	end = PAGE_ALIGN(end);	114	end = PAGE_ALIGN(end);
115	if (end <= start)	115	if (end <= start)
116	return;	116	return;
117	do_brk(start, end - start);	117	do_brk_unlocked(start, end - start);
118	}	118	}
119		119
120	#if CORE_DUMP	120	#if CORE_DUMP
Lines 324-330 static int load_aout_binary(struct linux Link Here
324	pos = 32;	324	pos = 32;
325	map_size = ex.a_text+ex.a_data;	325	map_size = ex.a_text+ex.a_data;
326		326
327	error = do_brk(text_addr & PAGE_MASK, map_size);	327	error = do_brk_unlocked(text_addr & PAGE_MASK, map_size);
328	if (error != (text_addr & PAGE_MASK)) {	328	if (error != (text_addr & PAGE_MASK)) {
329	send_sig(SIGKILL, current, 0);	329	send_sig(SIGKILL, current, 0);
330	return error;	330	return error;
Lines 360-366 static int load_aout_binary(struct linux Link Here
360		360
361	if (!bprm->file->f_op->mmap\|\|((fd_offset & ~PAGE_MASK) != 0)) {	361	if (!bprm->file->f_op->mmap\|\|((fd_offset & ~PAGE_MASK) != 0)) {
362	loff_t pos = fd_offset;	362	loff_t pos = fd_offset;
363	do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);	363	do_brk_unlocked(N_TXTADDR(ex), ex.a_text+ex.a_data);
364	bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),	364	bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),
365	ex.a_text+ex.a_data, &pos);	365	ex.a_text+ex.a_data, &pos);
366	flush_icache_range((unsigned long) N_TXTADDR(ex),	366	flush_icache_range((unsigned long) N_TXTADDR(ex),
Lines 469-475 static int load_aout_library(struct file Link Here
469	}	469	}
470	#endif	470	#endif
471		471
472	do_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);	472	do_brk_unlocked(start_addr, ex.a_text + ex.a_data + ex.a_bss);
473		473
474	file->f_op->read(file, (char *)start_addr,	474	file->f_op->read(file, (char *)start_addr,
475	ex.a_text + ex.a_data, &pos);	475	ex.a_text + ex.a_data, &pos);
Lines 493-499 static int load_aout_library(struct file Link Here
493	len = PAGE_ALIGN(ex.a_text + ex.a_data);	493	len = PAGE_ALIGN(ex.a_text + ex.a_data);
494	bss = ex.a_text + ex.a_data + ex.a_bss;	494	bss = ex.a_text + ex.a_data + ex.a_bss;
495	if (bss > len) {	495	if (bss > len) {
496	error = do_brk(start_addr + len, bss - len);	496	error = do_brk_unlocked(start_addr + len, bss - len);
497	retval = error;	497	retval = error;
498	if (error != start_addr + len)	498	if (error != start_addr + len)
499	goto out;	499	goto out;

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

(-)xx/fs/binfmt_aout.c.~1~ (-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

(-)xx/fs/binfmt_elf.c.~1~ (-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 1025-1031 static int load_elf_library(struct file Link Here
1025	len = ELF_PAGESTART(elf_phdata->p_filesz + elf_phdata->p_vaddr + ELF_MIN_ALIGN - 1);	1025	len = ELF_PAGESTART(elf_phdata->p_filesz + elf_phdata->p_vaddr + ELF_MIN_ALIGN - 1);
1026	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;	1026	bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
1027	if (bss > len)	1027	if (bss > len)
1028	do_brk(len, bss - len);	1028	do_brk_unlocked(len, bss - len);
1029	error = 0;	1029	error = 0;
1030		1030
1031	out_free_ph:	1031	out_free_ph:

Lines 1826-1831 out: Link Here

(-)xx/mm/mmap.c.~1~ (+13 lines)
1826		1826
1827	EXPORT_SYMBOL(do_brk);	1827	EXPORT_SYMBOL(do_brk);
1828		1828
		1829	unsigned long do_brk_unlocked(unsigned long addr, unsigned long len)
		1830	{
		1831	unsigned long ret;
		1832
		1833	down_write(&current->mm->mmap_sem);
		1834	ret = do_brk(addr, len);
		1835	up_write(&current->mm->mmap_sem);
		1836
		1837	return ret;
		1838	}
		1839
		1840	EXPORT_SYMBOL(do_brk_unlocked);
		1841
1829	/* Release all mmaps. */	1842	/* Release all mmaps. */
1830	void exit_mmap(struct mm_struct *mm)	1843	void exit_mmap(struct mm_struct *mm)
1831	{	1844	{