EXT2_FILE_WRITE




Ta funkcja pochodzi z pliku fs\ext2\file.c.

Funkcja write - kod zrodlowy cz.2 (system Ext2)

Link do: cz.1 kodu.

static int ext2_file_write (struct inode * inode, struct file * filp,
const char * buf, int count)
{
const loff_t two_gb = 2147483647;
loff_t pos;
off_t pos2;
long block;
int offset;
int written, c;
struct buffer_head * bh, *bufferlist[NBUF];
/* 16 */
struct super_block * sb;
int err;
int i,buffercount,write_error;

write_error = buffercount = 0;
if (!inode) {
printk("ext2_file_write: inode = NULL\n");
return -EINVAL;
}
sb = inode->i_sb;
if (sb->s_flags & MS_RDONLY)
/* fs jest readonly
* This fs has been automatically remounted ro because of errors
*/
return -ENOSPC;

if (!S_ISREG(inode->i_mode)) {
/* stat.h:
sprawdzenie, czy jestesmy plikiem regularnym, tzn.
nie gniazdem, linkiem, urz. blokowym, ani znakowym,
katalogiem, ani FIFO
- ta informacja jest w ostanich 4 bitach slowa dostepu
do pliku w i-wezle */

ext2_warning (sb, "ext2_file_write", "mode = %07o",
inode->i_mode);
return -EINVAL;
}
if (filp->f_flags & O_APPEND)
/* plik do nadpisywania - to zacznij pisac na koncu pliku*/
pos = inode->i_size;
else
pos = filp->f_pos;
/* zacznij na aktualnej pozycji */

pos2 = (off_t) pos;
/* Jesli plik byl otworzony w trybie synchronicznym, ustawiamy pole i_osync.

Te pole jest testowane przez 'allocation routines' (cos z obsluga pamieci)*/

if (filp->f_flags & O_SYNC)
inode->u.ext2_i.i_osync++;

/* 'u' to unia, ktora mowi o dodatkowej informacji o i-wezle
ktora jest trzymana w pamieci,
w zaleznosci od filesystemu, w ext2, jest to:
struct ext2_inode_info ext2_i;
(plik ext2_fs_i.h). Komentarz do uzywania i_osync jest
na gorze, ale ja nie wiem o co chodzi z tym meta-data i
allocation routines.
*/

block = pos2 >> EXT2_BLOCK_SIZE_BITS(sb);

/* daje to numer bloku logicznego, w ktorym jest bajt nr. pos2 w
pliku */


offset = pos2 & (sb->s_blocksize - 1);

/* to daje offset, czyli przesuniecie w bloku szukanego bajtu
poczatku pisania - liczy modulo s_blocksize */

c = sb->s_blocksize - offset;

/* zmienna c ma wskazywac ile bajtow mamy zapisac w
danym bloku.
Na poczatku ustalamy, ze zapisujemy
do konca bloku, pozniej sprawdzimy, czy count<c,
to znaczyloby, ze trzeba mniej zapisac, niz do koca
bloku, no i ustawimy c na count, czyli bedzie dobrze.*/

written = 0; /* 0 bajtow zapisanych */


while (count > 0) {
if (pos > two_gb) {
/* wyszlismy za 2GB */
if (!written)
written = -EFBIG;
break;
}
bh = ext2_getblk (inode, block, 1, &err);

/* bh to buffer_head (poprzedni temat to omawial),
getblk pobiera blok (tzn. zwraca bufor z tym blokiem,
bo wszystkie operacje na blokach sa buforowane), ktory
zawiera dane z bloku logicznego o numerze block w pliku */

if (!bh) {
if (!written)
written = err;
break;
}

count -= c;
if (count < 0)
c += count;
/* tutaj sie okazalo, ze w danym bloku mamy zapisac mniej
niz c bajtow, wiec ustalamy ilosc bajtow do zapisania
na count, bo c:= c + (count - c) = count. */

if (c != sb->s_blocksize && !buffer_uptodate(bh)) {

/* c==blocksize oznacza, ze mamy zapisac caly blok,
i nie ma potrzeby sprawdzac, czy bufor jest
aktualny, bo i tak go zamazemy */

ll_rw_block (READ, 1, &bh);

/* ta funkcja zajmuje sie wykonywaniem zadan
wejscia/wyjscia na urzadzeniu blokowym,
czyli wczytujemy bufor, potem czekamy
w kolejce na bufor */

wait_on_buffer (bh);
if (!buffer_uptodate(bh)) {

/* nic nie wyszlo z aktualizacji bufora, to
wyjdziemy zaraz z bledem */

brelse (bh);
if (!written)
written = -EIO;
break;
}
}
memcpy_fromfs (bh->b_data + offset, buf, c);

/* zapis do bufora w pamieci z danych 'buf' */

update_vm_cache(inode, pos, bh->b_data + offset, c);

/* ta funkcja sluzy tylko do write,
aktualizacja Virtual Memory Cache odnosnie
danego bloku - pobranie stron, zapisanie ich
i zwolnienie.
Wyglada na to, ze jest jakis proces wykonujacy
cash dla plikow.
Nie wiem, co to jest, kod za write'm.
Jesli plik nie jest do pisania synchronicznego,
to w tym miejscu dokonuje sie zapis na dysk.

Prawdopodobnie, dzieki polu i_osync, cashowanie
pliku (allocation routines) jest inne, i nie ma
zapisywania po jednym bloku, ale dopiero gdy
zapelni sie tablica, na dole */

pos2 += c;
pos += c;
written += c;
buf += c;
mark_buffer_uptodate(bh, 1);
mark_buffer_dirty(bh, 0);

/* zaznaczenie, ze bufor jest aktualny i nie jest brudny */

if (filp->f_flags & O_SYNC)
bufferlist[buffercount++] = bh;

/* jesli plik jest do pisania synchronicznego, to przechowuj
bufor w tablicy nie zapisujac go tak dlugo az sie
zapelni (rozmiar 16) */

else
brelse(bh);
/* a jak nie, to go zwolnij */

if (buffercount == NBUF){
/* zapelnilismy tablice, to ja cala zapiszemy */

ll_rw_block(WRITE, buffercount, bufferlist);
for(i=0; i<buffercount; i++){
wait_on_buffer(bufferlist[i]);
/* czekamy az sie zapisze */

if (!buffer_uptodate(bufferlist[i]))
write_error=1;
brelse(bufferlist[i]);
/* zwalniamy bufor */
}
buffercount=0;
}
if(write_error)
break;
block++;
/* zajmij sie nastepnym blokiem w pliku */
offset = 0;
/* zaczniemy pisac od zerowego offsetu w bloku */
c = sb->s_blocksize;
/* bajtow do konca bloku od offsetu jest blocksize */
}
if ( buffercount ){
/* zapisujemy to, co jeszcze zostalo, tak samo, jak poprzenio */

ll_rw_block(WRITE, buffercount, bufferlist);
for(i=0; i<buffercount; i++){
wait_on_buffer(bufferlist[i]);
if (!buffer_uptodate(bufferlist[i]))
write_error=1;
brelse(bufferlist[i]);
}
}
if (pos > inode->i_size)
inode->i_size = pos;
/* uaktualnienie rozmiaru pliku */

if (filp->f_flags & O_SYNC)
inode->u.ext2_i.i_osync--;
/* cos z pisaniem synchronicznym - pisalo, ze pole i_osync jest
uzywane przez "allocation routines" */

inode->i_ctime = inode->i_mtime = CURRENT_TIME;

/* change time i modification time jest ustalane na aktualny czas */

filp->f_pos = pos;
/* pozycja w tablicy plikow jest ustawiana na ta, gdzie skonczylismy
pisac */

inode->i_dirt = 1;
/* zaznaczamy, ze i-wezel jest brudny, to chyba znaczy, ze go
modyfikowalismy w pamieci, ale nie na dysku */

return written;
}



struct inode {
time_t i_atime; - czas ostatniego dostepu do pliku
time_t i_mtime; - czas ostatniej modyfikacji pliku
time_t i_ctime; - czas ostatniej modyfikacji i-wezla (?)
...

}