diff mbox

[1/2,v1.1] Consolidate code to initialize nscd dataset header

Message ID 20140407100543.GB6181@spoyarek.pnq.redhat.com
State Committed
Headers

Commit Message

Siddhesh Poyarekar April 7, 2014, 10:05 a.m. UTC 
  On Mon, Apr 07, 2014 at 10:11:34AM +0100, Will Newton wrote:
> > -      /* Fill in the rest of the dataset.  */
> > -      dataset->head.allocsize = total + req->key_len;
> > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -      dataset->head.notfound = false;
> > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > +                                  total - offsetof (struct dataset, resp),
> > +                                  he == NULL ? 0 : (dh->nreloads + 1),
> 
> These brackets are redundant (and similar cases in other patch hunks).

Fixed.

> > -             dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -             dataset->head.recsize = total;
> > -             dataset->head.notfound = true;
> > -             dataset->head.nreloads = 0;
> > -             dataset->head.usable = true;
> > -
> > -             /* Compute the timeout time.  */
> > -             timeout = dataset->head.timeout = t + db->negtimeout;
> > +             timeout = datahead_init_neg (&dataset->head,
> > +                                          (sizeof (struct dataset)
> > +                                           + req->key_len), total,
> 
> These brackets are also redundant (and similar elsewhere).

That is deliberate for correct indentation.

> > -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> > -  dataset->head.recsize = sizeof (innetgroup_response_header);
> > -  dataset->head.notfound = result->head.notfound;
> > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -  dataset->head.usable = true;
> > -  dataset->head.ttl = result->head.ttl;
> > +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> > +                    sizeof (innetgroup_response_header),
> > +                    he == NULL ? 0 : (dh->nreloads + 1), result->head.ttl);
> 
> Is this correct? Won't this set notfound to false rather than
> result->head.notfound?

Ahh yes.  Fixed.

Here's an updated version now.  I haven't posted the ChangeLog since
it is unchanged.

Thanks,
Siddhesh

Comments

Siddhesh Poyarekar April 18, 2014, 7:34 a.m. UTC | #1 
Ping!

