← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/sync/sync0rw.c

Merge initial InnoDB+ import.

This was applied by generating a patch between MySQL 5.1.50 InnoDB plugin and
the just-merged innodb+ from mysql-trunk revision-id: vasil.dimov@oracle.com-20100422110752-1zowoqxel5xx3z2e

Then, some manual merge resolving and it worked. This should make it much
easier to merge the rest of InnoDB 1.1 and 1.2 from the mysql tree using
my bzr-reapply script.

This takes us to InnoDB 1.1.1(ish).

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/sync/sync0rw.c
168
168
UNIV_INTERN rw_lock_list_t      rw_lock_list;
169
169
UNIV_INTERN mutex_t             rw_lock_list_mutex;
170
170
 
 
171
#ifdef UNIV_PFS_MUTEX
 
172
UNIV_INTERN mysql_pfs_key_t     rw_lock_list_mutex_key;
 
173
UNIV_INTERN mysql_pfs_key_t     rw_lock_mutex_key;
 
174
#endif /* UNIV_PFS_MUTEX */
 
175
 
171
176
#ifdef UNIV_SYNC_DEBUG
172
177
/* The global mutex which protects debug info lists of all rw-locks.
173
178
To modify the debug info list of an rw-lock, this mutex has to be
174
179
acquired in addition to the mutex protecting the lock. */
175
180
 
176
181
UNIV_INTERN mutex_t             rw_lock_debug_mutex;
 
182
 
 
183
# ifdef UNIV_PFS_MUTEX
 
184
UNIV_INTERN mysql_pfs_key_t     rw_lock_debug_mutex_key;
 
185
# endif
 
186
 
177
187
/* If deadlock detection does not get immediately the mutex,
178
188
it may wait for this event */
179
189
UNIV_INTERN os_event_t          rw_lock_debug_event;
231
241
# ifdef UNIV_SYNC_DEBUG
232
242
        ulint           level,          /*!< in: level */
233
243
# endif /* UNIV_SYNC_DEBUG */
234
 
        const char*     cmutex_name,    /*!< in: mutex name */
 
244
        const char*     cmutex_name,    /*!< in: mutex name */
235
245
#endif /* UNIV_DEBUG */
236
246
        const char*     cfile_name,     /*!< in: file name where created */
237
247
        ulint           cline)          /*!< in: file line where created */
240
250
        created, then the following call initializes the sync system. */
241
251
 
242
252
#ifndef INNODB_RW_LOCKS_USE_ATOMICS
243
 
        mutex_create(rw_lock_get_mutex(lock), SYNC_NO_ORDER_CHECK);
 
253
        mutex_create(rw_lock_mutex_key, rw_lock_get_mutex(lock),
 
254
                     SYNC_NO_ORDER_CHECK);
244
255
 
245
256
        lock->mutex.cfile_name = cfile_name;
246
257
        lock->mutex.cline = cline;
267
278
        lock->level = level;
268
279
#endif /* UNIV_SYNC_DEBUG */
269
280
 
270
 
        ut_d(lock->magic_n = RW_LOCK_MAGIC_N);
 
281
        lock->magic_n = RW_LOCK_MAGIC_N;
271
282
 
272
283
        lock->cfile_name = cfile_name;
273
284
        lock->cline = (unsigned int) cline;
282
293
 
283
294
        mutex_enter(&rw_lock_list_mutex);
284
295
 
285
 
        ut_ad(UT_LIST_GET_FIRST(rw_lock_list) == NULL
286
 
              || UT_LIST_GET_FIRST(rw_lock_list)->magic_n == RW_LOCK_MAGIC_N);
 
296
        if (UT_LIST_GET_LEN(rw_lock_list) > 0) {
 
297
                ut_a(UT_LIST_GET_FIRST(rw_lock_list)->magic_n
 
298
                     == RW_LOCK_MAGIC_N);
 
299
        }
287
300
 
288
301
        UT_LIST_ADD_FIRST(list, rw_lock_list, lock);
289
302
 
296
309
rw-lock is checked to be in the non-locked state. */
297
310
UNIV_INTERN
298
311
void
299
 
rw_lock_free(
300
 
/*=========*/
 
312
rw_lock_free_func(
 
313
/*==============*/
301
314
        rw_lock_t*      lock)   /*!< in: rw-lock */
302
315
{
303
316
        ut_ad(rw_lock_validate(lock));
304
317
        ut_a(lock->lock_word == X_LOCK_DECR);
305
318
 
 
319
        lock->magic_n = 0;
 
320
 
306
321
#ifndef INNODB_RW_LOCKS_USE_ATOMICS
307
322
        mutex_free(rw_lock_get_mutex(lock));
308
323
#endif /* INNODB_RW_LOCKS_USE_ATOMICS */
312
327
 
313
328
        os_event_free(lock->wait_ex_event);
314
329
 
315
 
        ut_ad(UT_LIST_GET_PREV(list, lock) == NULL
316
 
              || UT_LIST_GET_PREV(list, lock)->magic_n == RW_LOCK_MAGIC_N);
317
 
        ut_ad(UT_LIST_GET_NEXT(list, lock) == NULL
318
 
              || UT_LIST_GET_NEXT(list, lock)->magic_n == RW_LOCK_MAGIC_N);
 
330
        if (UT_LIST_GET_PREV(list, lock)) {
 
331
                ut_a(UT_LIST_GET_PREV(list, lock)->magic_n == RW_LOCK_MAGIC_N);
 
332
        }
 
333
        if (UT_LIST_GET_NEXT(list, lock)) {
 
334
                ut_a(UT_LIST_GET_NEXT(list, lock)->magic_n == RW_LOCK_MAGIC_N);
 
335
        }
319
336
 
320
337
        UT_LIST_REMOVE(list, rw_lock_list, lock);
321
338
 
322
339
        mutex_exit(&rw_lock_list_mutex);
323
 
 
324
 
        ut_d(lock->magic_n = 0);
325
340
}
326
341
 
327
342
#ifdef UNIV_DEBUG
340
355
        ulint waiters = rw_lock_get_waiters(lock);
341
356
        lint lock_word = lock->lock_word;
342
357
 
343
 
        ut_ad(lock->magic_n == RW_LOCK_MAGIC_N);
 
358
        ut_a(lock->magic_n == RW_LOCK_MAGIC_N);
344
359
        ut_a(waiters == 0 || waiters == 1);
345
360
        ut_a(lock_word > -X_LOCK_DECR ||(-lock_word) % X_LOCK_DECR == 0);
346
361
 
603
618
{
604
619
        ulint   index;  /*!< index of the reserved wait cell */
605
620
        ulint   i;      /*!< spin round count */
606
 
        ibool   spinning = FALSE;
 
621
        ibool   spinning = FALSE;
607
622
 
608
623
        ut_ad(rw_lock_validate(lock));
609
624