← Back to branch summary

~jbingham-gmail/libmemcached/embedded-ct

« back to all changes in this revision

Viewing changes to libmemcached/internal_server.c

  • Committer: Jeremy Bingham
  • Date: 2010-02-13 13:43:30 UTC
  • Revision ID: jbingham@gmail.com-20100213134330-znpi6vjbmfnyq09p
Most compiler errors out of the way.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmemcached/internal_server.c
51
51
    instance= ptr->call_calloc(ptr, 1, sizeof(internal_server_state_st)); 
52
52
    libmemcached_shm_init(ptr, ((sizeof(bucket) * INTMC_BUCKET_NUM)) + (sizeof(char) * HASH_LIST_SIZE));
53
53
    bucket *blist;
54
 
    blist = (bucket *)(ptr->shm_area->shm);
 
54
    bucket *listtmp;
55
55
    /* OK, I think that should have done it. Theoretically, we have a shared
56
56
     * bucket list */
57
57
 
58
58
    if (instance == NULL)
59
59
      return NULL;
60
 
    instance->list = (bucket *)ptr->shm_area->shm;
61
 
    blist = (bucket *)(ptr->shm_area->shm + (sizeof(char) * HASH_LIST_SIZE));
 
60
    listtmp = (bucket *)(ptr->shm_area->shm);
 
61
    /* blist = (bucket *)(ptr->shm_area->shm + (sizeof(char) * HASH_LIST_SIZE)); */
 
62
    blist = (bucket *)((bucket *)ptr->shm_area->shm + (sizeof(char) * HASH_LIST_SIZE));
 
63
    /* blist = (listtmp + (sizeof(char) * HASH_LIST_SIZE)); */
62
64
    instance->holding = &blist;
 
65
    instance->list = &listtmp;
63
66
    ptr->hosts[0].embedded_server= instance;
64
67
  }
65
68
  else
149
152
 
150
153
  assert(hash_key < HASH_LIST_SIZE);
151
154
 
152
 
  for (ptr= (instance->list + hash_key); ptr; ptr= ptr->next)
 
155
  for (ptr= *(instance->list + hash_key); ptr; ptr= ptr->next)
153
156
  {
154
157
    if (key_length ==  ptr->key_length && (memcmp(ptr->key, key, key_length) == 0))
155
158
      return ptr;
165
168
  bucket *ptr;
166
169
  bucket *prev;
167
170
 
168
 
  ptr= (instance->list + hash_key);
 
171
  ptr= *(instance->list + hash_key);
169
172
 
170
173
  if (ptr == NULL)
171
174
    return false;
 
175
  if (memc == NULL){ ; }
172
176
 
173
177
  if (key_length ==  ptr->key_length && memcmp(ptr->key, key, key_length) == 0)
174
178
  {
175
 
    (instance->list + hash_key) = ptr->next;
 
179
    *(instance->list + hash_key) = ptr->next;
176
180
 
177
181
    /* NEED: Semaphore, figure out best way to clear the buckets. */
178
182
    /* memc->call_free(memc, ptr->value);
206
210
  uint32_t hash_key= crap_hash(key, key_length);
207
211
  bucket *new_bucket;
208
212
  bucket *ptr;
 
213
  bucket *arrgh;
209
214
 
210
215
  /* new_bucket= memc->call_calloc(memc, 1, sizeof(bucket)); */
211
216
  if (memc == NULL) {
213
218
        }
214
219
  int i;
215
220
  for (i = 0; i < INTMC_BUCKET_NUM; i++){
216
 
        if (instance->(holding + i)->in_use)
217
 
                next;
218
 
        new_bucket = (instance->holding + i);
 
221
        arrgh = *(instance->holding + i);
 
222
        if (arrgh->in_use)
 
223
                continue;
 
224
        new_bucket = *(instance->holding + i);
219
225
        break;  
220
226
        }
221
227
  if (new_bucket == NULL)
222
228
    return NULL;
223
229
 
224
 
  ptr= (instance->list + hash_key);
 
230
  ptr= *(instance->list + hash_key);
225
231
 
226
232
  if (ptr == NULL)
227
233
  {
228
 
    (instance->list + hash_key) = new_bucket;
 
234
    *(instance->list + hash_key) = new_bucket;
229
235
 
230
236
    return new_bucket;
231
237
  }
498
504
    return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
499
505
 
500
506
  for (x= 0; x < HASH_LIST_SIZE; x++)
501
 
    delete_buckets(ptr, (instance->list + x));
 
507
    delete_buckets(ptr, *(instance->list + x));
502
508
  /* This strikes me as something that might be unpredictable. */
503
509
  /* memset(instance->list, 0, sizeof(bucket *) * HASH_LIST_SIZE); */
504
510
 
677
683
      /* This is the last reference to the cache, nuke it! */
678
684
      for (int x= 0; x < HASH_LIST_SIZE; x++)
679
685
      {
680
 
         bucket *ptr= (embedded->list + x);
 
686
         bucket *ptr= *(embedded->list + x);
681
687
 
682
688
         while (ptr) {
683
689
            bucket *tmp= ptr;