On Mon, Apr 07, 2014 at 03:35:43PM +0530, Siddhesh Poyarekar wrote:
> On Mon, Apr 07, 2014 at 10:11:34AM +0100, Will Newton wrote:
> > > -      /* Fill in the rest of the dataset.  */
> > > -      dataset->head.allocsize = total + req->key_len;
> > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -      dataset->head.notfound = false;
> > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > > -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > +                                  total - offsetof (struct dataset, resp),
> > > +                                  he == NULL ? 0 : (dh->nreloads + 1),
> > 
> > These brackets are redundant (and similar cases in other patch hunks).
> 
> Fixed.
> 
> > > -             dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -             dataset->head.recsize = total;
> > > -             dataset->head.notfound = true;
> > > -             dataset->head.nreloads = 0;
> > > -             dataset->head.usable = true;
> > > -
> > > -             /* Compute the timeout time.  */
> > > -             timeout = dataset->head.timeout = t + db->negtimeout;
> > > +             timeout = datahead_init_neg (&dataset->head,
> > > +                                          (sizeof (struct dataset)
> > > +                                           + req->key_len), total,
> > 
> > These brackets are also redundant (and similar elsewhere).
> 
> That is deliberate for correct indentation.
> 
> > > -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> > > -  dataset->head.recsize = sizeof (innetgroup_response_header);
> > > -  dataset->head.notfound = result->head.notfound;
> > > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -  dataset->head.usable = true;
> > > -  dataset->head.ttl = result->head.ttl;
> > > +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> > > +                    sizeof (innetgroup_response_header),
> > > +                    he == NULL ? 0 : (dh->nreloads + 1), result->head.ttl);
> > 
> > Is this correct? Won't this set notfound to false rather than
> > result->head.notfound?
> 
> Ahh yes.  Fixed.
> 
> Here's an updated version now.  I haven't posted the ChangeLog since
> it is unchanged.
> 
> Thanks,
> Siddhesh
> 
> diff --git a/nscd/aicache.c b/nscd/aicache.c
> index 98d40a1..d7966bd 100644
> --- a/nscd/aicache.c
> +++ b/nscd/aicache.c
> @@ -383,17 +383,12 @@ addhstaiX (struct database_dyn *db, int fd, request_header *req,
>  	  cp = family;
>  	}
>  
> -      /* Fill in the rest of the dataset.  */
> -      dataset->head.allocsize = total + req->key_len;
> -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> -      dataset->head.notfound = false;
> -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -      dataset->head.usable = true;
> -
> -      /* Compute the timeout time.  */
> -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> +				   total - offsetof (struct dataset, resp),
> +				   he == NULL ? 0 : dh->nreloads + 1,
> +				   ttl == INT32_MAX ? db->postimeout : ttl);
>  
> +      /* Fill in the rest of the dataset.  */
>        dataset->resp.version = NSCD_VERSION;
>        dataset->resp.found = 1;
>        dataset->resp.naddrs = naddrs;
> @@ -528,15 +523,9 @@ next_nip:
>        else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
>  					      + req->key_len), 1)) != NULL)
>  	{
> -	  dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> -	  dataset->head.recsize = total;
> -	  dataset->head.notfound = true;
> -	  dataset->head.nreloads = 0;
> -	  dataset->head.usable = true;
> -
> -	  /* Compute the timeout time.  */
> -	  timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> -	  dataset->head.ttl = db->negtimeout;
> +	  timeout = datahead_init_neg (&dataset->head,
> +				       sizeof (struct dataset) + req->key_len,
> +				       total, db->negtimeout);
>  
>  	  /* This is the reply.  */
>  	  memcpy (&dataset->resp, &notfound, total);
> diff --git a/nscd/grpcache.c b/nscd/grpcache.c
> index b5a33eb..df59fa7 100644
> --- a/nscd/grpcache.c
> +++ b/nscd/grpcache.c
> @@ -128,14 +128,10 @@ cache_addgr (struct database_dyn *db, int fd, request_header *req,
>  	    }
>  	  else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
>  	    {
> -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> -	      dataset->head.recsize = total;
> -	      dataset->head.notfound = true;
> -	      dataset->head.nreloads = 0;
> -	      dataset->head.usable = true;
> -
> -	      /* Compute the timeout time.  */
> -	      timeout = dataset->head.timeout = t + db->negtimeout;
> +	      timeout = datahead_init_neg (&dataset->head,
> +					   (sizeof (struct dataset)
> +					    + req->key_len), total,
> +					   db->negtimeout);
>  
>  	      /* This is the reply.  */
>  	      memcpy (&dataset->resp, &notfound, total);
> @@ -232,14 +228,10 @@ cache_addgr (struct database_dyn *db, int fd, request_header *req,
>  	  dataset_temporary = true;
>  	}
>  
> -      dataset->head.allocsize = total + n;
> -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> -      dataset->head.notfound = false;
> -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -      dataset->head.usable = true;
> -
> -      /* Compute the timeout time.  */
> -      timeout = dataset->head.timeout = t + db->postimeout;
> +      timeout = datahead_init_pos (&dataset->head, total + n,
> +				   total - offsetof (struct dataset, resp),
> +				   he == NULL ? 0 : dh->nreloads + 1,
> +				   db->postimeout);
>  
>        dataset->resp.version = NSCD_VERSION;
>        dataset->resp.found = 1;
> diff --git a/nscd/hstcache.c b/nscd/hstcache.c
> index a79b67a..d4f1ad2 100644
> --- a/nscd/hstcache.c
> +++ b/nscd/hstcache.c
> @@ -152,15 +152,11 @@ cache_addhst (struct database_dyn *db, int fd, request_header *req,
>  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
>  						  + req->key_len), 1)) != NULL)
>  	    {
> -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> -	      dataset->head.recsize = total;
> -	      dataset->head.notfound = true;
> -	      dataset->head.nreloads = 0;
> -	      dataset->head.usable = true;
> -
> -	      /* Compute the timeout time.  */
> -	      dataset->head.ttl = ttl == INT32_MAX ? db->negtimeout : ttl;
> -	      timeout = dataset->head.timeout = t + dataset->head.ttl;
> +	      timeout = datahead_init_neg (&dataset->head,
> +					   (sizeof (struct dataset)
> +					    + req->key_len), total,
> +					   (ttl == INT32_MAX
> +					    ? db->negtimeout : ttl));
>  
>  	      /* This is the reply.  */
>  	      memcpy (&dataset->resp, resp, total);
> @@ -257,15 +253,10 @@ cache_addhst (struct database_dyn *db, int fd, request_header *req,
>  	  alloca_used = true;
>  	}
>  
> -      dataset->head.allocsize = total + req->key_len;
> -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> -      dataset->head.notfound = false;
> -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -      dataset->head.usable = true;
> -
> -      /* Compute the timeout time.  */
> -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> -      timeout = dataset->head.timeout = t + dataset->head.ttl;
> +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> +				   total - offsetof (struct dataset, resp),
> +				   he == NULL ? 0 : dh->nreloads + 1,
> +				   ttl == INT32_MAX ? db->postimeout : ttl);
>  
>        dataset->resp.version = NSCD_VERSION;
>        dataset->resp.found = 1;
> diff --git a/nscd/initgrcache.c b/nscd/initgrcache.c
> index 1bf9f0d..361319f 100644
> --- a/nscd/initgrcache.c
> +++ b/nscd/initgrcache.c
> @@ -213,14 +213,10 @@ addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
>  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
>  						  + req->key_len), 1)) != NULL)
>  	    {
> -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> -	      dataset->head.recsize = total;
> -	      dataset->head.notfound = true;
> -	      dataset->head.nreloads = 0;
> -	      dataset->head.usable = true;
> -
> -	      /* Compute the timeout time.  */
> -	      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> +	      timeout = datahead_init_neg (&dataset->head,
> +					   (sizeof (struct dataset)
> +					    + req->key_len), total,
> +					   db->negtimeout);
>  
>  	      /* This is the reply.  */
>  	      memcpy (&dataset->resp, &notfound, total);
> @@ -276,14 +272,10 @@ addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
>  	  alloca_used = true;
>  	}
>  
> -      dataset->head.allocsize = total + req->key_len;
> -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> -      dataset->head.notfound = false;
> -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -      dataset->head.usable = true;
> -
> -      /* Compute the timeout time.  */
> -      timeout = dataset->head.timeout = time (NULL) + db->postimeout;
> +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> +				   total - offsetof (struct dataset, resp),
> +				   he == NULL ? 0 : dh->nreloads + 1,
> +				   db->postimeout);
>  
>        dataset->resp.version = NSCD_VERSION;
>        dataset->resp.found = 1;
> diff --git a/nscd/netgroupcache.c b/nscd/netgroupcache.c
> index 820d823..b3d40e9 100644
> --- a/nscd/netgroupcache.c
> +++ b/nscd/netgroupcache.c
> @@ -90,15 +90,9 @@ do_notfound (struct database_dyn *db, int fd, request_header *req,
>    /* If we cannot permanently store the result, so be it.  */
>    if (dataset != NULL)
>      {
> -      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> -      dataset->head.recsize = total;
> -      dataset->head.notfound = true;
> -      dataset->head.nreloads = 0;
> -      dataset->head.usable = true;
> -
> -      /* Compute the timeout time.  */
> -      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> -      dataset->head.ttl = db->negtimeout;
> +      timeout = datahead_init_neg (&dataset->head,
> +				   sizeof (struct dataset) + req->key_len,
> +				   total, db->negtimeout);
>  
>        /* This is the reply.  */
>        memcpy (&dataset->resp, &notfound, total);
> @@ -359,13 +353,10 @@ addgetnetgrentX (struct database_dyn *db, int fd, request_header *req,
>  
>    /* Fill in the dataset.  */
>    dataset = (struct dataset *) buffer;
> -  dataset->head.allocsize = total + req->key_len;
> -  dataset->head.recsize = total - offsetof (struct dataset, resp);
> -  dataset->head.notfound = false;
> -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -  dataset->head.usable = true;
> -  dataset->head.ttl = db->postimeout;
> -  timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> +  timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> +			       total - offsetof (struct dataset, resp),
> +			       he == NULL ? 0 : dh->nreloads + 1,
> +			       db->postimeout);
>  
>    dataset->resp.version = NSCD_VERSION;
>    dataset->resp.found = 1;
> @@ -541,12 +532,12 @@ addinnetgrX (struct database_dyn *db, int fd, request_header *req,
>        dataset = &dataset_mem;
>      }
>  
> -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> -  dataset->head.recsize = sizeof (innetgroup_response_header);
> +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> +		     sizeof (innetgroup_response_header),
> +		     he == NULL ? 0 : dh->nreloads + 1, result->head.ttl);
> +  /* Set the notfound status and timeout based on the result from
> +     getnetgrent.  */
>    dataset->head.notfound = result->head.notfound;
> -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -  dataset->head.usable = true;
> -  dataset->head.ttl = result->head.ttl;
>    dataset->head.timeout = timeout;
>  
>    dataset->resp.version = NSCD_VERSION;
> diff --git a/nscd/nscd-client.h b/nscd/nscd-client.h
> index 98f77e7..c069bf6 100644
> --- a/nscd/nscd-client.h
> +++ b/nscd/nscd-client.h
> @@ -236,6 +236,36 @@ struct datahead
>    } data[0];
>  };
>  
> +static inline time_t
> +datahead_init_common (struct datahead *head, nscd_ssize_t allocsize,
> +		      nscd_ssize_t recsize, uint32_t ttl)
> +{
> +  head->allocsize = allocsize;
> +  head->recsize = recsize;
> +  head->usable = true;
> +
> +  head->ttl = ttl;
> +  /* Compute the timeout time.  */
> +  return head->timeout = time (NULL) + ttl;
> +}
> +
> +static inline time_t
> +datahead_init_pos (struct datahead *head, nscd_ssize_t allocsize,
> +		   nscd_ssize_t recsize, uint8_t nreloads, uint32_t ttl)
> +{
> +  head->notfound = false;
> +  head->nreloads = nreloads;
> +  return datahead_init_common (head, allocsize, recsize, ttl);
> +}
> +
> +static inline time_t
> +datahead_init_neg (struct datahead *head, nscd_ssize_t allocsize,
> +		   nscd_ssize_t recsize, uint32_t ttl)
> +{
> +  head->notfound = true;
> +  head->nreloads = 0;
> +  return datahead_init_common (head, allocsize, recsize, ttl);
> +}
>  
>  /* Structure for one hash table entry.  */
>  struct hashentry
> diff --git a/nscd/pwdcache.c b/nscd/pwdcache.c
> index fa355c3..41c245b 100644
> --- a/nscd/pwdcache.c
> +++ b/nscd/pwdcache.c
> @@ -135,14 +135,10 @@ cache_addpw (struct database_dyn *db, int fd, request_header *req,
>  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
>  						  + req->key_len), 1)) != NULL)
>  	    {
> -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> -	      dataset->head.recsize = total;
> -	      dataset->head.notfound = true;
> -	      dataset->head.nreloads = 0;
> -	      dataset->head.usable = true;
> -
> -	      /* Compute the timeout time.  */
> -	      timeout = dataset->head.timeout = t + db->negtimeout;
> +	      timeout = datahead_init_neg (&dataset->head,
> +					   (sizeof (struct dataset)
> +					    + req->key_len), total,
> +					   db->negtimeout);
>  
>  	      /* This is the reply.  */
>  	      memcpy (&dataset->resp, &notfound, total);
> @@ -215,14 +211,10 @@ cache_addpw (struct database_dyn *db, int fd, request_header *req,
>  	  alloca_used = true;
>  	}
>  
> -      dataset->head.allocsize = total + n;
> -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> -      dataset->head.notfound = false;
> -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -      dataset->head.usable = true;
> -
> -      /* Compute the timeout time.  */
> -      timeout = dataset->head.timeout = t + db->postimeout;
> +      timeout = datahead_init_pos (&dataset->head, total + n,
> +				   total - offsetof (struct dataset, resp),
> +				   he == NULL ? 0 : dh->nreloads + 1,
> +				   db->postimeout);
>  
>        dataset->resp.version = NSCD_VERSION;
>        dataset->resp.found = 1;
> diff --git a/nscd/servicescache.c b/nscd/servicescache.c
> index 12ce9b2..95bdcfe 100644
> --- a/nscd/servicescache.c
> +++ b/nscd/servicescache.c
> @@ -120,14 +120,10 @@ cache_addserv (struct database_dyn *db, int fd, request_header *req,
>  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
>  						  + req->key_len), 1)) != NULL)
>  	    {
> -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> -	      dataset->head.recsize = total;
> -	      dataset->head.notfound = true;
> -	      dataset->head.nreloads = 0;
> -	      dataset->head.usable = true;
> -
> -	      /* Compute the timeout time.  */
> -	      timeout = dataset->head.timeout = t + db->negtimeout;
> +	      timeout = datahead_init_neg (&dataset->head,
> +					   (sizeof (struct dataset)
> +					    + req->key_len), total,
> +					   db->negtimeout);
>  
>  	      /* This is the reply.  */
>  	      memcpy (&dataset->resp, &notfound, total);
> @@ -207,14 +203,10 @@ cache_addserv (struct database_dyn *db, int fd, request_header *req,
>  	  alloca_used = true;
>  	}
>  
> -      dataset->head.allocsize = total + req->key_len;
> -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> -      dataset->head.notfound = false;
> -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> -      dataset->head.usable = true;
> -
> -      /* Compute the timeout time.  */
> -      timeout = dataset->head.timeout = t + db->postimeout;
> +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> +				   total - offsetof (struct dataset, resp),
> +				   he == NULL ? 0 : dh->nreloads + 1,
> +				   db->postimeout);
>  
>        dataset->resp.version = NSCD_VERSION;
>        dataset->resp.found = 1;
Siddhesh Poyarekar April 22, 2014, 9:48 a.m. UTC | #2 
Ping!

