From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 3850 invoked by alias); 10 Dec 2009 23:16:27 -0000 Mailing-List: contact archer-help@sourceware.org; run by ezmlm Sender: Precedence: bulk List-Post: List-Help: List-Subscribe: List-Id: Received: (qmail 3835 invoked by uid 22791); 10 Dec 2009 23:16:26 -0000 X-SWARE-Spam-Status: No, hits=-2.0 required=5.0 tests=BAYES_00,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org MIME-Version: 1.0 From: Aman Gupta Date: Thu, 10 Dec 2009 23:16:00 -0000 Message-ID: Subject: [patch] fixing leaking struct value* in py-value.c To: archer@sourceware.org Content-Type: multipart/mixed; boundary=0015177404c6a1b50f047a67fec8 X-SW-Source: 2009-q4/txt/msg00090.txt.bz2 --0015177404c6a1b50f047a67fec8 Content-Type: text/plain; charset=ISO-8859-1 Content-length: 6128 Bug: http://sourceware.org/bugzilla/show_bug.cgi?id=10896 Given: $ cat simple.c #include #include #include struct blah { char test[2]; int i; float none; } *list_of_blahs; int main(){ list_of_blahs = malloc(sizeof(struct blah) * 2000000); printf("pid: %d\n", getpid()); while(1){ sleep(1); } } $ cat simple.py gdb.execute('p list_of_blahs') list = gdb.history(0) end = list + 1000000 while list < end: list['i'] list += 1 $ ./simple & [1] 16572 $ gdb -ex 'py execfile("./simple.py")' ./simple 16572 The gdb process will leak a large amount of memory (>512mb RSS) while executing the python loop. Some (but not all) of this memory is returned after the loop completes and free_all_values() is called for the next command. The following patch against archer-tromey-python keeps the memory usage constant during the loop. diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c index 14efd79..f305b01 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -143,7 +143,7 @@ valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) } value_obj->value = value; - value_incref (value); + release_value_or_incref (value); value_obj->address = NULL; value_obj->type = NULL; note_value (value_obj); @@ -267,6 +267,7 @@ valpy_cast (PyObject *self, PyObject *args) { PyObject *type_obj; struct type *type; + PyObject *res_obj = NULL; struct value *res_val = NULL; /* Initialize to appease gcc warning. */ volatile struct gdb_exception except; @@ -305,8 +306,10 @@ valpy_getitem (PyObject *self, PyObject *key) { value_object *self_value = (value_object *) self; char *field = NULL; + PyObject *res_obj = NULL; struct value *res_val = NULL; volatile struct gdb_exception except; + struct value *mark = value_mark (); if (gdbpy_is_string (key)) { @@ -344,9 +347,13 @@ valpy_getitem (PyObject *self, PyObject *key) } xfree (field); - GDB_PY_HANDLE_EXCEPTION (except); + GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP (except, mark); + + if (res_val) + res_obj = value_to_value_object (res_val); - return res_val ? value_to_value_object (res_val) : NULL; + value_free_to_mark (mark); + return res_obj; } static int @@ -427,8 +434,10 @@ enum valpy_opcode static PyObject * valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) { + PyObject *res_obj = NULL; struct value *res_val = NULL; /* Initialize to appease gcc warning. */ volatile struct gdb_exception except; + struct value *mark = value_mark (); TRY_CATCH (except, RETURN_MASK_ALL) { @@ -519,9 +528,13 @@ valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) break; } } - GDB_PY_HANDLE_EXCEPTION (except); + GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP (except, mark); + + if (res_val) + res_obj = value_to_value_object (res_val); - return res_val ? value_to_value_object (res_val) : NULL; + value_free_to_mark (mark); + return res_obj; } static PyObject * @@ -684,6 +697,7 @@ valpy_richcompare (PyObject *self, PyObject *other, int op) int result = 0; struct value *value_other; volatile struct gdb_exception except; + struct value *mark = value_mark (); if (other == Py_None) /* Comparing with None is special. From what I can tell, in Python @@ -742,6 +756,7 @@ valpy_richcompare (PyObject *self, PyObject *other, int op) break; } } + value_free_to_mark (mark); GDB_PY_HANDLE_EXCEPTION (except); /* In this case, the Python exception has already been set. */ @@ -851,7 +866,7 @@ value_to_value_object (struct value *val) if (val_obj != NULL) { val_obj->value = val; - value_incref (val); + release_value_or_incref (val); val_obj->address = NULL; val_obj->type = NULL; note_value (val_obj); diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h index 47662d9..309ee5b 100644 --- a/gdb/python/python-internal.h +++ b/gdb/python/python-internal.h @@ -149,11 +149,17 @@ PyObject *gdbpy_parameter_value (enum var_types, void *); /* Use this after a TRY_EXCEPT to throw the appropriate Python exception. */ #define GDB_PY_HANDLE_EXCEPTION(Exception) \ + GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP(Exception, NULL) + +#define GDB_PY_HANDLE_EXCEPTION_AND_CLEANUP(Exception, mark) \ do { \ - if (Exception.reason < 0) \ + if (Exception.reason < 0) { \ + if (mark) \ + value_free_to_mark (mark); \ return PyErr_Format (Exception.reason == RETURN_QUIT \ ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, \ "%s", Exception.message); \ + } \ } while (0) /* Use this after a TRY_EXCEPT to throw the appropriate Python diff --git a/gdb/value.c b/gdb/value.c index 2f31185..9187a7f 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -691,7 +691,7 @@ free_all_values (void) /* Remove VAL from the chain all_values so it will not be freed automatically. */ -void +int release_value (struct value *val) { struct value *v; @@ -699,7 +699,7 @@ release_value (struct value *val) if (all_values == val) { all_values = val->next; - return; + return 1; } for (v = all_values; v; v = v->next) @@ -707,9 +707,21 @@ release_value (struct value *val) if (v->next == val) { v->next = val->next; - break; + return 1; } } + + return 0; +} + +/* Release VAL or increment its reference count if + it was released already */ + +void +release_value_or_incref (struct value *val) +{ + if (release_value (val) == 0) + value_incref (val); } /* Release all values up to mark */ diff --git a/gdb/value.h b/gdb/value.h index 0da7031..5705210 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -595,7 +595,9 @@ extern void value_free (struct value *val); extern void free_all_values (void); -extern void release_value (struct value *val); +extern int release_value (struct value *val); + +extern void release_value_or_incref (struct value *val); extern int record_latest_value (struct value *val); --0015177404c6a1b50f047a67fec8 Content-Type: application/octet-stream; name="gdb-python-leak.patch" Content-Disposition: attachment; filename="gdb-python-leak.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_g3257vx70 Content-length: 7142 ZGlmZiAtLWdpdCBhL2dkYi9weXRob24vcHktdmFsdWUuYyBiL2dkYi9weXRo b24vcHktdmFsdWUuYwppbmRleCAxNGVmZDc5Li5mMzA1YjAxIDEwMDY0NAot LS0gYS9nZGIvcHl0aG9uL3B5LXZhbHVlLmMKKysrIGIvZ2RiL3B5dGhvbi9w eS12YWx1ZS5jCkBAIC0xNDMsNyArMTQzLDcgQEAgdmFscHlfbmV3IChQeVR5 cGVPYmplY3QgKnN1YnR5cGUsIFB5T2JqZWN0ICphcmdzLCBQeU9iamVjdCAq a2V5d29yZHMpCiAgICAgfQogCiAgIHZhbHVlX29iai0+dmFsdWUgPSB2YWx1 ZTsKLSAgdmFsdWVfaW5jcmVmICh2YWx1ZSk7CisgIHJlbGVhc2VfdmFsdWVf b3JfaW5jcmVmICh2YWx1ZSk7CiAgIHZhbHVlX29iai0+YWRkcmVzcyA9IE5V TEw7CiAgIHZhbHVlX29iai0+dHlwZSA9IE5VTEw7CiAgIG5vdGVfdmFsdWUg KHZhbHVlX29iaik7CkBAIC0yNjcsNiArMjY3LDcgQEAgdmFscHlfY2FzdCAo UHlPYmplY3QgKnNlbGYsIFB5T2JqZWN0ICphcmdzKQogewogICBQeU9iamVj dCAqdHlwZV9vYmo7CiAgIHN0cnVjdCB0eXBlICp0eXBlOworICBQeU9iamVj dCAqcmVzX29iaiA9IE5VTEw7CiAgIHN0cnVjdCB2YWx1ZSAqcmVzX3ZhbCA9 IE5VTEw7CSAgLyogSW5pdGlhbGl6ZSB0byBhcHBlYXNlIGdjYyB3YXJuaW5n LiAgKi8KICAgdm9sYXRpbGUgc3RydWN0IGdkYl9leGNlcHRpb24gZXhjZXB0 OwogCkBAIC0zMDUsOCArMzA2LDEwIEBAIHZhbHB5X2dldGl0ZW0gKFB5T2Jq ZWN0ICpzZWxmLCBQeU9iamVjdCAqa2V5KQogewogICB2YWx1ZV9vYmplY3Qg KnNlbGZfdmFsdWUgPSAodmFsdWVfb2JqZWN0ICopIHNlbGY7CiAgIGNoYXIg KmZpZWxkID0gTlVMTDsKKyAgUHlPYmplY3QgKnJlc19vYmogPSBOVUxMOwog ICBzdHJ1Y3QgdmFsdWUgKnJlc192YWwgPSBOVUxMOwogICB2b2xhdGlsZSBz dHJ1Y3QgZ2RiX2V4Y2VwdGlvbiBleGNlcHQ7CisgIHN0cnVjdCB2YWx1ZSAq bWFyayA9IHZhbHVlX21hcmsgKCk7CiAKICAgaWYgKGdkYnB5X2lzX3N0cmlu ZyAoa2V5KSkKICAgICB7ICAKQEAgLTM0NCw5ICszNDcsMTMgQEAgdmFscHlf Z2V0aXRlbSAoUHlPYmplY3QgKnNlbGYsIFB5T2JqZWN0ICprZXkpCiAgICAg fQogCiAgIHhmcmVlIChmaWVsZCk7Ci0gIEdEQl9QWV9IQU5ETEVfRVhDRVBU SU9OIChleGNlcHQpOworICBHREJfUFlfSEFORExFX0VYQ0VQVElPTl9BTkRf Q0xFQU5VUCAoZXhjZXB0LCBtYXJrKTsKKworICBpZiAocmVzX3ZhbCkKKyAg ICByZXNfb2JqID0gdmFsdWVfdG9fdmFsdWVfb2JqZWN0IChyZXNfdmFsKTsK IAotICByZXR1cm4gcmVzX3ZhbCA/IHZhbHVlX3RvX3ZhbHVlX29iamVjdCAo cmVzX3ZhbCkgOiBOVUxMOworICB2YWx1ZV9mcmVlX3RvX21hcmsgKG1hcmsp OworICByZXR1cm4gcmVzX29iajsKIH0KIAogc3RhdGljIGludApAQCAtNDI3 LDggKzQzNCwxMCBAQCBlbnVtIHZhbHB5X29wY29kZQogc3RhdGljIFB5T2Jq ZWN0ICoKIHZhbHB5X2Jpbm9wIChlbnVtIHZhbHB5X29wY29kZSBvcGNvZGUs IFB5T2JqZWN0ICpzZWxmLCBQeU9iamVjdCAqb3RoZXIpCiB7CisgIFB5T2Jq ZWN0ICpyZXNfb2JqID0gTlVMTDsKICAgc3RydWN0IHZhbHVlICpyZXNfdmFs ID0gTlVMTDsJICAvKiBJbml0aWFsaXplIHRvIGFwcGVhc2UgZ2NjIHdhcm5p bmcuICAqLwogICB2b2xhdGlsZSBzdHJ1Y3QgZ2RiX2V4Y2VwdGlvbiBleGNl cHQ7CisgIHN0cnVjdCB2YWx1ZSAqbWFyayA9IHZhbHVlX21hcmsgKCk7CiAK ICAgVFJZX0NBVENIIChleGNlcHQsIFJFVFVSTl9NQVNLX0FMTCkKICAgICB7 CkBAIC01MTksOSArNTI4LDEzIEBAIHZhbHB5X2Jpbm9wIChlbnVtIHZhbHB5 X29wY29kZSBvcGNvZGUsIFB5T2JqZWN0ICpzZWxmLCBQeU9iamVjdCAqb3Ro ZXIpCiAJICBicmVhazsKIAl9CiAgICAgfQotICBHREJfUFlfSEFORExFX0VY Q0VQVElPTiAoZXhjZXB0KTsKKyAgR0RCX1BZX0hBTkRMRV9FWENFUFRJT05f QU5EX0NMRUFOVVAgKGV4Y2VwdCwgbWFyayk7CisKKyAgaWYgKHJlc192YWwp CisgICAgcmVzX29iaiA9IHZhbHVlX3RvX3ZhbHVlX29iamVjdCAocmVzX3Zh bCk7CiAKLSAgcmV0dXJuIHJlc192YWwgPyB2YWx1ZV90b192YWx1ZV9vYmpl Y3QgKHJlc192YWwpIDogTlVMTDsKKyAgdmFsdWVfZnJlZV90b19tYXJrICht YXJrKTsKKyAgcmV0dXJuIHJlc19vYmo7CiB9CiAKIHN0YXRpYyBQeU9iamVj dCAqCkBAIC02ODQsNiArNjk3LDcgQEAgdmFscHlfcmljaGNvbXBhcmUgKFB5 T2JqZWN0ICpzZWxmLCBQeU9iamVjdCAqb3RoZXIsIGludCBvcCkKICAgaW50 IHJlc3VsdCA9IDA7CiAgIHN0cnVjdCB2YWx1ZSAqdmFsdWVfb3RoZXI7CiAg IHZvbGF0aWxlIHN0cnVjdCBnZGJfZXhjZXB0aW9uIGV4Y2VwdDsKKyAgc3Ry dWN0IHZhbHVlICptYXJrID0gdmFsdWVfbWFyayAoKTsKIAogICBpZiAob3Ro ZXIgPT0gUHlfTm9uZSkKICAgICAvKiBDb21wYXJpbmcgd2l0aCBOb25lIGlz IHNwZWNpYWwuICBGcm9tIHdoYXQgSSBjYW4gdGVsbCwgaW4gUHl0aG9uCkBA IC03NDIsNiArNzU2LDcgQEAgdmFscHlfcmljaGNvbXBhcmUgKFB5T2JqZWN0 ICpzZWxmLCBQeU9iamVjdCAqb3RoZXIsIGludCBvcCkKIAkgIGJyZWFrOwog ICAgICAgfQogICAgIH0KKyAgdmFsdWVfZnJlZV90b19tYXJrIChtYXJrKTsK ICAgR0RCX1BZX0hBTkRMRV9FWENFUFRJT04gKGV4Y2VwdCk7CiAKICAgLyog SW4gdGhpcyBjYXNlLCB0aGUgUHl0aG9uIGV4Y2VwdGlvbiBoYXMgYWxyZWFk eSBiZWVuIHNldC4gICovCkBAIC04NTEsNyArODY2LDcgQEAgdmFsdWVfdG9f dmFsdWVfb2JqZWN0IChzdHJ1Y3QgdmFsdWUgKnZhbCkKICAgaWYgKHZhbF9v YmogIT0gTlVMTCkKICAgICB7CiAgICAgICB2YWxfb2JqLT52YWx1ZSA9IHZh bDsKLSAgICAgIHZhbHVlX2luY3JlZiAodmFsKTsKKyAgICAgIHJlbGVhc2Vf dmFsdWVfb3JfaW5jcmVmICh2YWwpOwogICAgICAgdmFsX29iai0+YWRkcmVz cyA9IE5VTEw7CiAgICAgICB2YWxfb2JqLT50eXBlID0gTlVMTDsKICAgICAg IG5vdGVfdmFsdWUgKHZhbF9vYmopOwpkaWZmIC0tZ2l0IGEvZ2RiL3B5dGhv bi9weXRob24taW50ZXJuYWwuaCBiL2dkYi9weXRob24vcHl0aG9uLWludGVy bmFsLmgKaW5kZXggNDc2NjJkOS4uMzA5ZWU1YiAxMDA2NDQKLS0tIGEvZ2Ri L3B5dGhvbi9weXRob24taW50ZXJuYWwuaAorKysgYi9nZGIvcHl0aG9uL3B5 dGhvbi1pbnRlcm5hbC5oCkBAIC0xNDksMTEgKzE0OSwxNyBAQCBQeU9iamVj dCAqZ2RicHlfcGFyYW1ldGVyX3ZhbHVlIChlbnVtIHZhcl90eXBlcywgdm9p ZCAqKTsKIC8qIFVzZSB0aGlzIGFmdGVyIGEgVFJZX0VYQ0VQVCB0byB0aHJv dyB0aGUgYXBwcm9wcmlhdGUgUHl0aG9uCiAgICBleGNlcHRpb24uICAqLwog I2RlZmluZSBHREJfUFlfSEFORExFX0VYQ0VQVElPTihFeGNlcHRpb24pCQkJ CVwKKyAgICBHREJfUFlfSEFORExFX0VYQ0VQVElPTl9BTkRfQ0xFQU5VUChF eGNlcHRpb24sIE5VTEwpCisKKyNkZWZpbmUgR0RCX1BZX0hBTkRMRV9FWENF UFRJT05fQU5EX0NMRUFOVVAoRXhjZXB0aW9uLCBtYXJrKQkJCQlcCiAgICAg ZG8gewkJCQkJCQkJXAotICAgICAgaWYgKEV4Y2VwdGlvbi5yZWFzb24gPCAw KQkJCQkJCVwKKyAgICAgIGlmIChFeGNlcHRpb24ucmVhc29uIDwgMCkgewkJ CQkJXAorICAgICAgICBpZiAobWFyaykJCQkJCQlcCisgICAgICAgICAgdmFs dWVfZnJlZV90b19tYXJrIChtYXJrKTsJCQkJCQlcCiAJcmV0dXJuIFB5RXJy X0Zvcm1hdCAoRXhjZXB0aW9uLnJlYXNvbiA9PSBSRVRVUk5fUVVJVAkJXAog CQkJICAgICA/IFB5RXhjX0tleWJvYXJkSW50ZXJydXB0IDogUHlFeGNfUnVu dGltZUVycm9yLCBcCiAJCQkgICAgICIlcyIsIEV4Y2VwdGlvbi5tZXNzYWdl KTsJCQlcCisgICAgICB9CQkJCQkJXAogICAgIH0gd2hpbGUgKDApCiAKIC8q IFVzZSB0aGlzIGFmdGVyIGEgVFJZX0VYQ0VQVCB0byB0aHJvdyB0aGUgYXBw cm9wcmlhdGUgUHl0aG9uCmRpZmYgLS1naXQgYS9nZGIvdmFsdWUuYyBiL2dk Yi92YWx1ZS5jCmluZGV4IDJmMzExODUuLjkxODdhN2YgMTAwNjQ0Ci0tLSBh L2dkYi92YWx1ZS5jCisrKyBiL2dkYi92YWx1ZS5jCkBAIC02OTEsNyArNjkx LDcgQEAgZnJlZV9hbGxfdmFsdWVzICh2b2lkKQogLyogUmVtb3ZlIFZBTCBm cm9tIHRoZSBjaGFpbiBhbGxfdmFsdWVzCiAgICBzbyBpdCB3aWxsIG5vdCBi ZSBmcmVlZCBhdXRvbWF0aWNhbGx5LiAgKi8KIAotdm9pZAoraW50CiByZWxl YXNlX3ZhbHVlIChzdHJ1Y3QgdmFsdWUgKnZhbCkKIHsKICAgc3RydWN0IHZh bHVlICp2OwpAQCAtNjk5LDcgKzY5OSw3IEBAIHJlbGVhc2VfdmFsdWUgKHN0 cnVjdCB2YWx1ZSAqdmFsKQogICBpZiAoYWxsX3ZhbHVlcyA9PSB2YWwpCiAg ICAgewogICAgICAgYWxsX3ZhbHVlcyA9IHZhbC0+bmV4dDsKLSAgICAgIHJl dHVybjsKKyAgICAgIHJldHVybiAxOwogICAgIH0KIAogICBmb3IgKHYgPSBh bGxfdmFsdWVzOyB2OyB2ID0gdi0+bmV4dCkKQEAgLTcwNyw5ICs3MDcsMjEg QEAgcmVsZWFzZV92YWx1ZSAoc3RydWN0IHZhbHVlICp2YWwpCiAgICAgICBp ZiAodi0+bmV4dCA9PSB2YWwpCiAJewogCSAgdi0+bmV4dCA9IHZhbC0+bmV4 dDsKLQkgIGJyZWFrOworCSAgcmV0dXJuIDE7CiAJfQogICAgIH0KKworICBy ZXR1cm4gMDsKK30KKworLyogUmVsZWFzZSBWQUwgb3IgaW5jcmVtZW50IGl0 cyByZWZlcmVuY2UgY291bnQgaWYKKyAgIGl0IHdhcyByZWxlYXNlZCBhbHJl YWR5ICovCisKK3ZvaWQKK3JlbGVhc2VfdmFsdWVfb3JfaW5jcmVmIChzdHJ1 Y3QgdmFsdWUgKnZhbCkKK3sKKyAgaWYgKHJlbGVhc2VfdmFsdWUgKHZhbCkg PT0gMCkKKyAgICB2YWx1ZV9pbmNyZWYgKHZhbCk7CiB9CiAKIC8qIFJlbGVh c2UgYWxsIHZhbHVlcyB1cCB0byBtYXJrICAqLwpkaWZmIC0tZ2l0IGEvZ2Ri L3ZhbHVlLmggYi9nZGIvdmFsdWUuaAppbmRleCAwZGE3MDMxLi41NzA1MjEw IDEwMDY0NAotLS0gYS9nZGIvdmFsdWUuaAorKysgYi9nZGIvdmFsdWUuaApA QCAtNTk1LDcgKzU5NSw5IEBAIGV4dGVybiB2b2lkIHZhbHVlX2ZyZWUgKHN0 cnVjdCB2YWx1ZSAqdmFsKTsKIAogZXh0ZXJuIHZvaWQgZnJlZV9hbGxfdmFs dWVzICh2b2lkKTsKIAotZXh0ZXJuIHZvaWQgcmVsZWFzZV92YWx1ZSAoc3Ry dWN0IHZhbHVlICp2YWwpOworZXh0ZXJuIGludCByZWxlYXNlX3ZhbHVlIChz dHJ1Y3QgdmFsdWUgKnZhbCk7CisKK2V4dGVybiB2b2lkIHJlbGVhc2VfdmFs dWVfb3JfaW5jcmVmIChzdHJ1Y3QgdmFsdWUgKnZhbCk7CiAKIGV4dGVybiBp bnQgcmVjb3JkX2xhdGVzdF92YWx1ZSAoc3RydWN0IHZhbHVlICp2YWwpOwog Cg== --0015177404c6a1b50f047a67fec8--