[ipfire-2.x.git] / src / patches / glibc / glibc-rh788959-2.patch

diff -rcp a/nscd/grpcache.c b/nscd/grpcache.c
*** a/nscd/grpcache.c	Wed Apr 11 12:50:07 2012
--- b/nscd/grpcache.c	Wed Apr 11 21:45:58 2012
*************** cache_addgr (struct database_dyn *db, in
*** 178,184 ****
        char *cp;
        const size_t key_len = strlen (key);
        const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
!       char *buf = alloca (buf_len);
        ssize_t n;
        size_t cnt;
  
--- 178,185 ----
        char *cp;
        const size_t key_len = strlen (key);
        const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
!       size_t alloca_used = 0;
!       char *buf = alloca_account (buf_len, alloca_used);
        ssize_t n;
        size_t cnt;
  
*************** cache_addgr (struct database_dyn *db, in
*** 190,196 ****
        /* Determine the length of all members.  */
        while (grp->gr_mem[gr_mem_cnt])
  	++gr_mem_cnt;
!       gr_mem_len = (uint32_t *) alloca (gr_mem_cnt * sizeof (uint32_t));
        for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
  	{
  	  gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
--- 191,198 ----
        /* Determine the length of all members.  */
        while (grp->gr_mem[gr_mem_cnt])
  	++gr_mem_cnt;
!       gr_mem_len = (uint32_t *) alloca_account (gr_mem_cnt * sizeof (uint32_t),
! 						alloca_used);
        for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
  	{
  	  gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
*************** cache_addgr (struct database_dyn *db, in
*** 205,214 ****
  	 change.  Allocate memory on the cache since it is likely
  	 discarded anyway.  If it turns out to be necessary to have a
  	 new record we can still allocate real memory.  */
!       bool alloca_used = false;
        dataset = NULL;
  
!       if (he == NULL)
  	dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
  
        if (dataset == NULL)
--- 207,216 ----
  	 change.  Allocate memory on the cache since it is likely
  	 discarded anyway.  If it turns out to be necessary to have a
  	 new record we can still allocate real memory.  */
!       bool dataset_in_stack_or_freed = false;
        dataset = NULL;
  
!       if (he == NULL || ! __libc_use_alloca (alloca_used + total + n))
  	dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
  
        if (dataset == NULL)
*************** cache_addgr (struct database_dyn *db, in
*** 216,225 ****
  	  /* We cannot permanently add the result in the moment.  But
  	     we can provide the result as is.  Store the data in some
  	     temporary memory.  */
! 	  dataset = (struct dataset *) alloca (total + n);
  
  	  /* We cannot add this record to the permanent database.  */
! 	  alloca_used = true;
  	}
  
        dataset->head.allocsize = total + n;
--- 218,227 ----
  	  /* We cannot permanently add the result in the moment.  But
  	     we can provide the result as is.  Store the data in some
  	     temporary memory.  */
! 	  dataset = (struct dataset *) alloca_account (total + n, alloca_used);
  
  	  /* We cannot add this record to the permanent database.  */
! 	  dataset_in_stack_or_freed = true;
  	}
  
        dataset->head.allocsize = total + n;
*************** cache_addgr (struct database_dyn *db, in
*** 273,278 ****
--- 275,288 ----
  		 allocated on the stack and need not be freed.  */
  	      dh->timeout = dataset->head.timeout;
  	      ++dh->nreloads;
+ 
+ 	      /* If the new record was not allocated on the stack, then it must
+ 		 be freed.  Note that it can no longer be used.  */
+ 	      if (! dataset_in_stack_or_freed)
+ 		{
+ 		  free (dataset);
+ 		  dataset_in_stack_or_freed = true;
+ 		}
  	    }
  	  else
  	    {
*************** cache_addgr (struct database_dyn *db, in
*** 288,294 ****
  		  key_copy = (char *) newp + (key_copy - (char *) dataset);
  
  		  dataset = memcpy (newp, dataset, total + n);
! 		  alloca_used = false;
  		}
  
  	      /* Mark the old record as obsolete.  */
--- 298,304 ----
  		  key_copy = (char *) newp + (key_copy - (char *) dataset);
  
  		  dataset = memcpy (newp, dataset, total + n);
! 		  dataset_in_stack_or_freed = false;
  		}
  
  	      /* Mark the old record as obsolete.  */
*************** cache_addgr (struct database_dyn *db, in
*** 303,309 ****
  	  assert (fd != -1);
  
  #ifdef HAVE_SENDFILE
! 	  if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
  	    {
  	      assert (db->wr_fd != -1);
  	      assert ((char *) &dataset->resp > (char *) db->data);
--- 313,319 ----
  	  assert (fd != -1);
  
  #ifdef HAVE_SENDFILE
! 	  if (__builtin_expect (db->mmap_used, 1) && !dataset_in_stack_or_freed)
  	    {
  	      assert (db->wr_fd != -1);
  	      assert ((char *) &dataset->resp > (char *) db->data);
*************** cache_addgr (struct database_dyn *db, in
*** 330,336 ****
  
        /* Add the record to the database.  But only if it has not been
  	 stored on the stack.  */
!       if (! alloca_used)
  	{
  	  /* If necessary, we also propagate the data to disk.  */
  	  if (db->persistent)
--- 340,346 ----
  
        /* Add the record to the database.  But only if it has not been
  	 stored on the stack.  */
!       if (! dataset_in_stack_or_freed)
  	{
  	  /* If necessary, we also propagate the data to disk.  */
  	  if (db->persistent)
Commit	Line	Data
12788f63 MT	1	diff -rcp a/nscd/grpcache.c b/nscd/grpcache.c
	2	*** a/nscd/grpcache.c Wed Apr 11 12:50:07 2012
	3	--- b/nscd/grpcache.c Wed Apr 11 21:45:58 2012
	4	*************** cache_addgr (struct database_dyn *db, in
	5	* 178,184 **
	6	char *cp;
	7	const size_t key_len = strlen (key);
	8	const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
	9	! char *buf = alloca (buf_len);
	10	ssize_t n;
	11	size_t cnt;
	12
	13	--- 178,185 ----
	14	char *cp;
	15	const size_t key_len = strlen (key);
	16	const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
	17	! size_t alloca_used = 0;
	18	! char *buf = alloca_account (buf_len, alloca_used);
	19	ssize_t n;
	20	size_t cnt;
	21
	22	*************** cache_addgr (struct database_dyn *db, in
	23	* 190,196 **
	24	/* Determine the length of all members. */
	25	while (grp->gr_mem[gr_mem_cnt])
	26	++gr_mem_cnt;
	27	! gr_mem_len = (uint32_t ) alloca (gr_mem_cnt sizeof (uint32_t));
	28	for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
	29	{
	30	gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
	31	--- 191,198 ----
	32	/* Determine the length of all members. */
	33	while (grp->gr_mem[gr_mem_cnt])
	34	++gr_mem_cnt;
	35	! gr_mem_len = (uint32_t ) alloca_account (gr_mem_cnt sizeof (uint32_t),
	36	! alloca_used);
	37	for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
	38	{
	39	gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
	40	*************** cache_addgr (struct database_dyn *db, in
	41	* 205,214 **
	42	change. Allocate memory on the cache since it is likely
	43	discarded anyway. If it turns out to be necessary to have a
	44	new record we can still allocate real memory. */
	45	! bool alloca_used = false;
	46	dataset = NULL;
	47
	48	! if (he == NULL)
	49	dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
	50
	51	if (dataset == NULL)
	52	--- 207,216 ----
	53	change. Allocate memory on the cache since it is likely
	54	discarded anyway. If it turns out to be necessary to have a
	55	new record we can still allocate real memory. */
	56	! bool dataset_in_stack_or_freed = false;
	57	dataset = NULL;
	58
	59	! if (he == NULL \|\| ! __libc_use_alloca (alloca_used + total + n))
	60	dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
	61
	62	if (dataset == NULL)
	63	*************** cache_addgr (struct database_dyn *db, in
	64	* 216,225 **
65	/* We cannot permanently add the result in the moment. But
66	we can provide the result as is. Store the data in some
67	temporary memory. */
68	! dataset = (struct dataset *) alloca (total + n);
69
70	/* We cannot add this record to the permanent database. */
71	! alloca_used = true;
72	}
73
74	dataset->head.allocsize = total + n;
75	--- 218,227 ----
76	/* We cannot permanently add the result in the moment. But
77	we can provide the result as is. Store the data in some
78	temporary memory. */
79	! dataset = (struct dataset *) alloca_account (total + n, alloca_used);
80
81	/* We cannot add this record to the permanent database. */
82	! dataset_in_stack_or_freed = true;
83	}
84
85	dataset->head.allocsize = total + n;
86	*************** cache_addgr (struct database_dyn *db, in
87	* 273,278 **
88	--- 275,288 ----
89	allocated on the stack and need not be freed. */
90	dh->timeout = dataset->head.timeout;
91	++dh->nreloads;
92	+
93	+ /* If the new record was not allocated on the stack, then it must
94	+ be freed. Note that it can no longer be used. */
95	+ if (! dataset_in_stack_or_freed)
96	+ {
97	+ free (dataset);
98	+ dataset_in_stack_or_freed = true;
99	+ }
100	}
101	else
102	{
103	*************** cache_addgr (struct database_dyn *db, in
104	* 288,294 **
105	key_copy = (char ) newp + (key_copy - (char ) dataset);
106
107	dataset = memcpy (newp, dataset, total + n);
108	! alloca_used = false;
109	}
110
111	/* Mark the old record as obsolete. */
112	--- 298,304 ----
113	key_copy = (char ) newp + (key_copy - (char ) dataset);
114
115	dataset = memcpy (newp, dataset, total + n);
116	! dataset_in_stack_or_freed = false;
117	}
118
119	/* Mark the old record as obsolete. */
120	*************** cache_addgr (struct database_dyn *db, in
121	* 303,309 **
122	assert (fd != -1);
123
124	#ifdef HAVE_SENDFILE
125	! if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
126	{
127	assert (db->wr_fd != -1);
128	assert ((char ) &dataset->resp > (char ) db->data);
129	--- 313,319 ----
130	assert (fd != -1);
131
132	#ifdef HAVE_SENDFILE
133	! if (__builtin_expect (db->mmap_used, 1) && !dataset_in_stack_or_freed)
134	{
135	assert (db->wr_fd != -1);
136	assert ((char ) &dataset->resp > (char ) db->data);
137	*************** cache_addgr (struct database_dyn *db, in
138	* 330,336 **
139
140	/* Add the record to the database. But only if it has not been
141	stored on the stack. */
142	! if (! alloca_used)
143	{
144	/* If necessary, we also propagate the data to disk. */
145	if (db->persistent)
146	--- 340,346 ----
147
148	/* Add the record to the database. But only if it has not been
149	stored on the stack. */
150	! if (! dataset_in_stack_or_freed)
151	{
152	/* If necessary, we also propagate the data to disk. */
153	if (db->persistent)