On Fri, Apr 18, 2014 at 01:04:47PM +0530, Siddhesh Poyarekar wrote:
> Ping!
> 
> On Mon, Apr 07, 2014 at 03:35:43PM +0530, Siddhesh Poyarekar wrote:
> > On Mon, Apr 07, 2014 at 10:11:34AM +0100, Will Newton wrote:
> > > > -      /* Fill in the rest of the dataset.  */
> > > > -      dataset->head.allocsize = total + req->key_len;
> > > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > > -      dataset->head.notfound = false;
> > > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > > -      dataset->head.usable = true;
> > > > -
> > > > -      /* Compute the timeout time.  */
> > > > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > > > -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > > +                                  total - offsetof (struct dataset, resp),
> > > > +                                  he == NULL ? 0 : (dh->nreloads + 1),
> > > 
> > > These brackets are redundant (and similar cases in other patch hunks).
> > 
> > Fixed.
> > 
> > > > -             dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > > -             dataset->head.recsize = total;
> > > > -             dataset->head.notfound = true;
> > > > -             dataset->head.nreloads = 0;
> > > > -             dataset->head.usable = true;
> > > > -
> > > > -             /* Compute the timeout time.  */
> > > > -             timeout = dataset->head.timeout = t + db->negtimeout;
> > > > +             timeout = datahead_init_neg (&dataset->head,
> > > > +                                          (sizeof (struct dataset)
> > > > +                                           + req->key_len), total,
> > > 
> > > These brackets are also redundant (and similar elsewhere).
> > 
> > That is deliberate for correct indentation.
> > 
> > > > -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> > > > -  dataset->head.recsize = sizeof (innetgroup_response_header);
> > > > -  dataset->head.notfound = result->head.notfound;
> > > > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > > -  dataset->head.usable = true;
> > > > -  dataset->head.ttl = result->head.ttl;
> > > > +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> > > > +                    sizeof (innetgroup_response_header),
> > > > +                    he == NULL ? 0 : (dh->nreloads + 1), result->head.ttl);
> > > 
> > > Is this correct? Won't this set notfound to false rather than
> > > result->head.notfound?
> > 
> > Ahh yes.  Fixed.
> > 
> > Here's an updated version now.  I haven't posted the ChangeLog since
> > it is unchanged.
> > 
> > Thanks,
> > Siddhesh
> > 
> > diff --git a/nscd/aicache.c b/nscd/aicache.c
> > index 98d40a1..d7966bd 100644
> > --- a/nscd/aicache.c
> > +++ b/nscd/aicache.c
> > @@ -383,17 +383,12 @@ addhstaiX (struct database_dyn *db, int fd, request_header *req,
> >  	  cp = family;
> >  	}
> >  
> > -      /* Fill in the rest of the dataset.  */
> > -      dataset->head.allocsize = total + req->key_len;
> > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -      dataset->head.notfound = false;
> > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > +				   total - offsetof (struct dataset, resp),
> > +				   he == NULL ? 0 : dh->nreloads + 1,
> > +				   ttl == INT32_MAX ? db->postimeout : ttl);
> >  
> > +      /* Fill in the rest of the dataset.  */
> >        dataset->resp.version = NSCD_VERSION;
> >        dataset->resp.found = 1;
> >        dataset->resp.naddrs = naddrs;
> > @@ -528,15 +523,9 @@ next_nip:
> >        else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> >  					      + req->key_len), 1)) != NULL)
> >  	{
> > -	  dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -	  dataset->head.recsize = total;
> > -	  dataset->head.notfound = true;
> > -	  dataset->head.nreloads = 0;
> > -	  dataset->head.usable = true;
> > -
> > -	  /* Compute the timeout time.  */
> > -	  timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> > -	  dataset->head.ttl = db->negtimeout;
> > +	  timeout = datahead_init_neg (&dataset->head,
> > +				       sizeof (struct dataset) + req->key_len,
> > +				       total, db->negtimeout);
> >  
> >  	  /* This is the reply.  */
> >  	  memcpy (&dataset->resp, &notfound, total);
> > diff --git a/nscd/grpcache.c b/nscd/grpcache.c
> > index b5a33eb..df59fa7 100644
> > --- a/nscd/grpcache.c
> > +++ b/nscd/grpcache.c
> > @@ -128,14 +128,10 @@ cache_addgr (struct database_dyn *db, int fd, request_header *req,
> >  	    }
> >  	  else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
> >  	    {
> > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -	      dataset->head.recsize = total;
> > -	      dataset->head.notfound = true;
> > -	      dataset->head.nreloads = 0;
> > -	      dataset->head.usable = true;
> > -
> > -	      /* Compute the timeout time.  */
> > -	      timeout = dataset->head.timeout = t + db->negtimeout;
> > +	      timeout = datahead_init_neg (&dataset->head,
> > +					   (sizeof (struct dataset)
> > +					    + req->key_len), total,
> > +					   db->negtimeout);
> >  
> >  	      /* This is the reply.  */
> >  	      memcpy (&dataset->resp, &notfound, total);
> > @@ -232,14 +228,10 @@ cache_addgr (struct database_dyn *db, int fd, request_header *req,
> >  	  dataset_temporary = true;
> >  	}
> >  
> > -      dataset->head.allocsize = total + n;
> > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -      dataset->head.notfound = false;
> > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      timeout = dataset->head.timeout = t + db->postimeout;
> > +      timeout = datahead_init_pos (&dataset->head, total + n,
> > +				   total - offsetof (struct dataset, resp),
> > +				   he == NULL ? 0 : dh->nreloads + 1,
> > +				   db->postimeout);
> >  
> >        dataset->resp.version = NSCD_VERSION;
> >        dataset->resp.found = 1;
> > diff --git a/nscd/hstcache.c b/nscd/hstcache.c
> > index a79b67a..d4f1ad2 100644
> > --- a/nscd/hstcache.c
> > +++ b/nscd/hstcache.c
> > @@ -152,15 +152,11 @@ cache_addhst (struct database_dyn *db, int fd, request_header *req,
> >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> >  						  + req->key_len), 1)) != NULL)
> >  	    {
> > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -	      dataset->head.recsize = total;
> > -	      dataset->head.notfound = true;
> > -	      dataset->head.nreloads = 0;
> > -	      dataset->head.usable = true;
> > -
> > -	      /* Compute the timeout time.  */
> > -	      dataset->head.ttl = ttl == INT32_MAX ? db->negtimeout : ttl;
> > -	      timeout = dataset->head.timeout = t + dataset->head.ttl;
> > +	      timeout = datahead_init_neg (&dataset->head,
> > +					   (sizeof (struct dataset)
> > +					    + req->key_len), total,
> > +					   (ttl == INT32_MAX
> > +					    ? db->negtimeout : ttl));
> >  
> >  	      /* This is the reply.  */
> >  	      memcpy (&dataset->resp, resp, total);
> > @@ -257,15 +253,10 @@ cache_addhst (struct database_dyn *db, int fd, request_header *req,
> >  	  alloca_used = true;
> >  	}
> >  
> > -      dataset->head.allocsize = total + req->key_len;
> > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -      dataset->head.notfound = false;
> > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > -      timeout = dataset->head.timeout = t + dataset->head.ttl;
> > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > +				   total - offsetof (struct dataset, resp),
> > +				   he == NULL ? 0 : dh->nreloads + 1,
> > +				   ttl == INT32_MAX ? db->postimeout : ttl);
> >  
> >        dataset->resp.version = NSCD_VERSION;
> >        dataset->resp.found = 1;
> > diff --git a/nscd/initgrcache.c b/nscd/initgrcache.c
> > index 1bf9f0d..361319f 100644
> > --- a/nscd/initgrcache.c
> > +++ b/nscd/initgrcache.c
> > @@ -213,14 +213,10 @@ addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
> >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> >  						  + req->key_len), 1)) != NULL)
> >  	    {
> > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -	      dataset->head.recsize = total;
> > -	      dataset->head.notfound = true;
> > -	      dataset->head.nreloads = 0;
> > -	      dataset->head.usable = true;
> > -
> > -	      /* Compute the timeout time.  */
> > -	      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> > +	      timeout = datahead_init_neg (&dataset->head,
> > +					   (sizeof (struct dataset)
> > +					    + req->key_len), total,
> > +					   db->negtimeout);
> >  
> >  	      /* This is the reply.  */
> >  	      memcpy (&dataset->resp, &notfound, total);
> > @@ -276,14 +272,10 @@ addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
> >  	  alloca_used = true;
> >  	}
> >  
> > -      dataset->head.allocsize = total + req->key_len;
> > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -      dataset->head.notfound = false;
> > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      timeout = dataset->head.timeout = time (NULL) + db->postimeout;
> > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > +				   total - offsetof (struct dataset, resp),
> > +				   he == NULL ? 0 : dh->nreloads + 1,
> > +				   db->postimeout);
> >  
> >        dataset->resp.version = NSCD_VERSION;
> >        dataset->resp.found = 1;
> > diff --git a/nscd/netgroupcache.c b/nscd/netgroupcache.c
> > index 820d823..b3d40e9 100644
> > --- a/nscd/netgroupcache.c
> > +++ b/nscd/netgroupcache.c
> > @@ -90,15 +90,9 @@ do_notfound (struct database_dyn *db, int fd, request_header *req,
> >    /* If we cannot permanently store the result, so be it.  */
> >    if (dataset != NULL)
> >      {
> > -      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -      dataset->head.recsize = total;
> > -      dataset->head.notfound = true;
> > -      dataset->head.nreloads = 0;
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> > -      dataset->head.ttl = db->negtimeout;
> > +      timeout = datahead_init_neg (&dataset->head,
> > +				   sizeof (struct dataset) + req->key_len,
> > +				   total, db->negtimeout);
> >  
> >        /* This is the reply.  */
> >        memcpy (&dataset->resp, &notfound, total);
> > @@ -359,13 +353,10 @@ addgetnetgrentX (struct database_dyn *db, int fd, request_header *req,
> >  
> >    /* Fill in the dataset.  */
> >    dataset = (struct dataset *) buffer;
> > -  dataset->head.allocsize = total + req->key_len;
> > -  dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -  dataset->head.notfound = false;
> > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -  dataset->head.usable = true;
> > -  dataset->head.ttl = db->postimeout;
> > -  timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > +  timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > +			       total - offsetof (struct dataset, resp),
> > +			       he == NULL ? 0 : dh->nreloads + 1,
> > +			       db->postimeout);
> >  
> >    dataset->resp.version = NSCD_VERSION;
> >    dataset->resp.found = 1;
> > @@ -541,12 +532,12 @@ addinnetgrX (struct database_dyn *db, int fd, request_header *req,
> >        dataset = &dataset_mem;
> >      }
> >  
> > -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> > -  dataset->head.recsize = sizeof (innetgroup_response_header);
> > +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> > +		     sizeof (innetgroup_response_header),
> > +		     he == NULL ? 0 : dh->nreloads + 1, result->head.ttl);
> > +  /* Set the notfound status and timeout based on the result from
> > +     getnetgrent.  */
> >    dataset->head.notfound = result->head.notfound;
> > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -  dataset->head.usable = true;
> > -  dataset->head.ttl = result->head.ttl;
> >    dataset->head.timeout = timeout;
> >  
> >    dataset->resp.version = NSCD_VERSION;
> > diff --git a/nscd/nscd-client.h b/nscd/nscd-client.h
> > index 98f77e7..c069bf6 100644
> > --- a/nscd/nscd-client.h
> > +++ b/nscd/nscd-client.h
> > @@ -236,6 +236,36 @@ struct datahead
> >    } data[0];
> >  };
> >  
> > +static inline time_t
> > +datahead_init_common (struct datahead *head, nscd_ssize_t allocsize,
> > +		      nscd_ssize_t recsize, uint32_t ttl)
> > +{
> > +  head->allocsize = allocsize;
> > +  head->recsize = recsize;
> > +  head->usable = true;
> > +
> > +  head->ttl = ttl;
> > +  /* Compute the timeout time.  */
> > +  return head->timeout = time (NULL) + ttl;
> > +}
> > +
> > +static inline time_t
> > +datahead_init_pos (struct datahead *head, nscd_ssize_t allocsize,
> > +		   nscd_ssize_t recsize, uint8_t nreloads, uint32_t ttl)
> > +{
> > +  head->notfound = false;
> > +  head->nreloads = nreloads;
> > +  return datahead_init_common (head, allocsize, recsize, ttl);
> > +}
> > +
> > +static inline time_t
> > +datahead_init_neg (struct datahead *head, nscd_ssize_t allocsize,
> > +		   nscd_ssize_t recsize, uint32_t ttl)
> > +{
> > +  head->notfound = true;
> > +  head->nreloads = 0;
> > +  return datahead_init_common (head, allocsize, recsize, ttl);
> > +}
> >  
> >  /* Structure for one hash table entry.  */
> >  struct hashentry
> > diff --git a/nscd/pwdcache.c b/nscd/pwdcache.c
> > index fa355c3..41c245b 100644
> > --- a/nscd/pwdcache.c
> > +++ b/nscd/pwdcache.c
> > @@ -135,14 +135,10 @@ cache_addpw (struct database_dyn *db, int fd, request_header *req,
> >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> >  						  + req->key_len), 1)) != NULL)
> >  	    {
> > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -	      dataset->head.recsize = total;
> > -	      dataset->head.notfound = true;
> > -	      dataset->head.nreloads = 0;
> > -	      dataset->head.usable = true;
> > -
> > -	      /* Compute the timeout time.  */
> > -	      timeout = dataset->head.timeout = t + db->negtimeout;
> > +	      timeout = datahead_init_neg (&dataset->head,
> > +					   (sizeof (struct dataset)
> > +					    + req->key_len), total,
> > +					   db->negtimeout);
> >  
> >  	      /* This is the reply.  */
> >  	      memcpy (&dataset->resp, &notfound, total);
> > @@ -215,14 +211,10 @@ cache_addpw (struct database_dyn *db, int fd, request_header *req,
> >  	  alloca_used = true;
> >  	}
> >  
> > -      dataset->head.allocsize = total + n;
> > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -      dataset->head.notfound = false;
> > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      timeout = dataset->head.timeout = t + db->postimeout;
> > +      timeout = datahead_init_pos (&dataset->head, total + n,
> > +				   total - offsetof (struct dataset, resp),
> > +				   he == NULL ? 0 : dh->nreloads + 1,
> > +				   db->postimeout);
> >  
> >        dataset->resp.version = NSCD_VERSION;
> >        dataset->resp.found = 1;
> > diff --git a/nscd/servicescache.c b/nscd/servicescache.c
> > index 12ce9b2..95bdcfe 100644
> > --- a/nscd/servicescache.c
> > +++ b/nscd/servicescache.c
> > @@ -120,14 +120,10 @@ cache_addserv (struct database_dyn *db, int fd, request_header *req,
> >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> >  						  + req->key_len), 1)) != NULL)
> >  	    {
> > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > -	      dataset->head.recsize = total;
> > -	      dataset->head.notfound = true;
> > -	      dataset->head.nreloads = 0;
> > -	      dataset->head.usable = true;
> > -
> > -	      /* Compute the timeout time.  */
> > -	      timeout = dataset->head.timeout = t + db->negtimeout;
> > +	      timeout = datahead_init_neg (&dataset->head,
> > +					   (sizeof (struct dataset)
> > +					    + req->key_len), total,
> > +					   db->negtimeout);
> >  
> >  	      /* This is the reply.  */
> >  	      memcpy (&dataset->resp, &notfound, total);
> > @@ -207,14 +203,10 @@ cache_addserv (struct database_dyn *db, int fd, request_header *req,
> >  	  alloca_used = true;
> >  	}
> >  
> > -      dataset->head.allocsize = total + req->key_len;
> > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > -      dataset->head.notfound = false;
> > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > -      dataset->head.usable = true;
> > -
> > -      /* Compute the timeout time.  */
> > -      timeout = dataset->head.timeout = t + db->postimeout;
> > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > +				   total - offsetof (struct dataset, resp),
> > +				   he == NULL ? 0 : dh->nreloads + 1,
> > +				   db->postimeout);
> >  
> >        dataset->resp.version = NSCD_VERSION;
> >        dataset->resp.found = 1;
> 
>
Siddhesh Poyarekar April 28, 2014, 2:50 p.m. UTC | #3 
Ping!

