Skip to content

Commit 60d917c

Browse files
coolreader18coolreader18
committed
Don't lock textio while calling buffer methods
1 parent 1d6b32c commit 60d917c

File tree

1 file changed

+32
-32
lines changed

1 file changed

+32
-32
lines changed

‎vm/src/stdlib/io.rs‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1883,8 +1883,9 @@ mod _io {
18831883
}
18841884

18851885
#[pymethod]
1886-
fn seekable(_self: PyObjectRef) -> bool {
1887-
true
1886+
fn seekable(&self, vm: &VirtualMachine) -> PyResult {
1887+
let buffer = self.lock(vm)?.buffer.clone();
1888+
vm.get_attribute(buffer, "seekable")
18881889
}
18891890

18901891
#[pymethod]
@@ -1894,7 +1895,7 @@ mod _io {
18941895
how: OptionalArg<i32>,
18951896
vm: &VirtualMachine,
18961897
) -> PyResult {
1897-
let data = self.lock(vm)?;
1898+
let buffer = self.lock(vm)?.buffer.clone();
18981899
let offset = get_offset(offset, vm)?;
18991900
let how = how.unwrap_or(0);
19001901
if how == 1 && offset != 0 {
@@ -1908,33 +1909,33 @@ mod _io {
19081909
"can't do nonzero end-relative seeks".to_owned(),
19091910
));
19101911
}
1911-
call_method(vm, &data.buffer, "seek", (offset, how))
1912+
call_method(vm, &buffer, "seek", (offset, how))
19121913
}
19131914

19141915
#[pymethod]
19151916
fn tell(&self, vm: &VirtualMachine) -> PyResult {
1916-
let data = self.lock(vm)?;
1917-
call_method(vm, &data.buffer, "tell", ())
1917+
let buffer = self.lock(vm)?.buffer.clone();
1918+
call_method(vm, &buffer, "tell", ())
19181919
}
19191920

19201921
#[pyproperty]
19211922
fn name(&self, vm: &VirtualMachine) -> PyResult {
1922-
let data = self.lock(vm)?;
1923-
vm.get_attribute(data.buffer.clone(), "name")
1923+
let buffer = self.lock(vm)?.buffer.clone();
1924+
vm.get_attribute(buffer, "name")
19241925
}
19251926

19261927
#[pymethod]
19271928
fn fileno(&self, vm: &VirtualMachine) -> PyResult {
1928-
let data = self.lock(vm)?;
1929-
call_method(vm, &data.buffer, "fileno", ())
1929+
let buffer = self.lock(vm)?.buffer.clone();
1930+
call_method(vm, &buffer, "fileno", ())
19301931
}
19311932

19321933
#[pymethod]
19331934
fn read(&self, size: OptionalOption<PyObjectRef>, vm: &VirtualMachine) -> PyResult<String> {
1934-
let data = self.lock(vm)?;
1935-
check_readable(&data.buffer, vm)?;
1935+
let buffer = self.lock(vm)?.buffer.clone();
1936+
check_readable(&buffer, vm)?;
19361937

1937-
let bytes = call_method(vm, &data.buffer, "read", (size.flatten(),))?;
1938+
let bytes = call_method(vm, &buffer, "read", (size.flatten(),))?;
19381939
let bytes = PyBytesLike::try_from_object(vm, bytes)?;
19391940
//format bytes into string
19401941
let rust_string = String::from_utf8(bytes.to_cow().into_owned()).map_err(|e| {
@@ -1950,14 +1951,14 @@ mod _io {
19501951
fn write(&self, obj: PyStrRef, vm: &VirtualMachine) -> PyResult<usize> {
19511952
use std::str::from_utf8;
19521953

1953-
let data = self.lock(vm)?;
1954-
check_writable(&data.buffer, vm)?;
1954+
let buffer = self.lock(vm)?.buffer.clone();
1955+
check_writable(&buffer, vm)?;
19551956

19561957
let bytes = obj.borrow_value().as_bytes();
19571958

1958-
let len = call_method(vm, &data.buffer, "write", (bytes.to_owned(),));
1959+
let len = call_method(vm, &buffer, "write", (bytes.to_owned(),));
19591960
if obj.borrow_value().contains('\n') {
1960-
let _ = call_method(vm, &data.buffer, "flush", ());
1961+
let _ = call_method(vm, &buffer, "flush", ());
19611962
}
19621963
let len = usize::try_from_object(vm, len?)?;
19631964

@@ -1971,16 +1972,16 @@ mod _io {
19711972

19721973
#[pymethod]
19731974
fn flush(&self, vm: &VirtualMachine) -> PyResult {
1974-
let data = self.lock(vm)?;
1975-
check_closed(&data.buffer, vm)?;
1976-
call_method(vm, &data.buffer, "flush", ())
1975+
let buffer = self.lock(vm)?.buffer.clone();
1976+
check_closed(&buffer, vm)?;
1977+
call_method(vm, &buffer, "flush", ())
19771978
}
19781979

19791980
#[pymethod]
19801981
fn isatty(&self, vm: &VirtualMachine) -> PyResult {
1981-
let data = self.lock(vm)?;
1982-
check_closed(&data.buffer, vm)?;
1983-
call_method(vm, &data.buffer, "isatty", ())
1982+
let buffer = self.lock(vm)?.buffer.clone();
1983+
check_closed(&buffer, vm)?;
1984+
call_method(vm, &buffer, "isatty", ())
19841985
}
19851986

19861987
#[pymethod]
@@ -1989,10 +1990,10 @@ mod _io {
19891990
size: OptionalOption<PyObjectRef>,
19901991
vm: &VirtualMachine,
19911992
) -> PyResult<String> {
1992-
let data = self.lock(vm)?;
1993-
check_readable(&data.buffer, vm)?;
1993+
let buffer = self.lock(vm)?.buffer.clone();
1994+
check_readable(&buffer, vm)?;
19941995

1995-
let bytes = call_method(vm, &data.buffer, "readline", (size.flatten(),))?;
1996+
let bytes = call_method(vm, &buffer, "readline", (size.flatten(),))?;
19961997
let bytes = PyBytesLike::try_from_object(vm, bytes)?;
19971998
//format bytes into string
19981999
let rust_string = String::from_utf8(bytes.borrow_value().to_vec()).map_err(|e| {
@@ -2006,18 +2007,17 @@ mod _io {
20062007

20072008
#[pymethod]
20082009
fn close(&self, vm: &VirtualMachine) -> PyResult {
2009-
let data = self.lock(vm)?;
2010-
call_method(vm, &data.buffer, "close", ())
2010+
let buffer = self.lock(vm)?.buffer.clone();
2011+
call_method(vm, &buffer, "close", ())
20112012
}
20122013
#[pyproperty]
20132014
fn closed(&self, vm: &VirtualMachine) -> PyResult {
2014-
let data = self.lock(vm)?;
2015-
vm.get_attribute(data.buffer.clone(), "closed")
2015+
let buffer = self.lock(vm)?.buffer.clone();
2016+
vm.get_attribute(buffer, "closed")
20162017
}
20172018
#[pyproperty]
20182019
fn buffer(&self, vm: &VirtualMachine) -> PyResult {
2019-
let data = self.lock(vm)?;
2020-
Ok(data.buffer.clone())
2020+
Ok(self.lock(vm)?.buffer.clone())
20212021
}
20222022

20232023
#[pymethod(magic)]

0 commit comments

Comments
 (0)