On Tue, 2007-08-21 at 02:39 +0200, Nick Piggin wrote:
quoted text
> On Mon, Aug 20, 2007 at 11:14:08PM +0200, Peter Zijlstra wrote:
> > On Mon, 2007-08-20 at 13:27 -0700, Christoph Lameter wrote:
> > > On Mon, 20 Aug 2007, Peter Zijlstra wrote:
> > >=20
> > > > > Plus the same issue can happen today. Writes are usually not comp=
leted=20
quoted text
> > > > > during reclaim. If the writes are sufficiently deferred then you =
have the=20
quoted text
> > > > > same issue now.
> > > >=20
> > > > Once we have initiated (disk) writeout we do not need more memory t=
o
quoted text
> > > > complete it, all we need to do is wait for the completion interrupt=
.
quoted text
> > >=20
> > > We cannot reclaim the page as long as the I/O is not complete. If you=
=20
quoted text
> > > have too many anonymous pages and the rest of memory is dirty then yo=
u can=20
quoted text
> > > get into OOM scenarios even without this patch.
> >=20
> > As long as the reserve is large enough to completely initialize writeou=
t
quoted text
> > of a single page we can make progress. Once writeout is initialized the
> > completion interrupt is guaranteed to happen (assuming working
> > hardware).
>=20
> Although interestingly, we are not guaranteed to have enough memory to
> completely initialise writeout of a single page.

Yes, that is due to the unbounded nature of direct reclaim, no?

I've been meaning to write some patches to address this problem in a way
that does not introduce the hard wall Linus objects to. If only I had
this extra day in the week :-/

And then there is the deadlock in add_to_swap() that I still have to
look into, I hope it can eventually be solved using reserve based
allocation.

quoted text
> The buffer layer doesn't require disk blocks to be allocated at page
> dirty-time. Allocating disk blocks can require complex filesystem operati=
ons
quoted text
> and readin of buffer cache pages. The buffer_head structures themselves m=
ay
quoted text
> not even be present and must be allocated :P
>=20
> In _practice_, this isn't such a problem because we have dirty limits, an=
d
quoted text
> we're almost guaranteed to have some clean pages to be reclaimed. In this
> same way, networked filesystems are not a problem in practice. However
> network swap, because there is no dirty limits on swap, can actually see
> the deadlock problems.

The main problem with networked swap is not so much sending out the
pages (this has similar problems like the filesystems but is all bounded
in its memory use).

The biggest issue is receiving the completion notification. Network
needs to fall back to a state where it does not blindly consumes memory
or drops _all_ packets. An intermediate state is required, one where we
can receive and inspect incoming packets but commit to very few.

In order to create such a network state and for it to be stable, a
certain amount of memory needs to be available and an external trigger
is needed to enter and leave this state - currently provided by there
being more memory available than needed or not.