On Tue, Apr 22, 2014 at 03:18:20PM +0530, Siddhesh Poyarekar wrote:
> Ping!
> 
> On Fri, Apr 18, 2014 at 01:04:47PM +0530, Siddhesh Poyarekar wrote:
> > Ping!
> > 
> > On Mon, Apr 07, 2014 at 03:35:43PM +0530, Siddhesh Poyarekar wrote:
> > > On Mon, Apr 07, 2014 at 10:11:34AM +0100, Will Newton wrote:
> > > > > -      /* Fill in the rest of the dataset.  */
> > > > > -      dataset->head.allocsize = total + req->key_len;
> > > > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > > > -      dataset->head.notfound = false;
> > > > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > > > -      dataset->head.usable = true;
> > > > > -
> > > > > -      /* Compute the timeout time.  */
> > > > > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > > > > -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > > > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > > > +                                  total - offsetof (struct dataset, resp),
> > > > > +                                  he == NULL ? 0 : (dh->nreloads + 1),
> > > > 
> > > > These brackets are redundant (and similar cases in other patch hunks).
> > > 
> > > Fixed.
> > > 
> > > > > -             dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > > > -             dataset->head.recsize = total;
> > > > > -             dataset->head.notfound = true;
> > > > > -             dataset->head.nreloads = 0;
> > > > > -             dataset->head.usable = true;
> > > > > -
> > > > > -             /* Compute the timeout time.  */
> > > > > -             timeout = dataset->head.timeout = t + db->negtimeout;
> > > > > +             timeout = datahead_init_neg (&dataset->head,
> > > > > +                                          (sizeof (struct dataset)
> > > > > +                                           + req->key_len), total,
> > > > 
> > > > These brackets are also redundant (and similar elsewhere).
> > > 
> > > That is deliberate for correct indentation.
> > > 
> > > > > -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> > > > > -  dataset->head.recsize = sizeof (innetgroup_response_header);
> > > > > -  dataset->head.notfound = result->head.notfound;
> > > > > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > > > -  dataset->head.usable = true;
> > > > > -  dataset->head.ttl = result->head.ttl;
> > > > > +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> > > > > +                    sizeof (innetgroup_response_header),
> > > > > +                    he == NULL ? 0 : (dh->nreloads + 1), result->head.ttl);
> > > > 
> > > > Is this correct? Won't this set notfound to false rather than
> > > > result->head.notfound?
> > > 
> > > Ahh yes.  Fixed.
> > > 
> > > Here's an updated version now.  I haven't posted the ChangeLog since
> > > it is unchanged.
> > > 
> > > Thanks,
> > > Siddhesh
> > > 
> > > diff --git a/nscd/aicache.c b/nscd/aicache.c
> > > index 98d40a1..d7966bd 100644
> > > --- a/nscd/aicache.c
> > > +++ b/nscd/aicache.c
> > > @@ -383,17 +383,12 @@ addhstaiX (struct database_dyn *db, int fd, request_header *req,
> > >  	  cp = family;
> > >  	}
> > >  
> > > -      /* Fill in the rest of the dataset.  */
> > > -      dataset->head.allocsize = total + req->key_len;
> > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -      dataset->head.notfound = false;
> > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > > -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > +				   total - offsetof (struct dataset, resp),
> > > +				   he == NULL ? 0 : dh->nreloads + 1,
> > > +				   ttl == INT32_MAX ? db->postimeout : ttl);
> > >  
> > > +      /* Fill in the rest of the dataset.  */
> > >        dataset->resp.version = NSCD_VERSION;
> > >        dataset->resp.found = 1;
> > >        dataset->resp.naddrs = naddrs;
> > > @@ -528,15 +523,9 @@ next_nip:
> > >        else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> > >  					      + req->key_len), 1)) != NULL)
> > >  	{
> > > -	  dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -	  dataset->head.recsize = total;
> > > -	  dataset->head.notfound = true;
> > > -	  dataset->head.nreloads = 0;
> > > -	  dataset->head.usable = true;
> > > -
> > > -	  /* Compute the timeout time.  */
> > > -	  timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> > > -	  dataset->head.ttl = db->negtimeout;
> > > +	  timeout = datahead_init_neg (&dataset->head,
> > > +				       sizeof (struct dataset) + req->key_len,
> > > +				       total, db->negtimeout);
> > >  
> > >  	  /* This is the reply.  */
> > >  	  memcpy (&dataset->resp, &notfound, total);
> > > diff --git a/nscd/grpcache.c b/nscd/grpcache.c
> > > index b5a33eb..df59fa7 100644
> > > --- a/nscd/grpcache.c
> > > +++ b/nscd/grpcache.c
> > > @@ -128,14 +128,10 @@ cache_addgr (struct database_dyn *db, int fd, request_header *req,
> > >  	    }
> > >  	  else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
> > >  	    {
> > > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -	      dataset->head.recsize = total;
> > > -	      dataset->head.notfound = true;
> > > -	      dataset->head.nreloads = 0;
> > > -	      dataset->head.usable = true;
> > > -
> > > -	      /* Compute the timeout time.  */
> > > -	      timeout = dataset->head.timeout = t + db->negtimeout;
> > > +	      timeout = datahead_init_neg (&dataset->head,
> > > +					   (sizeof (struct dataset)
> > > +					    + req->key_len), total,
> > > +					   db->negtimeout);
> > >  
> > >  	      /* This is the reply.  */
> > >  	      memcpy (&dataset->resp, &notfound, total);
> > > @@ -232,14 +228,10 @@ cache_addgr (struct database_dyn *db, int fd, request_header *req,
> > >  	  dataset_temporary = true;
> > >  	}
> > >  
> > > -      dataset->head.allocsize = total + n;
> > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -      dataset->head.notfound = false;
> > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      timeout = dataset->head.timeout = t + db->postimeout;
> > > +      timeout = datahead_init_pos (&dataset->head, total + n,
> > > +				   total - offsetof (struct dataset, resp),
> > > +				   he == NULL ? 0 : dh->nreloads + 1,
> > > +				   db->postimeout);
> > >  
> > >        dataset->resp.version = NSCD_VERSION;
> > >        dataset->resp.found = 1;
> > > diff --git a/nscd/hstcache.c b/nscd/hstcache.c
> > > index a79b67a..d4f1ad2 100644
> > > --- a/nscd/hstcache.c
> > > +++ b/nscd/hstcache.c
> > > @@ -152,15 +152,11 @@ cache_addhst (struct database_dyn *db, int fd, request_header *req,
> > >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> > >  						  + req->key_len), 1)) != NULL)
> > >  	    {
> > > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -	      dataset->head.recsize = total;
> > > -	      dataset->head.notfound = true;
> > > -	      dataset->head.nreloads = 0;
> > > -	      dataset->head.usable = true;
> > > -
> > > -	      /* Compute the timeout time.  */
> > > -	      dataset->head.ttl = ttl == INT32_MAX ? db->negtimeout : ttl;
> > > -	      timeout = dataset->head.timeout = t + dataset->head.ttl;
> > > +	      timeout = datahead_init_neg (&dataset->head,
> > > +					   (sizeof (struct dataset)
> > > +					    + req->key_len), total,
> > > +					   (ttl == INT32_MAX
> > > +					    ? db->negtimeout : ttl));
> > >  
> > >  	      /* This is the reply.  */
> > >  	      memcpy (&dataset->resp, resp, total);
> > > @@ -257,15 +253,10 @@ cache_addhst (struct database_dyn *db, int fd, request_header *req,
> > >  	  alloca_used = true;
> > >  	}
> > >  
> > > -      dataset->head.allocsize = total + req->key_len;
> > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -      dataset->head.notfound = false;
> > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > > -      timeout = dataset->head.timeout = t + dataset->head.ttl;
> > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > +				   total - offsetof (struct dataset, resp),
> > > +				   he == NULL ? 0 : dh->nreloads + 1,
> > > +				   ttl == INT32_MAX ? db->postimeout : ttl);
> > >  
> > >        dataset->resp.version = NSCD_VERSION;
> > >        dataset->resp.found = 1;
> > > diff --git a/nscd/initgrcache.c b/nscd/initgrcache.c
> > > index 1bf9f0d..361319f 100644
> > > --- a/nscd/initgrcache.c
> > > +++ b/nscd/initgrcache.c
> > > @@ -213,14 +213,10 @@ addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
> > >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> > >  						  + req->key_len), 1)) != NULL)
> > >  	    {
> > > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -	      dataset->head.recsize = total;
> > > -	      dataset->head.notfound = true;
> > > -	      dataset->head.nreloads = 0;
> > > -	      dataset->head.usable = true;
> > > -
> > > -	      /* Compute the timeout time.  */
> > > -	      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> > > +	      timeout = datahead_init_neg (&dataset->head,
> > > +					   (sizeof (struct dataset)
> > > +					    + req->key_len), total,
> > > +					   db->negtimeout);
> > >  
> > >  	      /* This is the reply.  */
> > >  	      memcpy (&dataset->resp, &notfound, total);
> > > @@ -276,14 +272,10 @@ addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
> > >  	  alloca_used = true;
> > >  	}
> > >  
> > > -      dataset->head.allocsize = total + req->key_len;
> > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -      dataset->head.notfound = false;
> > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      timeout = dataset->head.timeout = time (NULL) + db->postimeout;
> > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > +				   total - offsetof (struct dataset, resp),
> > > +				   he == NULL ? 0 : dh->nreloads + 1,
> > > +				   db->postimeout);
> > >  
> > >        dataset->resp.version = NSCD_VERSION;
> > >        dataset->resp.found = 1;
> > > diff --git a/nscd/netgroupcache.c b/nscd/netgroupcache.c
> > > index 820d823..b3d40e9 100644
> > > --- a/nscd/netgroupcache.c
> > > +++ b/nscd/netgroupcache.c
> > > @@ -90,15 +90,9 @@ do_notfound (struct database_dyn *db, int fd, request_header *req,
> > >    /* If we cannot permanently store the result, so be it.  */
> > >    if (dataset != NULL)
> > >      {
> > > -      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -      dataset->head.recsize = total;
> > > -      dataset->head.notfound = true;
> > > -      dataset->head.nreloads = 0;
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
> > > -      dataset->head.ttl = db->negtimeout;
> > > +      timeout = datahead_init_neg (&dataset->head,
> > > +				   sizeof (struct dataset) + req->key_len,
> > > +				   total, db->negtimeout);
> > >  
> > >        /* This is the reply.  */
> > >        memcpy (&dataset->resp, &notfound, total);
> > > @@ -359,13 +353,10 @@ addgetnetgrentX (struct database_dyn *db, int fd, request_header *req,
> > >  
> > >    /* Fill in the dataset.  */
> > >    dataset = (struct dataset *) buffer;
> > > -  dataset->head.allocsize = total + req->key_len;
> > > -  dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -  dataset->head.notfound = false;
> > > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -  dataset->head.usable = true;
> > > -  dataset->head.ttl = db->postimeout;
> > > -  timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > > +  timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > +			       total - offsetof (struct dataset, resp),
> > > +			       he == NULL ? 0 : dh->nreloads + 1,
> > > +			       db->postimeout);
> > >  
> > >    dataset->resp.version = NSCD_VERSION;
> > >    dataset->resp.found = 1;
> > > @@ -541,12 +532,12 @@ addinnetgrX (struct database_dyn *db, int fd, request_header *req,
> > >        dataset = &dataset_mem;
> > >      }
> > >  
> > > -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> > > -  dataset->head.recsize = sizeof (innetgroup_response_header);
> > > +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> > > +		     sizeof (innetgroup_response_header),
> > > +		     he == NULL ? 0 : dh->nreloads + 1, result->head.ttl);
> > > +  /* Set the notfound status and timeout based on the result from
> > > +     getnetgrent.  */
> > >    dataset->head.notfound = result->head.notfound;
> > > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -  dataset->head.usable = true;
> > > -  dataset->head.ttl = result->head.ttl;
> > >    dataset->head.timeout = timeout;
> > >  
> > >    dataset->resp.version = NSCD_VERSION;
> > > diff --git a/nscd/nscd-client.h b/nscd/nscd-client.h
> > > index 98f77e7..c069bf6 100644
> > > --- a/nscd/nscd-client.h
> > > +++ b/nscd/nscd-client.h
> > > @@ -236,6 +236,36 @@ struct datahead
> > >    } data[0];
> > >  };
> > >  
> > > +static inline time_t
> > > +datahead_init_common (struct datahead *head, nscd_ssize_t allocsize,
> > > +		      nscd_ssize_t recsize, uint32_t ttl)
> > > +{
> > > +  head->allocsize = allocsize;
> > > +  head->recsize = recsize;
> > > +  head->usable = true;
> > > +
> > > +  head->ttl = ttl;
> > > +  /* Compute the timeout time.  */
> > > +  return head->timeout = time (NULL) + ttl;
> > > +}
> > > +
> > > +static inline time_t
> > > +datahead_init_pos (struct datahead *head, nscd_ssize_t allocsize,
> > > +		   nscd_ssize_t recsize, uint8_t nreloads, uint32_t ttl)
> > > +{
> > > +  head->notfound = false;
> > > +  head->nreloads = nreloads;
> > > +  return datahead_init_common (head, allocsize, recsize, ttl);
> > > +}
> > > +
> > > +static inline time_t
> > > +datahead_init_neg (struct datahead *head, nscd_ssize_t allocsize,
> > > +		   nscd_ssize_t recsize, uint32_t ttl)
> > > +{
> > > +  head->notfound = true;
> > > +  head->nreloads = 0;
> > > +  return datahead_init_common (head, allocsize, recsize, ttl);
> > > +}
> > >  
> > >  /* Structure for one hash table entry.  */
> > >  struct hashentry
> > > diff --git a/nscd/pwdcache.c b/nscd/pwdcache.c
> > > index fa355c3..41c245b 100644
> > > --- a/nscd/pwdcache.c
> > > +++ b/nscd/pwdcache.c
> > > @@ -135,14 +135,10 @@ cache_addpw (struct database_dyn *db, int fd, request_header *req,
> > >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> > >  						  + req->key_len), 1)) != NULL)
> > >  	    {
> > > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -	      dataset->head.recsize = total;
> > > -	      dataset->head.notfound = true;
> > > -	      dataset->head.nreloads = 0;
> > > -	      dataset->head.usable = true;
> > > -
> > > -	      /* Compute the timeout time.  */
> > > -	      timeout = dataset->head.timeout = t + db->negtimeout;
> > > +	      timeout = datahead_init_neg (&dataset->head,
> > > +					   (sizeof (struct dataset)
> > > +					    + req->key_len), total,
> > > +					   db->negtimeout);
> > >  
> > >  	      /* This is the reply.  */
> > >  	      memcpy (&dataset->resp, &notfound, total);
> > > @@ -215,14 +211,10 @@ cache_addpw (struct database_dyn *db, int fd, request_header *req,
> > >  	  alloca_used = true;
> > >  	}
> > >  
> > > -      dataset->head.allocsize = total + n;
> > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -      dataset->head.notfound = false;
> > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      timeout = dataset->head.timeout = t + db->postimeout;
> > > +      timeout = datahead_init_pos (&dataset->head, total + n,
> > > +				   total - offsetof (struct dataset, resp),
> > > +				   he == NULL ? 0 : dh->nreloads + 1,
> > > +				   db->postimeout);
> > >  
> > >        dataset->resp.version = NSCD_VERSION;
> > >        dataset->resp.found = 1;
> > > diff --git a/nscd/servicescache.c b/nscd/servicescache.c
> > > index 12ce9b2..95bdcfe 100644
> > > --- a/nscd/servicescache.c
> > > +++ b/nscd/servicescache.c
> > > @@ -120,14 +120,10 @@ cache_addserv (struct database_dyn *db, int fd, request_header *req,
> > >  	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
> > >  						  + req->key_len), 1)) != NULL)
> > >  	    {
> > > -	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > -	      dataset->head.recsize = total;
> > > -	      dataset->head.notfound = true;
> > > -	      dataset->head.nreloads = 0;
> > > -	      dataset->head.usable = true;
> > > -
> > > -	      /* Compute the timeout time.  */
> > > -	      timeout = dataset->head.timeout = t + db->negtimeout;
> > > +	      timeout = datahead_init_neg (&dataset->head,
> > > +					   (sizeof (struct dataset)
> > > +					    + req->key_len), total,
> > > +					   db->negtimeout);
> > >  
> > >  	      /* This is the reply.  */
> > >  	      memcpy (&dataset->resp, &notfound, total);
> > > @@ -207,14 +203,10 @@ cache_addserv (struct database_dyn *db, int fd, request_header *req,
> > >  	  alloca_used = true;
> > >  	}
> > >  
> > > -      dataset->head.allocsize = total + req->key_len;
> > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > -      dataset->head.notfound = false;
> > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > -      dataset->head.usable = true;
> > > -
> > > -      /* Compute the timeout time.  */
> > > -      timeout = dataset->head.timeout = t + db->postimeout;
> > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > +				   total - offsetof (struct dataset, resp),
> > > +				   he == NULL ? 0 : dh->nreloads + 1,
> > > +				   db->postimeout);
> > >  
> > >        dataset->resp.version = NSCD_VERSION;
> > >        dataset->resp.found = 1;
> > 
> > 
> 
>
Ondrej Bilka April 28, 2014, 3:47 p.m. UTC | #4 
On Mon, Apr 28, 2014 at 08:20:27PM +0530, Siddhesh Poyarekar wrote:
> Ping!
> 
> On Tue, Apr 22, 2014 at 03:18:20PM +0530, Siddhesh Poyarekar wrote:
> > Ping!
> > 
> > On Fri, Apr 18, 2014 at 01:04:47PM +0530, Siddhesh Poyarekar wrote:
> > > Ping!
> > > 
> > > On Mon, Apr 07, 2014 at 03:35:43PM +0530, Siddhesh Poyarekar wrote:
> > > > On Mon, Apr 07, 2014 at 10:11:34AM +0100, Will Newton wrote:
> > > > > > -      /* Fill in the rest of the dataset.  */
> > > > > > -      dataset->head.allocsize = total + req->key_len;
> > > > > > -      dataset->head.recsize = total - offsetof (struct dataset, resp);
> > > > > > -      dataset->head.notfound = false;
> > > > > > -      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > > > > -      dataset->head.usable = true;
> > > > > > -
> > > > > > -      /* Compute the timeout time.  */
> > > > > > -      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
> > > > > > -      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
> > > > > > +      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
> > > > > > +                                  total - offsetof (struct dataset, resp),
> > > > > > +                                  he == NULL ? 0 : (dh->nreloads + 1),
> > > > > 
> > > > > These brackets are redundant (and similar cases in other patch hunks).
> > > > 
> > > > Fixed.
> > > > 
> > > > > > -             dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
> > > > > > -             dataset->head.recsize = total;
> > > > > > -             dataset->head.notfound = true;
> > > > > > -             dataset->head.nreloads = 0;
> > > > > > -             dataset->head.usable = true;
> > > > > > -
> > > > > > -             /* Compute the timeout time.  */
> > > > > > -             timeout = dataset->head.timeout = t + db->negtimeout;
> > > > > > +             timeout = datahead_init_neg (&dataset->head,
> > > > > > +                                          (sizeof (struct dataset)
> > > > > > +                                           + req->key_len), total,
> > > > > 
> > > > > These brackets are also redundant (and similar elsewhere).
> > > > 
> > > > That is deliberate for correct indentation.
> > > > 
> > > > > > -  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
> > > > > > -  dataset->head.recsize = sizeof (innetgroup_response_header);
> > > > > > -  dataset->head.notfound = result->head.notfound;
> > > > > > -  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
> > > > > > -  dataset->head.usable = true;
> > > > > > -  dataset->head.ttl = result->head.ttl;
> > > > > > +  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
> > > > > > +                    sizeof (innetgroup_response_header),
> > > > > > +                    he == NULL ? 0 : (dh->nreloads + 1), result->head.ttl);
> > > > > 
> > > > > Is this correct? Won't this set notfound to false rather than
> > > > > result->head.notfound?
> > > > 
> > > > Ahh yes.  Fixed.
> > > > 
> > > > Here's an updated version now.  I haven't posted the ChangeLog since
> > > > it is unchanged.
> > > > 
> > > > Thanks,
> > > > Siddhesh
> > > > 
looks ok.
diff mbox

