← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/my_lock.c

  • Committer: Monty Taylor
  • Date: 2008-07-05 18:10:38 UTC
  • mto: This revision was merged to the branch mainline in revision 63.
  • Revision ID: monty@inaugust.com-20080705181038-0ih0nnamu5qrut0y
Fixed prototypes. Cleaned define a little bit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/my_lock.c
 
1
/* Copyright (C) 2000-2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#include "mysys_priv.h"
 
17
#include "mysys_err.h"
 
18
#include <errno.h>
 
19
#undef MY_HOW_OFTEN_TO_ALARM
 
20
#define MY_HOW_OFTEN_TO_ALARM ((int) my_time_to_wait_for_lock)
 
21
#ifdef NO_ALARM_LOOP
 
22
#undef NO_ALARM_LOOP
 
23
#endif
 
24
#include <my_alarm.h>
 
25
 
 
26
 
 
27
/*
 
28
  Lock a part of a file
 
29
 
 
30
  RETURN VALUE
 
31
    0   Success
 
32
    -1  An error has occured and 'my_errno' is set
 
33
        to indicate the actual error code.
 
34
*/
 
35
 
 
36
int my_lock(File fd, int locktype, my_off_t start, my_off_t length,
 
37
            myf MyFlags)
 
38
{
 
39
  int value;
 
40
  long alarm_pos=0,alarm_end_pos=MY_HOW_OFTEN_TO_WRITE-1;
 
41
 
 
42
  DBUG_ENTER("my_lock");
 
43
  DBUG_PRINT("my",("Fd: %d  Op: %d  start: %ld  Length: %ld  MyFlags: %d",
 
44
                   fd,locktype,(long) start,(long) length,MyFlags));
 
45
  if (my_disable_locking)
 
46
    DBUG_RETURN(0);
 
47
 
 
48
#if defined(HAVE_FCNTL)
 
49
  {
 
50
    struct flock lock;
 
51
 
 
52
    lock.l_type=   (short) locktype;
 
53
    lock.l_whence= SEEK_SET;
 
54
    lock.l_start=  (off_t) start;
 
55
    lock.l_len=    (off_t) length;
 
56
 
 
57
    if (MyFlags & MY_DONT_WAIT)
 
58
    {
 
59
      if (fcntl(fd,F_SETLK,&lock) != -1)        /* Check if we can lock */
 
60
        DBUG_RETURN(0);                 /* Ok, file locked */
 
61
      DBUG_PRINT("info",("Was locked, trying with alarm"));
 
62
      while ((value=fcntl(fd,F_SETLKW,&lock)) && !  (alarm_pos++ >= alarm_end_pos) &&
 
63
             errno == EINTR)
 
64
      {                 /* Setup again so we don`t miss it */
 
65
        alarm_end_pos+=MY_HOW_OFTEN_TO_WRITE;
 
66
      }
 
67
      if (value != -1)
 
68
        DBUG_RETURN(0);
 
69
      if (errno == EINTR)
 
70
        errno=EAGAIN;
 
71
    }
 
72
    else if (fcntl(fd,F_SETLKW,&lock) != -1) /* Wait until a lock */
 
73
      DBUG_RETURN(0);
 
74
  }
 
75
#else
 
76
  if (MyFlags & MY_SEEK_NOT_DONE)
 
77
  {
 
78
    if (my_seek(fd,start,MY_SEEK_SET,MYF(MyFlags & ~MY_SEEK_NOT_DONE))
 
79
        == MY_FILEPOS_ERROR)
 
80
    {
 
81
      /*
 
82
        If an error has occured in my_seek then we will already
 
83
        have an error code in my_errno; Just return error code.
 
84
      */
 
85
      DBUG_RETURN(-1);
 
86
    }
 
87
  }
 
88
  if (lockf(fd,locktype,length) != -1)
 
89
    DBUG_RETURN(0);
 
90
#endif /* HAVE_FCNTL */
 
91
 
 
92
        /* We got an error. We don't want EACCES errors */
 
93
  my_errno=(errno == EACCES) ? EAGAIN : errno ? errno : -1;
 
94
  if (MyFlags & MY_WME)
 
95
  {
 
96
    if (locktype == F_UNLCK)
 
97
      my_error(EE_CANTUNLOCK,MYF(ME_BELL+ME_WAITTANG),my_errno);
 
98
    else
 
99
      my_error(EE_CANTLOCK,MYF(ME_BELL+ME_WAITTANG),my_errno);
 
100
  }
 
101
  DBUG_PRINT("error",("my_errno: %d (%d)",my_errno,errno));
 
102
  DBUG_RETURN(-1);
 
103
} /* my_lock */