Category

Development Platform
Home > SourceCode/Document > Database system > MySQL > View Code
fwalk.c
Package: mysql-3.23.35.tar.gz　[view]
Upload User: tsgydb
Upload Date: 2007-04-14
Package Size: 10674k
Code Size: 5k
Category:

MySQL

Development Platform:

Visual C++

fwalk.c：Code Content
  1. /*-
  2.  * Copyright (c) 1990 The Regents of the University of California.
  3.  * Copyright (c) 1993, 1994 Chris Provenzano. 
  4.  * All rights reserved.
  5.  *
  6.  * This code is derived from software contributed to Berkeley by
  7.  * Chris Torek.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, are permitted provided that the following conditions
  11.  * are met:
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in the
  16.  *    documentation and/or other materials provided with the distribution.
  17.  * 3. All advertising materials mentioning features or use of this software
  18.  *    must display the following acknowledgement:
  19.  * This product includes software developed by the University of
  20.  * California, Berkeley and its contributors.
  21.  * 4. Neither the name of the University nor the names of its contributors
  22.  *    may be used to endorse or promote products derived from this software
  23.  *    without specific prior written permission.
  24.  *
  25.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35.  * SUCH DAMAGE.
  36.  */
  38. #if defined(LIBC_SCCS) && !defined(lint)
  39. /*static char *sccsid = "from: @(#)fwalk.c 5.2 (Berkeley) 2/24/91";*/
  40. static char *rcsid = "$Id$";
  41. #endif /* LIBC_SCCS and not lint */
  43. #include <pthread.h>
  44. #include <errno.h>
  45. #include <stdio.h>
  46. #include "local.h"
  47. #include "glue.h"
  49. extern pthread_mutex_t __sfp_mutex;
  50. extern pthread_cond_t __sfp_cond;
  51. extern int __sfp_state;
  53. /*
  54.  * fwalk now can only be used for flushing the buffers.
  55.  * This is all it was originally used for.
  56.  * The function has also become much more complicated.
  57.  * The first time through we flush everything we can.
  58.  * If this fails to flush everything because we couldn't get a lock
  59.  * we wait on the locksfor the second pass. Why this works ...
  60.  * 
  61.  * This function must allow for multiple threads to flush everything.
  62.  * This function cannot flush buffers locked by another thread.
  63.  * So we flush everything we can the first pass. This includes all
  64.  * buffers locked by this thread, and wait on buffers that are locked.
  65.  * Eventually other threads willl unlock there buffers or flush them themselves
  66.  * at which point this thread will notice that it's empty or be able to
  67.  * flush the buffer. This is fine so long as no other thread tries to flush
  68.  * all buffers. Here is the possible deadlock condition, but since this thread
  69.  * has flushed all buffers it can, there are NO buffers locked by this thread
  70.  * that need flushing so any other thread flushing won't block waiting on this
  71.  * thread thereby eliminating the deadlock condition.
  72.  */
  74. int __swalk_sflush()
  75. {
  76. register FILE *fp, *savefp;
  77. register int n, ret, saven;
  78. register struct glue *g, *saveg;
  80. /* Only allow other threads to read __sglue */
  81. pthread_mutex_lock(&__sfp_mutex);
  82. __sfp_state++;
  83. pthread_mutex_unlock(&__sfp_mutex);
  85. ret = 0;
  86. saven = 0;
  87. saveg = NULL;
  88. savefp = NULL;
  89. for (g = &__sglue; g != NULL; g = g->next) {
  90. for (fp = g->iobs, n = g->niobs; --n >= 0; fp++) {
  91. if (fp->_flags != 0) {
  92. /* Is there anything to flush? */
  93. if (fp->_bf._base && (fp->_bf._base - fp->_p)) {
  94. if (ftrylockfile(fp)) { /* Can we flush it */
  95. if (!saven) { /* No, save first fp we can't flush */
  96. saven = n;
  97. saveg = g;
  98. savefp = fp;
  99. continue;
  100. }
  101. } else {
  102. ret |= __sflush(fp);
  103. funlockfile(fp);
  104. }
  105. }
  106. }
  107. }
  108. }
  109. if (savefp) {
  110. for (g = saveg; g != NULL; g = g->next) {
  111. for (fp = savefp, n = saven + 1; --n >= 0; fp++) {
  112. if (fp->_flags != 0) {
  113.   /* Anything to flush */
  114. while (fp->_bf._base && (fp->_bf._base - fp->_p)) {
  115. flockfile(fp);
  116. ret |= __sflush(fp);
  117. funlockfile(fp);
  118. }
  119. }
  120. }
  121. }
  122. }
  124. /* If no other readers wakeup a thread waiting to do __sfp */
  125. pthread_mutex_lock(&__sfp_mutex);
  126. if (! (--__sfp_state)) {
  127. pthread_cond_signal(&__sfp_cond);
  128. }
  129. pthread_mutex_unlock(&__sfp_mutex);
  130. return (ret);
  131. }