Patch

diff --git a/nscd/aicache.c b/nscd/aicache.c
index 98d40a1..d7966bd 100644
--- a/nscd/aicache.c
+++ b/nscd/aicache.c
@@ -383,17 +383,12 @@  addhstaiX (struct database_dyn *db, int fd, request_header *req,
 	  cp = family;
 	}
 
-      /* Fill in the rest of the dataset.  */
-      dataset->head.allocsize = total + req->key_len;
-      dataset->head.recsize = total - offsetof (struct dataset, resp);
-      dataset->head.notfound = false;
-      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-      dataset->head.usable = true;
-
-      /* Compute the timeout time.  */
-      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
-      timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
+      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
+				   total - offsetof (struct dataset, resp),
+				   he == NULL ? 0 : dh->nreloads + 1,
+				   ttl == INT32_MAX ? db->postimeout : ttl);
 
+      /* Fill in the rest of the dataset.  */
       dataset->resp.version = NSCD_VERSION;
       dataset->resp.found = 1;
       dataset->resp.naddrs = naddrs;
@@ -528,15 +523,9 @@  next_nip:
       else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
 					      + req->key_len), 1)) != NULL)
 	{
-	  dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
-	  dataset->head.recsize = total;
-	  dataset->head.notfound = true;
-	  dataset->head.nreloads = 0;
-	  dataset->head.usable = true;
-
-	  /* Compute the timeout time.  */
-	  timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
-	  dataset->head.ttl = db->negtimeout;
+	  timeout = datahead_init_neg (&dataset->head,
+				       sizeof (struct dataset) + req->key_len,
+				       total, db->negtimeout);
 
 	  /* This is the reply.  */
 	  memcpy (&dataset->resp, &notfound, total);
diff --git a/nscd/grpcache.c b/nscd/grpcache.c
index b5a33eb..df59fa7 100644
--- a/nscd/grpcache.c
+++ b/nscd/grpcache.c
@@ -128,14 +128,10 @@  cache_addgr (struct database_dyn *db, int fd, request_header *req,
 	    }
 	  else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
 	    {
-	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
-	      dataset->head.recsize = total;
-	      dataset->head.notfound = true;
-	      dataset->head.nreloads = 0;
-	      dataset->head.usable = true;
-
-	      /* Compute the timeout time.  */
-	      timeout = dataset->head.timeout = t + db->negtimeout;
+	      timeout = datahead_init_neg (&dataset->head,
+					   (sizeof (struct dataset)
+					    + req->key_len), total,
+					   db->negtimeout);
 
 	      /* This is the reply.  */
 	      memcpy (&dataset->resp, &notfound, total);
@@ -232,14 +228,10 @@  cache_addgr (struct database_dyn *db, int fd, request_header *req,
 	  dataset_temporary = true;
 	}
 
-      dataset->head.allocsize = total + n;
-      dataset->head.recsize = total - offsetof (struct dataset, resp);
-      dataset->head.notfound = false;
-      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-      dataset->head.usable = true;
-
-      /* Compute the timeout time.  */
-      timeout = dataset->head.timeout = t + db->postimeout;
+      timeout = datahead_init_pos (&dataset->head, total + n,
+				   total - offsetof (struct dataset, resp),
+				   he == NULL ? 0 : dh->nreloads + 1,
+				   db->postimeout);
 
       dataset->resp.version = NSCD_VERSION;
       dataset->resp.found = 1;
diff --git a/nscd/hstcache.c b/nscd/hstcache.c
index a79b67a..d4f1ad2 100644
--- a/nscd/hstcache.c
+++ b/nscd/hstcache.c
@@ -152,15 +152,11 @@  cache_addhst (struct database_dyn *db, int fd, request_header *req,
 	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
 						  + req->key_len), 1)) != NULL)
 	    {
-	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
-	      dataset->head.recsize = total;
-	      dataset->head.notfound = true;
-	      dataset->head.nreloads = 0;
-	      dataset->head.usable = true;
-
-	      /* Compute the timeout time.  */
-	      dataset->head.ttl = ttl == INT32_MAX ? db->negtimeout : ttl;
-	      timeout = dataset->head.timeout = t + dataset->head.ttl;
+	      timeout = datahead_init_neg (&dataset->head,
+					   (sizeof (struct dataset)
+					    + req->key_len), total,
+					   (ttl == INT32_MAX
+					    ? db->negtimeout : ttl));
 
 	      /* This is the reply.  */
 	      memcpy (&dataset->resp, resp, total);
@@ -257,15 +253,10 @@  cache_addhst (struct database_dyn *db, int fd, request_header *req,
 	  alloca_used = true;
 	}
 
-      dataset->head.allocsize = total + req->key_len;
-      dataset->head.recsize = total - offsetof (struct dataset, resp);
-      dataset->head.notfound = false;
-      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-      dataset->head.usable = true;
-
-      /* Compute the timeout time.  */
-      dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
-      timeout = dataset->head.timeout = t + dataset->head.ttl;
+      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
+				   total - offsetof (struct dataset, resp),
+				   he == NULL ? 0 : dh->nreloads + 1,
+				   ttl == INT32_MAX ? db->postimeout : ttl);
 
       dataset->resp.version = NSCD_VERSION;
       dataset->resp.found = 1;
