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 (?) ... }