Skip to content

Commit 8c684eb

Browse files
coolreader18coolreader18
committed
Don't lock textio while calling buffer methods
1 parent 211e7ca commit 8c684eb

1 file changed

Lines changed: 32 additions & 32 deletions

File tree

‎vm/src/stdlib/io.rs‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1877,8 +1877,9 @@ mod _io {
18771877
}
18781878

18791879
#[pymethod]
1880-
fn seekable(_self: PyObjectRef) -> bool {
1881-
true
1880+
fn seekable(&self, vm: &VirtualMachine) -> PyResult {
1881+
let buffer = self.lock(vm)?.buffer.clone();
1882+
vm.get_attribute(buffer, "seekable")
18821883
}
18831884

18841885
#[pymethod]
@@ -1888,7 +1889,7 @@ mod _io {
18881889
how: OptionalArg<i32>,
18891890
vm: &VirtualMachine,
18901891
) -> PyResult {
1891-
let data = self.lock(vm)?;
1892+
let buffer = self.lock(vm)?.buffer.clone();
18921893
let offset = get_offset(offset, vm)?;
18931894
let how = how.unwrap_or(0);
18941895
if how == 1 && offset != 0 {
@@ -1902,33 +1903,33 @@ mod _io {
19021903
"can't do nonzero end-relative seeks".to_owned(),
19031904
));
19041905
}
1905-
call_method(vm, &data.buffer, "seek", (offset, how))
1906+
call_method(vm, &buffer, "seek", (offset, how))
19061907
}
19071908

19081909
#[pymethod]
19091910
fn tell(&self, vm: &VirtualMachine) -> PyResult {
1910-
let data = self.lock(vm)?;
1911-
call_method(vm, &data.buffer, "tell", ())
1911+
let buffer = self.lock(vm)?.buffer.clone();
1912+
call_method(vm, &buffer, "tell", ())
19121913
}
19131914

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

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

19261927
#[pymethod]
19271928
fn read(&self, size: OptionalOption<PyObjectRef>, vm: &VirtualMachine) -> PyResult<String> {
1928-
let data = self.lock(vm)?;
1929-
check_readable(&data.buffer, vm)?;
1929+
let buffer = self.lock(vm)?.buffer.clone();
1930+
check_readable(&buffer, vm)?;
19301931

1931-
let bytes = call_method(vm, &data.buffer, "read", (size.flatten(),))?;
1932+
let bytes = call_method(vm, &buffer, "read", (size.flatten(),))?;
19321933
let bytes = PyBytesLike::try_from_object(vm, bytes)?;
19331934
//format bytes into string
19341935
let rust_string = String::from_utf8(bytes.to_cow().into_owned()).map_err(|e| {
@@ -1944,14 +1945,14 @@ mod _io {
19441945
fn write(&self, obj: PyStrRef, vm: &VirtualMachine) -> PyResult<usize> {
19451946
use std::str::from_utf8;
19461947

1947-
let data = self.lock(vm)?;
1948-
check_writable(&data.buffer, vm)?;
1948+
let buffer = self.lock(vm)?.buffer.clone();
1949+
check_writable(&buffer, vm)?;
19491950

19501951
let bytes = obj.borrow_value().as_bytes();
19511952

1952-
let len = call_method(vm, &data.buffer, "write", (bytes.to_owned(),));
1953+
let len = call_method(vm, &buffer, "write", (bytes.to_owned(),));
19531954
if obj.borrow_value().contains('\n') {
1954-
let _ = call_method(vm, &data.buffer, "flush", ());
1955+
let _ = call_method(vm, &buffer, "flush", ());
19551956
}
19561957
let len = usize::try_from_object(vm, len?)?;
19571958

@@ -1965,16 +1966,16 @@ mod _io {
19651966

19661967
#[pymethod]
19671968
fn flush(&self, vm: &VirtualMachine) -> PyResult {
1968-
let data = self.lock(vm)?;
1969-
check_closed(&data.buffer, vm)?;
1970-
call_method(vm, &data.buffer, "flush", ())
1969+
let buffer = self.lock(vm)?.buffer.clone();
1970+
check_closed(&buffer, vm)?;
1971+
call_method(vm, &buffer, "flush", ())
19711972
}
19721973

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

19801981
#[pymethod]
@@ -1983,10 +1984,10 @@ mod _io {
19831984
size: OptionalOption<PyObjectRef>,
19841985
vm: &VirtualMachine,
19851986
) -> PyResult<String> {
1986-
let data = self.lock(vm)?;
1987-
check_readable(&data.buffer, vm)?;
1987+
let buffer = self.lock(vm)?.buffer.clone();
1988+
check_readable(&buffer, vm)?;
19881989

1989-
let bytes = call_method(vm, &data.buffer, "readline", (size.flatten(),))?;
1990+
let bytes = call_method(vm, &buffer, "readline", (size.flatten(),))?;
19901991
let bytes = PyBytesLike::try_from_object(vm, bytes)?;
19911992
//format bytes into string
19921993
let rust_string = String::from_utf8(bytes.borrow_value().to_vec()).map_err(|e| {
@@ -2000,18 +2001,17 @@ mod _io {
20002001

20012002
#[pymethod]
20022003
fn close(&self, vm: &VirtualMachine) -> PyResult {
2003-
let data = self.lock(vm)?;
2004-
call_method(vm, &data.buffer, "close", ())
2004+
let buffer = self.lock(vm)?.buffer.clone();
2005+
call_method(vm, &buffer, "close", ())
20052006
}
20062007
#[pyproperty]
20072008
fn closed(&self, vm: &VirtualMachine) -> PyResult {
2008-
let data = self.lock(vm)?;
2009-
vm.get_attribute(data.buffer.clone(), "closed")
2009+
let buffer = self.lock(vm)?.buffer.clone();
2010+
vm.get_attribute(buffer, "closed")
20102011
}
20112012
#[pyproperty]
20122013
fn buffer(&self, vm: &VirtualMachine) -> PyResult {
2013-
let data = self.lock(vm)?;
2014-
Ok(data.buffer.clone())
2014+
Ok(self.lock(vm)?.buffer.clone())
20152015
}
20162016

20172017
#[pymethod(magic)]

0 commit comments

Comments
 (0)