diff --git a/nscd/initgrcache.c b/nscd/initgrcache.c
index 1bf9f0d..361319f 100644
--- a/nscd/initgrcache.c
+++ b/nscd/initgrcache.c
@@ -213,14 +213,10 @@  addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
 	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
 						  + req->key_len), 1)) != NULL)
 	    {
-	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
-	      dataset->head.recsize = total;
-	      dataset->head.notfound = true;
-	      dataset->head.nreloads = 0;
-	      dataset->head.usable = true;
-
-	      /* Compute the timeout time.  */
-	      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
+	      timeout = datahead_init_neg (&dataset->head,
+					   (sizeof (struct dataset)
+					    + req->key_len), total,
+					   db->negtimeout);
 
 	      /* This is the reply.  */
 	      memcpy (&dataset->resp, &notfound, total);
@@ -276,14 +272,10 @@  addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
 	  alloca_used = true;
 	}
 
-      dataset->head.allocsize = total + req->key_len;
-      dataset->head.recsize = total - offsetof (struct dataset, resp);
-      dataset->head.notfound = false;
-      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-      dataset->head.usable = true;
-
-      /* Compute the timeout time.  */
-      timeout = dataset->head.timeout = time (NULL) + db->postimeout;
+      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
+				   total - offsetof (struct dataset, resp),
+				   he == NULL ? 0 : dh->nreloads + 1,
+				   db->postimeout);
 
       dataset->resp.version = NSCD_VERSION;
       dataset->resp.found = 1;
