]>
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) |