Date: Fri, 7 Sep 2001 15:48:36 +0200
From: "Peter J. Holzer" <hjp-luga@hjp.at>
To: luga@luga.at
Subject: Re: [luga] gleichzeitiges schreiben und lesen von Files
Message-ID: <20010907154836.B29189@teal.h.hjp.at>
Mail-Followup-To: luga@luga.at
References: <01090701431800.00439@linuxdaheim> <20010907070744.A1095@minsky.haberstroh.at> <20010907093800.B31821@wsr.ac.at> <01090715495202.00439@linuxdaheim>
Mime-Version: 1.0
Content-Type: multipart/signed; micalg=pgp-md5;
	protocol="application/pgp-signature"; boundary="NMuMz9nt05w80d4+"
Content-Disposition: inline
User-Agent: Mutt/1.3.17i
In-Reply-To: <01090715495202.00439@linuxdaheim>; from bz@datenkueche.com on Fri, Sep 07, 2001 at 03:49:52PM +0200
Sender: owner-luga@luga.or.at
Content-Length: 4437


--NMuMz9nt05w80d4+
Content-Type: text/plain; charset=iso-8859-1
Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable

On 2001-09-07 15:49:52 +0200, Bernhard Zwischenbrugger wrote:
> On Friday 07 September 2001 09:38, you wrote:
> > On 2001-09-07 07:07:44 +0200, Harald R. Haberstroh wrote:
> > > Bernhard Zwischenbrugger hod am Fri, 07.09.2001 um 01:43 gsogt:
> > > > Prozess A hat schreibenden Zugriff auf File XY. File XY hat
> > > > einen g=FCltigen Status vor und nach dem Schreibzugriff. W=E4rend
> > > > dem Schreibzugriff hat das File XY eventuell einen ung=FCltigen
> > > > Status. Der Schreibende Zugriff dauert ein bisschen l=E4nger -
> > > > sagen wir mal 5 Sekunden.
> > > >
> > > > Prozess B liest in dieser Zeit das File XY.
> > > >
> > > > Kann es nun sein, dass das File XY beim lesen einen ung=FCltigen
> > > > Status hat?
> > >
> > > JA
> >
> > Ack. Wobei das nichts mit der zeitlichen Dauer des Schreibzugriffs
> > zu tun hat. Ein einzelnes write ist immer atomic, selbst wenn ich
> > ein Gigabyte rausschreibe und das eine Minute dauert. Zwei writes
> > sind nicht atomic, und ein anderer Prozess kann zwischen dem ersten
> > und dem zweiten write das File im inkonsistenten Zustand lesen,
> > selbst wenn beide writes nur ein Byte schreiben und im Programm
> > unmittelbar aufeinander folgen.
>
> Danke f=FCr die Antworten.
>
> Ich weiss jetzt nicht genau ob ich das richtig verstanden hab. Ein
> Beispiel:
>
> Prozess A baut einen langen String mit 10 MByte auf. Der Prozess A
> schreibt diese 10 MByte auf das File XY. Der Schreibprozess dauert 500
> ms. Ist dieser Schreibvorgang ist nun atomic?

Ja.

> Prozess B liest das File XY w=E4rend dem Schreibvorgang von Prozess A -
> sagen wir 200ms nachdem der Schreibvorgang begonnen hat.
>
> Der Schreibvorgang ist atomic, Prozess B findet kein g=FCltiges File.
> Wartet Prozess B jetzt bis der Schreibvorgang beendet ist?

Entweder das, oder der Kernel mu=DF den alten Zustand noch irgendwo
gespeichert halten, damit der Prozess diesen sieht. Welche der beiden
Varianten gew=E4hlt wird, h=E4ngt wohl vom Filesystem ab (Ich w=FCrde
annehmen, da=DF bei "traditionellen" Filesystemen eher gewartet, bei
journalling Filesystemen eher der alte Zustand genommen wird).

> W=FCrde der schreibende Prozess warten bis alle Lesevorg=E4nge beendet   ?
> sind Kann man da mit "flush" etwas vern=FCnfiges Zaubern               ?

Was ist flush? Wenn Du fflush meinst, dann ist das eine stdio-Funktion,
die nur write aufruft. Eventuell kannst Du in der Stdio einen sehr
gro=DFen Buffer setzen und mit fflush genau dann flushen, wenn Du einen
konsistenten Zustand hast. Ich w=FCrde da aber eher zu den
low-level-Funktionen (read, write) greifen, da wei=DF man, was passiert.


> Prozess B ist =FCbrigens ein xslt Prozessor (xsltproc von gnome) der ein
> XML-File an einem St=FCck einliest, parsed und dann die Verarbeitung
> startet. Ist dieser Lesevorgang nun atomic oder nicht?

Vermutlich nicht. Wie genau liest der das File "in einem St=FCck" ein?
Zuerst ein (f)stat um die L=E4nge zu bestimmen, dann ein malloc und ein
read? Da kann das File zwischen fstat und read die L=E4nge =E4ndern. Wenn
das nicht passieren kann, mu=DF das File gelockt werden.

Es gibt =FCbrigens noch einen (h=E4ufig angewendeten) Trick, um Files atomic
zu =E4ndern: Das neue File wird unter einem neuen, eindeutigen Namen
angelegt, und erst wenn es fertig ist, umbenannt. Jeder lesende Prozess
hat dann eine konsistente Version. Geht nat=FCrlich nur bei Files, die
=FCblicherweise ge=F6ffnet, gelesen und wieder geschlossen werden. Ein
Prozess, der das File nicht wieder schlie=DFt, bekommt keine =C4nderungen
mit.

> Wie kann man sowas rausfinden?

strace oder Source-Code.

	hp

--=20
   _  | Peter J. Holzer    | Oder glaubst du "Bugtraq" waere eine
|_|_) | Sysadmin WSR       | Science-Fiction TV-Serie ueber Schaben
| |   | hjp@hjp.at         | im Weltall?
__/   | http://www.hjp.at/ |	-- Juergen P. Meier in dcsm

--NMuMz9nt05w80d4+
Content-Type: application/pgp-signature
Content-Disposition: inline

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.0.6 (GNU/Linux)
Comment: For info see http://www.gnupg.org

iQCVAwUBO5jQNMWZRTFRD2FBAQFhkQQAmkbDLfHnoBiF19wmfkiz1zynkt8CWt2S
rfVGzisTFlzv2JX/UOA4MN+I6xqFGuyUA0+Knd6tV19pO9tiZQvh+spbd/85jZda
9eIfacYTgulL8otkQV9mmC5PVaJC42WJ2AKoDZMFzlttYcFtYldJD66y+YxcK4+W
28ieuEah7wk=
=IDn9
-----END PGP SIGNATURE-----

--NMuMz9nt05w80d4+--