← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/functions/lock.cc

Merged Nathan from lp:~nlws/drizzle/fix-string-c-ptr-overrun

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/functions/lock.cc
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#include <drizzled/server_includes.h>
21
 
#include CSTDINT_H
22
 
#include <drizzled/functions/lock.h>
23
 
#include <mysys/hash.h>
24
 
#include <drizzled/session.h>
25
 
 
26
 
/*
27
 
** User level locks
28
 
*/
29
 
 
30
 
pthread_mutex_t LOCK_user_locks;
31
 
static HASH hash_user_locks;
32
 
 
33
 
class User_level_lock
34
 
{
35
 
  unsigned char *key;
36
 
  size_t key_length;
37
 
 
38
 
public:
39
 
  int count;
40
 
  bool locked;
41
 
  pthread_cond_t cond;
42
 
  my_thread_id thread_id;
43
 
  void set_thread(Session *session) { thread_id= session->thread_id; }
44
 
 
45
 
  User_level_lock(const unsigned char *key_arg,uint32_t length, ulong id)
46
 
    :key_length(length),count(1),locked(1), thread_id(id)
47
 
  {
48
 
    key= (unsigned char*) my_memdup(key_arg,length,MYF(0));
49
 
    pthread_cond_init(&cond,NULL);
50
 
    if (key)
51
 
    {
52
 
      if (my_hash_insert(&hash_user_locks,(unsigned char*) this))
53
 
      {
54
 
        free(key);
55
 
        key=0;
56
 
      }
57
 
    }
58
 
  }
59
 
  ~User_level_lock()
60
 
  {
61
 
    if (key)
62
 
    {
63
 
      hash_delete(&hash_user_locks,(unsigned char*) this);
64
 
      free(key);
65
 
    }
66
 
    pthread_cond_destroy(&cond);
67
 
  }
68
 
  inline bool initialized() { return key != 0; }
69
 
 
70
 
  friend void item_user_lock_release(User_level_lock *ull);
71
 
  friend unsigned char *ull_get_key(const User_level_lock *ull, size_t *length,
72
 
                            bool not_used);
73
 
};
74
 
 
75
 
unsigned char *ull_get_key(const User_level_lock *ull, size_t *length,
76
 
                   bool not_used __attribute__((unused)))
77
 
{
78
 
  *length= ull->key_length;
79
 
  return ull->key;
80
 
}
81
 
 
82
 
 
83
 
void item_user_lock_release(User_level_lock *ull)
84
 
{
85
 
  ull->locked=0;
86
 
  ull->thread_id= 0;
87
 
  if (--ull->count)
88
 
    pthread_cond_signal(&ull->cond);
89
 
  else
90
 
    delete ull;
91
 
}
92
 
 
93
 
 
94
 
 
95
 
/**
96
 
  Check a user level lock.
97
 
 
98
 
  Sets null_value=true on error.
99
 
 
100
 
  @retval
101
 
    1           Available
102
 
  @retval
103
 
    0           Already taken, or error
104
 
*/
105
 
 
106
 
int64_t Item_func_is_free_lock::val_int()
107
 
{
108
 
  assert(fixed == 1);
109
 
  String *res=args[0]->val_str(&value);
110
 
  User_level_lock *ull;
111
 
 
112
 
  null_value=0;
113
 
  if (!res || !res->length())
114
 
  {
115
 
    null_value=1;
116
 
    return 0;
117
 
  }
118
 
 
119
 
  pthread_mutex_lock(&LOCK_user_locks);
120
 
  ull= (User_level_lock *) hash_search(&hash_user_locks, (unsigned char*) res->ptr(),
121
 
                                       (size_t) res->length());
122
 
  pthread_mutex_unlock(&LOCK_user_locks);
123
 
  if (!ull || !ull->locked)
124
 
    return 1;
125
 
  return 0;
126
 
}
127
 
 
128
 
int64_t Item_func_is_used_lock::val_int()
129
 
{
130
 
  assert(fixed == 1);
131
 
  String *res=args[0]->val_str(&value);
132
 
  User_level_lock *ull;
133
 
 
134
 
  null_value=1;
135
 
  if (!res || !res->length())
136
 
    return 0;
137
 
 
138
 
  pthread_mutex_lock(&LOCK_user_locks);
139
 
  ull= (User_level_lock *) hash_search(&hash_user_locks, (unsigned char*) res->ptr(),
140
 
                                       (size_t) res->length());
141
 
  pthread_mutex_unlock(&LOCK_user_locks);
142
 
  if (!ull || !ull->locked)
143
 
    return 0;
144
 
 
145
 
  null_value=0;
146
 
  return ull->thread_id;
147
 
}
148
 
 
149