src/sqllog/FileSend.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.com   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   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                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #include <os.h>
  21 #include <SqlLogConnection.h>
  22 #include <CSql.h>
  23
  24 FileSend::FileSend()
  25 {
  26     fdRedoLog = -1;
  27     fdStmtLog = -1;
  28     openRedoFile();
  29 }
  30 DbRetVal FileSend::openRedoFile()
  31 {
  32     if (fdRedoLog > 0) os::close(fdRedoLog);
  33     if (fdStmtLog > 0) os::close(fdStmtLog);
  34     char fileName[MAX_FILE_LEN];
  35     char stmtFileName[MAX_FILE_LEN];
  36     sprintf(fileName, "%s/csql.db.cur", Conf::config.getDbFile());
  37     sprintf(stmtFileName, "%s/csql.db.stmt", Conf::config.getDbFile());
  38     int durableMode = Conf::config.getDurableMode();
  39     switch(durableMode) {
  40         case 1:
  41         case 2:
  42             fdRedoLog = os::openFileForAppend(fileName, O_CREAT);
  43             fdStmtLog = os::openFileForAppend(stmtFileName, O_CREAT);
  44             break;
  45         case 3:
  46             fdRedoLog = os::openFileForAppend(fileName, O_CREAT|O_SYNC);
  47             fdStmtLog = os::openFileForAppend(stmtFileName, O_CREAT|O_SYNC);
  48             break;
  49         case 4:
  50 #ifdef SOLARIS
  51             fdRedoLog = os::openFileForAppend(fileName, O_CREAT|O_DSYNC);
  52             fdStmtLog = os::openFileForAppend(stmtFileName, O_CREAT|O_DSYNC);
  53 #else
  54             fdRedoLog = os::openFileForAppend(fileName, O_CREAT|O_DIRECT);
  55             fdStmtLog = os::openFileForAppend(stmtFileName, O_CREAT|O_DIRECT);
  56 #endif
  57             break;
  58         default:
  59             fdRedoLog = os::openFileForAppend(fileName, O_CREAT);
  60             fdStmtLog = os::openFileForAppend(stmtFileName, O_CREAT);
  61             break;
  62     }
  63     if (-1 == fdRedoLog || -1 == fdStmtLog) {
  64         printError(ErrSysInternal, "Unable to open redo log file");
  65         return ErrSysInternal;
  66     }
  67     return OK;
  68 }
  69
  70 FileSend::~FileSend() {
  71     if (fdRedoLog > 0) os::close(fdRedoLog);
  72     if (fdStmtLog > 0) os::close(fdStmtLog);
  73     fdRedoLog = -1;
  74     fdStmtLog = -1;
  75 }
  76
  77 DbRetVal FileSend::prepare(int txnId, int stmtId, int len, char *stmt,
  78                            char *tblName, bool hasParam)
  79 {
  80     if (fdRedoLog < 0) {
  81        printError(ErrBadArg, "Redo Log file not opened");
  82        return ErrBadArg;
  83     }
  84     if (fdStmtLog < 0) {
  85        printError(ErrBadArg, "Redo Stmt Log file not opened");
  86        return ErrBadArg;
  87     }
  88     int fd =fdRedoLog;
  89     if (hasParam) fd=fdStmtLog;
  90     //The following structure needs strlen after stmt id for traversal in
  91     //redolog file unlike msg queue structure where string is the last element
  92     //and is not a continuous piece of memory.
  93     int datalen = os::align(5 * sizeof(int) + len); // for len + txnId + msg type + stmtId + tableName + stmtstrlen + stmtstring
  94     char *buf = (char*) malloc(datalen);
  95     char *msg = buf;
  96     //Note:: msg type is taken as -ve as we need to differentiate between
  97     //statement id and logtype during recovery.
  98     *(int*) msg = -1;
  99     if (strlen(stmt) > 6 && ( strncasecmp(stmt,"CREATE", 6) == 0 ||
 100                                   strncasecmp(stmt,"DROP", 4) == 0 ||
 101                                       strncasecmp(stmt,"RENAME", 6) == 0 ||
 102                                           strncasecmp(stmt,"ALTER", 5) == 0 ))
 103         *(int*)msg = -4; //means prepare and execute the stmt
 104     msg = msg+sizeof(int);
 105     *(int *)msg = datalen;
 106     msg = msg+sizeof(int);
 107     *(int *)msg = txnId;
 108     msg = msg+sizeof(int);
 109     *(int *)msg = stmtId;
 110     msg = msg+ sizeof(int);
 111     *(int *)msg = os::align(len);
 112     msg = msg+ sizeof(int);
 113     msg[len-1] = '\0';
 114     strcpy(msg, stmt);
 115     int ret =0;
 116     bool firstTime=true;
 117 retry:
 118     if (Conf::config.getDurableMode() != 1) {
 119         ret = os::lockFile(fd);
 120         if (-1 == ret) {
 121             ::free(buf);
 122             printError(ErrLockTimeOut,"Unable to get exclusive lock on redo log file");
 123             return ErrLockTimeOut;
 124         }
 125     }
 126     ret = os::write(fd, buf, datalen);
 127     if (Conf::config.getDurableMode() != 1) {
 128         os::unlockFile(fd);
 129     }
 130     if (-1 == ret) {
 131         DbRetVal rv = openRedoFile();
 132         if (hasParam) fd=fdStmtLog; else fd=fdRedoLog;
 133         if (OK == rv) {
 134             logFine(Conf::logger, "Reopening redo log file");
 135             if(firstTime) { firstTime = false; goto retry; }
 136         }
 137         printError(ErrOS, "Unable to write undo log");
 138         ::free(buf);
 139         return ErrOS;
 140     }
 141     ::free(buf);
 142     return OK;
 143 };
 144
 145 DbRetVal FileSend::commit(int len, void *data)
 146 {
 147     if (fdRedoLog < 0) {
 148        printError(ErrBadArg, "Redo Log file not opened");
 149        return ErrBadArg;
 150     }
 151     char *dat=(char*)data - sizeof(int);
 152     *(int*)dat = -2; //type 2->commit
 153     bool firstTime = true;
 154 retry:
 155     if (Conf::config.getDurableMode() != 1) {
 156         int ret = os::lockFile(fdRedoLog);
 157         if (-1 == ret) {
 158             printError(ErrLockTimeOut,"Unable to get exclusive lock on redo log file");
 159             return ErrLockTimeOut;
 160         }
 161     }
 162     int ret = os::write(fdRedoLog, dat, len+sizeof(int));
 163     if (Conf::config.getDurableMode() != 1) {
 164         os::unlockFile(fdRedoLog);
 165     }
 166     if (-1 == ret) {
 167         DbRetVal rv = openRedoFile();
 168         if (OK == rv) {
 169             logFine(Conf::logger, "Reopening redo log file");
 170             if(firstTime) { firstTime = false; goto retry; }
 171         }
 172         printError(ErrOS, "Unable to write undo log");
 173         return ErrOS;
 174     }
 175     return OK;
 176 }
 177 DbRetVal FileSend::free(int txnId, int stmtId, bool hasParam)
 178 {
 179     if (fdRedoLog < 0) {
 180        printError(ErrBadArg, "Redo Log file not opened");
 181        return ErrBadArg;
 182     }
 183     if (fdStmtLog < 0) {
 184        printError(ErrBadArg, "Redo Stmt Log file not opened");
 185        return ErrBadArg;
 186     }
 187     int fd =fdRedoLog;
 188     int buflen =  4 *sizeof(int);
 189     char *msg = (char *) malloc(buflen);
 190     char *ptr = msg;
 191     *(int*)ptr = -3;
 192     ptr += sizeof(int);
 193     *(int *)ptr = 3 * sizeof(int); // for len + txnId + stmtId
 194     ptr += sizeof(int);
 195     *(int *)ptr = txnId;
 196     ptr += sizeof(int);
 197     *(int *)ptr = stmtId;
 198     printDebug(DM_SqlLog, "stmtID sent = %d\n", *(int *)ptr);
 199     bool firstTime = true;
 200 retry:
 201     if (Conf::config.getDurableMode() != 1) {
 202         int ret = os::lockFile(fd);
 203         if (-1 == ret) {
 204             ::free(msg);
 205             printError(ErrLockTimeOut,"Unable to get exclusive lock on redo log file");
 206             return ErrLockTimeOut;
 207         }
 208     }
 209     int ret = os::write(fd, msg, buflen);
 210     if (Conf::config.getDurableMode() != 1) {
 211         os::unlockFile(fd);
 212     }
 213     if (-1 == ret) {
 214         DbRetVal rv = openRedoFile();
 215         if (hasParam) fd=fdStmtLog; else fd=fdRedoLog;
 216         if (OK == rv) {
 217             logFine(Conf::logger, "Reopening redo log file");
 218             if(firstTime) { firstTime = false; goto retry; }
 219         }
 220         printError(ErrOS, "Unable to write undo log");
 221         ::free(msg);
 222         return ErrOS;
 223     }
 224     if (!hasParam) {
 225         //For non parameterized stmts , no need to write in stmt log
 226         ::free(msg);
 227         return OK;
 228     }
 229     fd=fdStmtLog;
 230 retry1:
 231     if (Conf::config.getDurableMode() != 1) {
 232         int ret = os::lockFile(fd);
 233         if (-1 == ret) {
 234             ::free(msg);
 235             printError(ErrLockTimeOut,"Unable to get exclusive lock on redo log file");
 236             return ErrLockTimeOut;
 237         }
 238     }
 239
 240     ret = os::write(fd, msg, buflen);
 241     if (Conf::config.getDurableMode() != 1) {
 242         os::unlockFile(fd);
 243     }
 244     if (-1 == ret) {
 245         DbRetVal rv = openRedoFile();
 246         if (OK == rv) {
 247             logFine(Conf::logger, "Reopening redo log file");
 248             if(firstTime) { firstTime = false; goto retry1; }
 249         }
 250         printError(ErrOS, "Unable to write undo log");
 251         ::free(msg);
 252         return ErrOS;
 253     }
 254     ::free(msg);
 255     return OK;
 256 }
 257
 258 OfflineLog::OfflineLog()
 259 {
 260     fdOfflineLog = -1;
 261     metadata = NULL;
 262     createMetadataFile();
 263     openOfflineLogFile();
 264 }
 265
 266 DbRetVal OfflineLog::openOfflineLogFile()
 267 {
 268     char fileName[MAX_FILE_LEN];
 269     int offlineLogFileSize = Conf::config.getOfflineLogFileSize();
 270     fileSize = 0;
 271     if (metadata == NULL) {
 272         metadata = openMetadataFile();
 273         if (metadata == NULL) {
 274             printError(ErrOS, "Unable to open Metadata file");
 275             return ErrOS;
 276         }
 277     }
 278     char *ptr = (char *) metadata;
 279     sprintf(fileName, "%s/offlineLogFile.%d",
 280                                         Conf::config.getDbFile(), *(int *)ptr);
 281     bool ret = false;
 282     if ( ((ret = os::fileExists(fileName)) == true) &&
 283               ((fileSize = os::getFileSize(fileName)) >= offlineLogFileSize) )
 284         sprintf(fileName, "%s/offlineLogFile.%d",
 285                                     Conf::config.getDbFile(), ++(*(int *)ptr));
 286     else if (ret == true)
 287         sprintf(fileName, "%s/offlineLogFile.%d", Conf::config.getDbFile(),
 288                                                                   *(int *)ptr);
 289     else {
 290         sprintf(fileName, "%s/offlineLogFile.0", Conf::config.getDbFile());
 291         *(int *) ptr = 0;
 292     }
 293     int durableMode = Conf::config.getDurableMode();
 294     switch(durableMode) {
 295         case 1:
 296         case 2:
 297             fdOfflineLog = os::openFileForAppend(fileName, O_CREAT);
 298             break;
 299         case 3:
 300             fdOfflineLog = os::openFileForAppend(fileName, O_CREAT|O_SYNC);
 301             break;
 302         case 4:
 303 #ifdef SOLARIS
 304             fdOfflineLog = os::openFileForAppend(fileName, O_CREAT|O_DSYNC);
 305 #else
 306             fdOfflineLog = os::openFileForAppend(fileName, O_CREAT|O_DIRECT);
 307 #endif
 308             break;
 309         default:
 310             fdOfflineLog = os::openFileForAppend(fileName, O_CREAT);
 311             break;
 312     }
 313     if (-1 == fdOfflineLog) {
 314         printError(ErrSysInternal, "Unable to open redo log file");
 315         return ErrSysInternal;
 316     }
 317     ret = os::msync((char*)metadata, sizeof(int), MS_SYNC);
 318     if (ret) {
 319         printError(ErrOS, "Unable to sync file index to metadata file.");
 320         return ErrOS;
 321     }
 322     return OK;
 323 }
 324
 325 OfflineLog::~OfflineLog()
 326 {
 327     if (fdOfflineLog > 0) os::close(fdOfflineLog);
 328     fdOfflineLog = -1;
 329 }
 330
 331 DbRetVal OfflineLog::prepare(int txnId, int stId, int len, char *stmt,
 332                              char*tn, bool hasParam)
 333 {
 334     if (fdOfflineLog < 0) return ErrBadArg;
 335     DbRetVal rv = OK;
 336     if (fileSize > Conf::config.getOfflineLogFileSize())
 337     {
 338         rv = openOfflineLogFile();
 339         if (rv != OK) return rv;
 340     }
 341     //The following structure needs strlen after stmt id for traversal in
 342     //redolog file unlike msg queue structure where string is the last element
 343     //and is not a continuous piece of memory.
 344     int datalen = os::align(5 * sizeof(int) + len); // for len + txnId + msg type + stmtId + tableName + stmtstrlen + stmtstring
 345     char *buf = (char*) malloc(datalen);
 346     char *msg = buf;
 347     //Note:: msg type is taken as -ve as we need to differentiate between
 348     //statement id and logtype during recovery.
 349     *(int*) msg = -1;
 350     if (strlen(stmt) > 6 && ( strncasecmp(stmt,"CREATE", 6) == 0 || strncasecmp(stmt,"DROP", 4) == 0 ))
 351         *(int*)msg = -4; //means prepare and execute the stmt
 352     msg = msg+sizeof(int);
 353     *(int *)msg = datalen;
 354     msg = msg+sizeof(int);
 355     *(int *)msg = txnId;
 356     msg = msg+sizeof(int);
 357     *(int *)msg = stId;
 358     msg = msg+ sizeof(int);
 359     *(int *)msg = os::align(len);
 360     msg = msg+ sizeof(int);
 361     msg[len-1] = '\0';
 362     strcpy(msg, stmt);
 363     int ret =0;
 364     bool firstTime=true;
 365 retry:
 366     if (Conf::config.getDurableMode() != 1) {
 367         ret = os::lockFile(fdOfflineLog);
 368         if (-1 == ret) {
 369             ::free(buf);
 370             printError(ErrLockTimeOut,"Unable to get exclusive lock on redo log file");
 371             return ErrLockTimeOut;
 372         }
 373     }
 374     ret = os::write(fdOfflineLog, buf, datalen);
 375     if (Conf::config.getDurableMode() != 1) {
 376         os::unlockFile(fdOfflineLog);
 377     }
 378     if (-1 == ret) {
 379         DbRetVal rv = openOfflineLogFile();
 380         if (OK == rv) {
 381             logFine(Conf::logger, "Reopening redo log file");
 382             if(firstTime) { firstTime = false; goto retry; }
 383         }
 384         printError(ErrOS, "Unable to write undo log");
 385         ::free(buf);
 386         return ErrOS;
 387     }
 388     ::free(buf);
 389     fileSize += datalen;
 390     return OK;
 391 }
 392 DbRetVal OfflineLog::commit(int len, void *data)
 393 {
 394     if (fdOfflineLog < 0) return ErrBadArg;
 395     DbRetVal rv = OK;
 396     if (fileSize > Conf::config.getOfflineLogFileSize())
 397     {
 398         rv = openOfflineLogFile();
 399         if (rv != OK) return rv;
 400     }
 401     char *dat=(char*)data - sizeof(int);
 402     *(int*)dat = -2; //type 2->commit
 403     bool firstTime = true;
 404 retry:
 405     if (Conf::config.getDurableMode() != 1) {
 406         int ret = os::lockFile(fdOfflineLog);
 407         if (-1 == ret) {
 408             printError(ErrLockTimeOut,"Unable to get exclusive lock on redo log file");
 409             return ErrLockTimeOut;
 410         }
 411     }
 412     int ret = os::write(fdOfflineLog, dat, len+sizeof(int));
 413     if (Conf::config.getDurableMode() != 1) {
 414         os::unlockFile(fdOfflineLog);
 415     }
 416     if (-1 == ret) {
 417         DbRetVal rv = openOfflineLogFile();
 418         if (OK == rv) {
 419             logFine(Conf::logger, "Reopening redo log file");
 420             if(firstTime) { firstTime = false; goto retry; }
 421         }
 422         printError(ErrOS, "Unable to write undo log");
 423         return ErrOS;
 424     }
 425     fileSize += len+sizeof(int);
 426     return OK;
 427 }
 428 DbRetVal OfflineLog::free(int txnId, int stId, bool hasParam)
 429 {
 430     if (fdOfflineLog < 0) return ErrBadArg;
 431     DbRetVal rv = OK;
 432     if (fileSize > Conf::config.getOfflineLogFileSize())
 433     {
 434         rv = openOfflineLogFile();
 435         if (rv != OK) return rv;
 436     }
 437     int buflen =  4 *sizeof(int);
 438     char *msg = (char *) malloc(buflen);
 439     char *ptr = msg;
 440     *(int*)ptr = -3;
 441     ptr += sizeof(int);
 442     *(int *)ptr = 3 * sizeof(int); // for len + txnId + stmtId
 443     ptr += sizeof(int);
 444     *(int *)ptr = txnId;
 445     ptr += sizeof(int);
 446     *(int *)ptr = stId;
 447     printDebug(DM_SqlLog, "stmtID sent = %d\n", *(int *)ptr);
 448     bool firstTime = false;
 449 retry:
 450     if (Conf::config.getDurableMode() != 1) {
 451         int ret = os::lockFile(fdOfflineLog);
 452         if (-1 == ret) {
 453             ::free(msg);
 454             printError(ErrLockTimeOut,"Unable to get exclusive lock on redo log file");
 455             return ErrLockTimeOut;
 456         }
 457     }
 458     int ret = os::write(fdOfflineLog, msg, buflen);
 459     if (Conf::config.getDurableMode() != 1) {
 460         os::unlockFile(fdOfflineLog);
 461     }
 462     if (-1 == ret) {
 463         DbRetVal rv = openOfflineLogFile();
 464         if (OK == rv) {
 465             logFine(Conf::logger, "Reopening redo log file");
 466             if(firstTime) { firstTime = false; goto retry; }
 467         }
 468         printError(ErrOS, "Unable to write undo log");
 469         ::free(msg);
 470         return ErrOS;
 471     }
 472     ::free(msg);
 473     fileSize += buflen;
 474     return OK;
 475 }
 476
 477 DbRetVal OfflineLog::createMetadataFile()
 478 {
 479     int fd = -1;
 480     char mmapFile[128];
 481     sprintf(mmapFile, "%s/offlineLogFile.dat", Conf::config.getDbFile());
 482     int size = sizeof(int);
 483     // int for offlineLogFile index + long for committed TxnID
 484     char buffer[4];
 485     if (os::fileExists(mmapFile)) return OK;
 486     else {
 487         fd = ::open(mmapFile, O_CREAT | O_RDWR, 0664);
 488         if (fd == -1) {
 489             printError(ErrOS, "Unable to create '%s'file to mmap", mmapFile);
 490             return ErrOS;
 491         }
 492         memset(buffer, 0, size);
 493         int sz = os::write(fd, buffer, size);
 494         if (sz != size) {
 495             printError(ErrOS, "Unable to initialize mmap file %s", mmapFile);
 496             return ErrOS;
 497         }
 498         os::close(fd);
 499     }
 500     return OK;
 501 }
 502
 503 void *OfflineLog::openMetadataFile()
 504 {
 505     char mmapFile[128];
 506     int size = sizeof(int) + sizeof(long);
 507     sprintf(mmapFile, "%s/offlineLogFile.dat", Conf::config.getDbFile());
 508     file_desc fd = os::openFile(mmapFile, fileOpenWriteOnly, 0666);
 509     if (fd == (file_desc)-1) {
 510         printError(ErrOS, "Unable to open Mmap file %s", mmapFile);
 511         return NULL;
 512     }
 513     metadata = os::mmap(NULL, size, mapProtRead | mapProtWrite, mapShared, fd, 0);
 514     if (metadata == NULL) {
 515         printError(ErrOS, "Unable to map the file %s to memory", mmapFile);
 516         return NULL;
 517     }
 518     return metadata;
 519 }