diff --git a/nscd/netgroupcache.c b/nscd/netgroupcache.c
index 820d823..b3d40e9 100644
--- a/nscd/netgroupcache.c
+++ b/nscd/netgroupcache.c
@@ -90,15 +90,9 @@  do_notfound (struct database_dyn *db, int fd, request_header *req,
   /* If we cannot permanently store the result, so be it.  */
   if (dataset != NULL)
     {
-      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
-      dataset->head.recsize = total;
-      dataset->head.notfound = true;
-      dataset->head.nreloads = 0;
-      dataset->head.usable = true;
-
-      /* Compute the timeout time.  */
-      timeout = dataset->head.timeout = time (NULL) + db->negtimeout;
-      dataset->head.ttl = db->negtimeout;
+      timeout = datahead_init_neg (&dataset->head,
+				   sizeof (struct dataset) + req->key_len,
+				   total, db->negtimeout);
 
       /* This is the reply.  */
       memcpy (&dataset->resp, &notfound, total);
@@ -359,13 +353,10 @@  addgetnetgrentX (struct database_dyn *db, int fd, request_header *req,
 
   /* Fill in the dataset.  */
   dataset = (struct dataset *) buffer;
-  dataset->head.allocsize = total + req->key_len;
-  dataset->head.recsize = total - offsetof (struct dataset, resp);
-  dataset->head.notfound = false;
-  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-  dataset->head.usable = true;
-  dataset->head.ttl = db->postimeout;
-  timeout = dataset->head.timeout = time (NULL) + dataset->head.ttl;
+  timeout = datahead_init_pos (&dataset->head, total + req->key_len,
+			       total - offsetof (struct dataset, resp),
+			       he == NULL ? 0 : dh->nreloads + 1,
+			       db->postimeout);
 
   dataset->resp.version = NSCD_VERSION;
   dataset->resp.found = 1;
@@ -541,12 +532,12 @@  addinnetgrX (struct database_dyn *db, int fd, request_header *req,
       dataset = &dataset_mem;
     }
 
-  dataset->head.allocsize = sizeof (*dataset) + req->key_len;
-  dataset->head.recsize = sizeof (innetgroup_response_header);
+  datahead_init_pos (&dataset->head, sizeof (*dataset) + req->key_len,
+		     sizeof (innetgroup_response_header),
+		     he == NULL ? 0 : dh->nreloads + 1, result->head.ttl);
+  /* Set the notfound status and timeout based on the result from
+     getnetgrent.  */
   dataset->head.notfound = result->head.notfound;
-  dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-  dataset->head.usable = true;
-  dataset->head.ttl = result->head.ttl;
   dataset->head.timeout = timeout;
 
   dataset->resp.version = NSCD_VERSION;
diff --git a/nscd/nscd-client.h b/nscd/nscd-client.h
index 98f77e7..c069bf6 100644
--- a/nscd/nscd-client.h
+++ b/nscd/nscd-client.h
@@ -236,6 +236,36 @@  struct datahead
   } data[0];
 };
 
+static inline time_t
+datahead_init_common (struct datahead *head, nscd_ssize_t allocsize,
+		      nscd_ssize_t recsize, uint32_t ttl)
+{
+  head->allocsize = allocsize;
+  head->recsize = recsize;
+  head->usable = true;
+
+  head->ttl = ttl;
+  /* Compute the timeout time.  */
+  return head->timeout = time (NULL) + ttl;
+}
+
+static inline time_t
+datahead_init_pos (struct datahead *head, nscd_ssize_t allocsize,
+		   nscd_ssize_t recsize, uint8_t nreloads, uint32_t ttl)
+{
+  head->notfound = false;
+  head->nreloads = nreloads;
+  return datahead_init_common (head, allocsize, recsize, ttl);
+}
+
+static inline time_t
+datahead_init_neg (struct datahead *head, nscd_ssize_t allocsize,
+		   nscd_ssize_t recsize, uint32_t ttl)
+{
+  head->notfound = true;
+  head->nreloads = 0;
+  return datahead_init_common (head, allocsize, recsize, ttl);
+}
 
 /* Structure for one hash table entry.  */
 struct hashentry
diff --git a/nscd/pwdcache.c b/nscd/pwdcache.c
index fa355c3..41c245b 100644
--- a/nscd/pwdcache.c
+++ b/nscd/pwdcache.c
@@ -135,14 +135,10 @@  cache_addpw (struct database_dyn *db, int fd, request_header *req,
 	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
 						  + req->key_len), 1)) != NULL)
 	    {
-	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
-	      dataset->head.recsize = total;
-	      dataset->head.notfound = true;
-	      dataset->head.nreloads = 0;
-	      dataset->head.usable = true;
-
-	      /* Compute the timeout time.  */
-	      timeout = dataset->head.timeout = t + db->negtimeout;
+	      timeout = datahead_init_neg (&dataset->head,
+					   (sizeof (struct dataset)
+					    + req->key_len), total,
+					   db->negtimeout);
 
 	      /* This is the reply.  */
 	      memcpy (&dataset->resp, &notfound, total);
@@ -215,14 +211,10 @@  cache_addpw (struct database_dyn *db, int fd, request_header *req,
 	  alloca_used = true;
 	}
 
-      dataset->head.allocsize = total + n;
-      dataset->head.recsize = total - offsetof (struct dataset, resp);
-      dataset->head.notfound = false;
-      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-      dataset->head.usable = true;
-
-      /* Compute the timeout time.  */
-      timeout = dataset->head.timeout = t + db->postimeout;
+      timeout = datahead_init_pos (&dataset->head, total + n,
+				   total - offsetof (struct dataset, resp),
+				   he == NULL ? 0 : dh->nreloads + 1,
+				   db->postimeout);
 
       dataset->resp.version = NSCD_VERSION;
       dataset->resp.found = 1;
diff --git a/nscd/servicescache.c b/nscd/servicescache.c
index 12ce9b2..95bdcfe 100644
--- a/nscd/servicescache.c
+++ b/nscd/servicescache.c
@@ -120,14 +120,10 @@  cache_addserv (struct database_dyn *db, int fd, request_header *req,
 	  else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
 						  + req->key_len), 1)) != NULL)
 	    {
-	      dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
-	      dataset->head.recsize = total;
-	      dataset->head.notfound = true;
-	      dataset->head.nreloads = 0;
-	      dataset->head.usable = true;
-
-	      /* Compute the timeout time.  */
-	      timeout = dataset->head.timeout = t + db->negtimeout;
+	      timeout = datahead_init_neg (&dataset->head,
+					   (sizeof (struct dataset)
+					    + req->key_len), total,
+					   db->negtimeout);
 
 	      /* This is the reply.  */
 	      memcpy (&dataset->resp, &notfound, total);
@@ -207,14 +203,10 @@  cache_addserv (struct database_dyn *db, int fd, request_header *req,
 	  alloca_used = true;
 	}
 
-      dataset->head.allocsize = total + req->key_len;
-      dataset->head.recsize = total - offsetof (struct dataset, resp);
-      dataset->head.notfound = false;
-      dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
-      dataset->head.usable = true;
-
-      /* Compute the timeout time.  */
-      timeout = dataset->head.timeout = t + db->postimeout;
+      timeout = datahead_init_pos (&dataset->head, total + req->key_len,
+				   total - offsetof (struct dataset, resp),
+				   he == NULL ? 0 : dh->nreloads + 1,
+				   db->postimeout);
 
       dataset->resp.version = NSCD_VERSION;
       dataset->resp.found = 1;