ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/BDB/BDB.xs
(Generate patch)

Comparing BDB/BDB.xs (file contents):
Revision 1.50 by root, Thu Sep 25 13:22:32 2008 UTC vs.
Revision 1.53 by root, Thu Sep 25 22:09:02 2008 UTC

… …
351static void req_free (bdb_req req); 351static void req_free (bdb_req req);
352static void req_cancel (bdb_req req); 352static void req_cancel (bdb_req req);
353 353
354static int req_invoke (bdb_req req) 354static int req_invoke (bdb_req req)
355{ 355{
356 dSP; 356 switch (req->type)
357 {
358 case REQ_DB_CLOSE:
359 SvREFCNT_dec (req->sv1);
360 break;
361
362 case REQ_DB_GET:
363 case REQ_DB_PGET:
364 dbt_to_sv (req->sv3, &req->dbt3);
365 break;
366
367 case REQ_C_GET:
368 case REQ_C_PGET:
369 dbt_to_sv (req->sv1, &req->dbt1);
370 dbt_to_sv (req->sv2, &req->dbt2);
371 dbt_to_sv (req->sv3, &req->dbt3);
372 break;
373
374 case REQ_DB_PUT:
375 case REQ_C_PUT:
376 dbt_to_sv (0, &req->dbt1);
377 dbt_to_sv (0, &req->dbt2);
378 break;
379
380 case REQ_DB_KEY_RANGE:
381 {
382 AV *av = newAV ();
383
384 av_push (av, newSVnv (req->key_range.less));
385 av_push (av, newSVnv (req->key_range.equal));
386 av_push (av, newSVnv (req->key_range.greater));
387
388 SvREADONLY_off (req->sv1);
389 sv_setsv_mg (req->sv1, newRV_noinc ((SV *)av));
390 SvREFCNT_dec (req->sv1);
391 }
392 break;
393
394#if DB_VERSION_MINOR >= 3
395 case REQ_SEQ_GET:
396 SvREADONLY_off (req->sv1);
397
398 if (sizeof (IV) > 4)
399 sv_setiv_mg (req->sv1, (IV)req->seq_t);
400 else
401 sv_setnv_mg (req->sv1, (NV)req->seq_t);
402
403 SvREFCNT_dec (req->sv1);
404 break;
405#endif
406 }
407
408 errno = req->result;
357 409
358 if (req->callback) 410 if (req->callback)
359 { 411 {
412 dSP;
413
360 ENTER; 414 ENTER;
361 SAVETMPS; 415 SAVETMPS;
362 PUSHMARK (SP); 416 PUSHMARK (SP);
363 417
364 switch (req->type)
365 {
366 case REQ_DB_CLOSE:
367 SvREFCNT_dec (req->sv1);
368 break;
369
370 case REQ_DB_GET:
371 case REQ_DB_PGET:
372 dbt_to_sv (req->sv3, &req->dbt3);
373 break;
374
375 case REQ_C_GET:
376 case REQ_C_PGET:
377 dbt_to_sv (req->sv1, &req->dbt1);
378 dbt_to_sv (req->sv2, &req->dbt2);
379 dbt_to_sv (req->sv3, &req->dbt3);
380 break;
381
382 case REQ_DB_PUT:
383 case REQ_C_PUT:
384 dbt_to_sv (0, &req->dbt1);
385 dbt_to_sv (0, &req->dbt2);
386 break;
387
388 case REQ_DB_KEY_RANGE:
389 {
390 AV *av = newAV ();
391
392 av_push (av, newSVnv (req->key_range.less));
393 av_push (av, newSVnv (req->key_range.equal));
394 av_push (av, newSVnv (req->key_range.greater));
395
396 SvREADONLY_off (req->sv1);
397 sv_setsv_mg (req->sv1, newRV_noinc ((SV *)av));
398 SvREFCNT_dec (req->sv1);
399 }
400 break;
401
402#if DB_VERSION_MINOR >= 3
403 case REQ_SEQ_GET:
404 SvREADONLY_off (req->sv1);
405
406 if (sizeof (IV) > 4)
407 sv_setiv_mg (req->sv1, (IV)req->seq_t);
408 else
409 sv_setnv_mg (req->sv1, (NV)req->seq_t);
410
411 SvREFCNT_dec (req->sv1);
412 break;
413#endif
414 }
415
416 errno = req->result;
417
418 PUTBACK; 418 PUTBACK;
419 call_sv (req->callback, G_VOID | G_EVAL); 419 call_sv (req->callback, G_VOID | G_EVAL);
420 SPAGAIN; 420 SPAGAIN;
421 421
422 FREETMPS; 422 FREETMPS;
423 LEAVE; 423 LEAVE;
424
425 return !SvTRUE (ERRSV);
424 } 426 }
425 427
426 return !SvTRUE (ERRSV); 428 return 1;
427} 429}
428 430
429static void req_free (bdb_req req) 431static void req_free (bdb_req req)
430{ 432{
431 SvREFCNT_dec (req->callback); 433 SvREFCNT_dec (req->callback);
… …
485 487
486 respipe_osf [0] = TO_SOCKET (respipe [0]); 488 respipe_osf [0] = TO_SOCKET (respipe [0]);
487 respipe_osf [1] = TO_SOCKET (respipe [1]); 489 respipe_osf [1] = TO_SOCKET (respipe [1]);
488} 490}
489 491
492static void bdb_request (bdb_req req);
490X_THREAD_PROC (bdb_proc); 493X_THREAD_PROC (bdb_proc);
491 494
492static void start_thread (void) 495static void start_thread (void)
493{ 496{
494 worker *wrk = calloc (1, sizeof (worker)); 497 worker *wrk = calloc (1, sizeof (worker));
… …
541 } 544 }
542 545
543 // synthesize callback if none given 546 // synthesize callback if none given
544 if (!req->callback) 547 if (!req->callback)
545 { 548 {
549 if (SvOK (prepare_cb))
550 {
546 int count; 551 int count;
547 552
548 dSP; 553 dSP;
549 PUSHMARK (SP); 554 PUSHMARK (SP);
550 PUTBACK; 555 PUTBACK;
551 count = call_sv (prepare_cb, G_ARRAY); 556 count = call_sv (prepare_cb, G_ARRAY);
552 SPAGAIN; 557 SPAGAIN;
553 558
554 if (count != 2) 559 if (count != 2)
555 croak ("prepare callback must return exactly two values\n"); 560 croak ("prepare callback must return exactly two values\n");
556 561
557 wait_callback = POPs; 562 wait_callback = POPs;
558 req->callback = SvREFCNT_inc (POPs); 563 req->callback = SvREFCNT_inc (POPs);
564 }
565 else
566 {
567 // execute request synchronously
568 bdb_request (req);
569 req_invoke (req);
570 req_free (req);
571 return;
572 }
559 } 573 }
560 574
561 ++nreqs; 575 ++nreqs;
562 576
563 X_LOCK (reqlock); 577 X_LOCK (reqlock);
… …
577 } 591 }
578} 592}
579 593
580static void end_thread (void) 594static void end_thread (void)
581{ 595{
582 bdb_req req; 596 bdb_req req = calloc (1, sizeof (bdb_cb));
583
584 Newz (0, req, 1, bdb_cb);
585 597
586 req->type = REQ_QUIT; 598 req->type = REQ_QUIT;
587 req->pri = PRI_MAX + PRI_BIAS; 599 req->pri = PRI_MAX + PRI_BIAS;
588 600
589 X_LOCK (reqlock); 601 X_LOCK (reqlock);
… …
714 726
715 return count; 727 return count;
716} 728}
717 729
718/*****************************************************************************/ 730/*****************************************************************************/
731
732static void
733bdb_request (bdb_req req)
734{
735 switch (req->type)
736 {
737 case REQ_ENV_OPEN:
738 req->result = req->env->open (req->env, req->buf1, req->uint1, req->int1);
739 break;
740
741 case REQ_ENV_CLOSE:
742 req->result = req->env->close (req->env, req->uint1);
743 break;
744
745 case REQ_ENV_TXN_CHECKPOINT:
746 req->result = req->env->txn_checkpoint (req->env, req->uint1, req->int1, req->uint2);
747 break;
748
749 case REQ_ENV_LOCK_DETECT:
750 req->result = req->env->lock_detect (req->env, req->uint1, req->uint2, &req->int1);
751 break;
752
753 case REQ_ENV_MEMP_SYNC:
754 req->result = req->env->memp_sync (req->env, 0);
755 break;
756
757 case REQ_ENV_MEMP_TRICKLE:
758 req->result = req->env->memp_trickle (req->env, req->int1, &req->int2);
759 break;
760
761 case REQ_ENV_DBREMOVE:
762 req->result = req->env->dbremove (req->env, req->txn, req->buf1, req->buf2, req->uint1);
763 break;
764
765 case REQ_ENV_DBRENAME:
766 req->result = req->env->dbrename (req->env, req->txn, req->buf1, req->buf2, req->buf3, req->uint1);
767 break;
768
769 case REQ_DB_OPEN:
770 req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
771 break;
772
773 case REQ_DB_CLOSE:
774 req->result = req->db->close (req->db, req->uint1);
775 break;
776
777#if DB_VERSION_MINOR >= 4
778 case REQ_DB_COMPACT:
779 req->result = req->db->compact (req->db, req->txn, &req->dbt1, &req->dbt2, 0, req->uint1, 0);
780 break;
781#endif
782
783 case REQ_DB_SYNC:
784 req->result = req->db->sync (req->db, req->uint1);
785 break;
786
787 case REQ_DB_UPGRADE:
788 req->result = req->db->upgrade (req->db, req->buf1, req->uint1);
789 break;
790
791 case REQ_DB_PUT:
792 req->result = req->db->put (req->db, req->txn, &req->dbt1, &req->dbt2, req->uint1);
793 break;
794
795#if DB_VERSION_MINOR >= 6
796 case REQ_DB_EXISTS:
797 req->result = req->db->exists (req->db, req->txn, &req->dbt1, req->uint1);
798 break;
799#endif
800 case REQ_DB_GET:
801 req->result = req->db->get (req->db, req->txn, &req->dbt1, &req->dbt3, req->uint1);
802 break;
803
804 case REQ_DB_PGET:
805 req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
806 break;
807
808 case REQ_DB_DEL:
809 req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);
810 break;
811
812 case REQ_DB_KEY_RANGE:
813 req->result = req->db->key_range (req->db, req->txn, &req->dbt1, &req->key_range, req->uint1);
814 break;
815
816 case REQ_TXN_COMMIT:
817 req->result = req->txn->commit (req->txn, req->uint1);
818 break;
819
820 case REQ_TXN_ABORT:
821 req->result = req->txn->abort (req->txn);
822 break;
823
824 case REQ_TXN_FINISH:
825 if (req->txn->flags & TXN_DEADLOCK)
826 {
827 req->result = req->txn->abort (req->txn);
828 if (!req->result)
829 req->result = DB_LOCK_DEADLOCK;
830 }
831 else
832 req->result = req->txn->commit (req->txn, req->uint1);
833 break;
834
835 case REQ_C_CLOSE:
836 req->result = req->dbc->c_close (req->dbc);
837 break;
838
839 case REQ_C_COUNT:
840 {
841 db_recno_t recno;
842 req->result = req->dbc->c_count (req->dbc, &recno, req->uint1);
843 req->uv1 = recno;
844 }
845 break;
846
847 case REQ_C_PUT:
848 req->result = req->dbc->c_put (req->dbc, &req->dbt1, &req->dbt2, req->uint1);
849 break;
850
851 case REQ_C_GET:
852 req->result = req->dbc->c_get (req->dbc, &req->dbt1, &req->dbt3, req->uint1);
853 break;
854
855 case REQ_C_PGET:
856 req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
857 break;
858
859 case REQ_C_DEL:
860 req->result = req->dbc->c_del (req->dbc, req->uint1);
861 break;
862
863#if DB_VERSION_MINOR >= 3
864 case REQ_SEQ_OPEN:
865 req->result = req->seq->open (req->seq, req->txn, &req->dbt1, req->uint1);
866 break;
867
868 case REQ_SEQ_CLOSE:
869 req->result = req->seq->close (req->seq, req->uint1);
870 break;
871
872 case REQ_SEQ_GET:
873 req->result = req->seq->get (req->seq, req->txn, req->int1, &req->seq_t, req->uint1);
874 break;
875
876 case REQ_SEQ_REMOVE:
877 req->result = req->seq->remove (req->seq, req->txn, req->uint1);
878 break;
879#endif
880
881 default:
882 req->result = ENOSYS;
883 break;
884 }
885
886 if (req->txn && (req->result > 0 || req->result == DB_LOCK_NOTGRANTED))
887 req->txn->flags |= TXN_DEADLOCK;
888}
719 889
720X_THREAD_PROC (bdb_proc) 890X_THREAD_PROC (bdb_proc)
721{ 891{
722 bdb_req req; 892 bdb_req req;
723 struct timespec ts; 893 struct timespec ts;
… …
764 934
765 --nready; 935 --nready;
766 936
767 X_UNLOCK (reqlock); 937 X_UNLOCK (reqlock);
768 938
769 switch (req->type) 939 if (req->type == REQ_QUIT)
770 { 940 {
771 case REQ_QUIT: 941 X_LOCK (reslock);
772 req->result = ENOSYS; 942 free (req);
943 self->req = 0;
944 X_UNLOCK (reslock);
945
773 goto quit; 946 goto quit;
774
775 case REQ_ENV_OPEN:
776 req->result = req->env->open (req->env, req->buf1, req->uint1, req->int1);
777 break;
778
779 case REQ_ENV_CLOSE:
780 req->result = req->env->close (req->env, req->uint1);
781 break;
782
783 case REQ_ENV_TXN_CHECKPOINT:
784 req->result = req->env->txn_checkpoint (req->env, req->uint1, req->int1, req->uint2);
785 break;
786
787 case REQ_ENV_LOCK_DETECT:
788 req->result = req->env->lock_detect (req->env, req->uint1, req->uint2, &req->int1);
789 break;
790
791 case REQ_ENV_MEMP_SYNC:
792 req->result = req->env->memp_sync (req->env, 0);
793 break;
794
795 case REQ_ENV_MEMP_TRICKLE:
796 req->result = req->env->memp_trickle (req->env, req->int1, &req->int2);
797 break;
798
799 case REQ_ENV_DBREMOVE:
800 req->result = req->env->dbremove (req->env, req->txn, req->buf1, req->buf2, req->uint1);
801 break;
802
803 case REQ_ENV_DBRENAME:
804 req->result = req->env->dbrename (req->env, req->txn, req->buf1, req->buf2, req->buf3, req->uint1);
805 break;
806
807 case REQ_DB_OPEN:
808 req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
809 break;
810
811 case REQ_DB_CLOSE:
812 req->result = req->db->close (req->db, req->uint1);
813 break;
814
815#if DB_VERSION_MINOR >= 4
816 case REQ_DB_COMPACT:
817 req->result = req->db->compact (req->db, req->txn, &req->dbt1, &req->dbt2, 0, req->uint1, 0);
818 break;
819#endif
820
821 case REQ_DB_SYNC:
822 req->result = req->db->sync (req->db, req->uint1);
823 break;
824
825 case REQ_DB_UPGRADE:
826 req->result = req->db->upgrade (req->db, req->buf1, req->uint1);
827 break;
828
829 case REQ_DB_PUT:
830 req->result = req->db->put (req->db, req->txn, &req->dbt1, &req->dbt2, req->uint1);
831 break;
832
833#if DB_VERSION_MINOR >= 6
834 case REQ_DB_EXISTS:
835 req->result = req->db->exists (req->db, req->txn, &req->dbt1, req->uint1);
836 break;
837#endif
838 case REQ_DB_GET:
839 req->result = req->db->get (req->db, req->txn, &req->dbt1, &req->dbt3, req->uint1);
840 break;
841
842 case REQ_DB_PGET:
843 req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
844 break;
845
846 case REQ_DB_DEL:
847 req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);
848 break;
849
850 case REQ_DB_KEY_RANGE:
851 req->result = req->db->key_range (req->db, req->txn, &req->dbt1, &req->key_range, req->uint1);
852 break;
853
854 case REQ_TXN_COMMIT:
855 req->result = req->txn->commit (req->txn, req->uint1);
856 break;
857
858 case REQ_TXN_ABORT:
859 req->result = req->txn->abort (req->txn);
860 break;
861
862 case REQ_TXN_FINISH:
863 if (req->txn->flags & TXN_DEADLOCK)
864 {
865 req->result = req->txn->abort (req->txn);
866 if (!req->result)
867 req->result = DB_LOCK_DEADLOCK;
868 }
869 else
870 req->result = req->txn->commit (req->txn, req->uint1);
871 break;
872
873 case REQ_C_CLOSE:
874 req->result = req->dbc->c_close (req->dbc);
875 break;
876
877 case REQ_C_COUNT:
878 {
879 db_recno_t recno;
880 req->result = req->dbc->c_count (req->dbc, &recno, req->uint1);
881 req->uv1 = recno;
882 }
883 break;
884
885 case REQ_C_PUT:
886 req->result = req->dbc->c_put (req->dbc, &req->dbt1, &req->dbt2, req->uint1);
887 break;
888
889 case REQ_C_GET:
890 req->result = req->dbc->c_get (req->dbc, &req->dbt1, &req->dbt3, req->uint1);
891 break;
892
893 case REQ_C_PGET:
894 req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
895 break;
896
897 case REQ_C_DEL:
898 req->result = req->dbc->c_del (req->dbc, req->uint1);
899 break;
900
901#if DB_VERSION_MINOR >= 3
902 case REQ_SEQ_OPEN:
903 req->result = req->seq->open (req->seq, req->txn, &req->dbt1, req->uint1);
904 break;
905
906 case REQ_SEQ_CLOSE:
907 req->result = req->seq->close (req->seq, req->uint1);
908 break;
909
910 case REQ_SEQ_GET:
911 req->result = req->seq->get (req->seq, req->txn, req->int1, &req->seq_t, req->uint1);
912 break;
913
914 case REQ_SEQ_REMOVE:
915 req->result = req->seq->remove (req->seq, req->txn, req->uint1);
916 break;
917#endif
918
919 default:
920 req->result = ENOSYS;
921 break;
922 } 947 }
923 948
924 if (req->txn && (req->result > 0 || req->result == DB_LOCK_NOTGRANTED)) 949 bdb_request (req);
925 req->txn->flags |= TXN_DEADLOCK;
926 950
927 X_LOCK (reslock); 951 X_LOCK (reslock);
928 952
929 ++npending; 953 ++npending;
930 954
… …
1318 }; 1342 };
1319 1343
1320 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1344 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1321 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 1345 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
1322 1346
1347 prepare_cb = &PL_sv_undef;
1348
1323 { 1349 {
1324 /* we currently only allow version, minor-version and patchlevel to go up to 255 */ 1350 /* we currently only allow version, minor-version and patchlevel to go up to 255 */
1325 char vstring[3] = { DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH }; 1351 char vstring[3] = { DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH };
1326 1352
1327 newCONSTSUB (stash, "VERSION_v", newSVpvn (vstring, 3)); 1353 newCONSTSUB (stash, "VERSION_v", newSVpvn (vstring, 3));
… …
1465 RETVAL = started; 1491 RETVAL = started;
1466 if (WORDACCESS_UNSAFE) X_UNLOCK (wrklock); 1492 if (WORDACCESS_UNSAFE) X_UNLOCK (wrklock);
1467 OUTPUT: 1493 OUTPUT:
1468 RETVAL 1494 RETVAL
1469 1495
1470void 1496SV *
1471set_sync_prepare (SV *cb) 1497set_sync_prepare (SV *cb)
1472 PROTOTYPE: & 1498 PROTOTYPE: &
1473 CODE: 1499 CODE:
1474 SvREFCNT_dec (prepare_cb); 1500 RETVAL = prepare_cb;
1475 prepare_cb = newSVsv (cb); 1501 prepare_cb = newSVsv (cb);
1502 OUTPUT:
1503 RETVAL
1476 1504
1477char * 1505char *
1478strerror (int errorno = errno) 1506strerror (int errorno = errno)
1479 PROTOTYPE: ;$ 1507 PROTOTYPE: ;$
1480 CODE: 1508 CODE:

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines