Sedangkan pagecache SVR4 hanya digunakan untuk cache data filesystem dan dengan demikian menggunakan struct vnode dan offset ke dalam file sebagai parameter hash, cache halaman Linux dirancang untuk menjadi lebih umum, dan karena itu menggunakan struct address_space (dijelaskan di bawah) sebagai parameter pertama. Karena pagecache Linux digabungkan dengan erat notasi dari address spaces, Anda akan membutuhkan setidaknya pemahaman dasar dari adress_spaces untuk memahami cara pagecache bekerja. Sebuah address_space adalah sejenis perangkat lunak MMU yang memetakan semua halaman dari satu objek (misalnya inode) ke konkurensi lainnya (biasanya blok disk fisik). Struct address_space adalah didefinisikan di include/linux/fs.h sebagai berikut:
struct address_space {
struct list_head
unsigned long
struct address_space_operations *
void *
struct vm_area_struct *
struct vm_area_struct *
spinlock_t
};
pages;
nrpages;
a_ops;
host;
i_mmap;
i_mmap_shared;
i_shared_lock;
Untuk memahami cara address_spaces berfungsi, kita hanya perlu melihat beberapa bidang ini: halaman adalah gabungan daftar tertaut dari semua halaman yang termasuk dalam address_space ini, nrpages adalah jumlah halaman dalam halaman, a_ops mendefinisikan metode address_space dan host ini adalah opaque pointer ke objek address_space yang dimilik. Penggunaan halaman dan nrpages sangat jelas, jadi kita akan melihat lebih rinci struktur address_space_operations, didefinisikan dalam header yang sama:
struct address_space_operations {Untuk pandangan dasar pada prinsip address_spaces (dan pagecache) yang perlu kita lihat-> writepage dan ->readpage, tetapi dalam prakteknya kita perlu melihat ->prepare_write dan
int (*writepage)(struct page *);
int (*readpage)(struct file *, struct page *);
int (*sync_page)(struct page *);
int (*prepare_write)(struct file *,
struct page *, unsigned, unsigned);
int (*commit_write)(struct file *,
struct page *, unsigned, unsigned);
int (*bmap)(struct address_space *, long);
};
-> commit_write juga.
Dengan hanya melihat nama-nama Anda mungkin bisa menebak apa metode ini, tetapi untuk menjelaskannya, akan melihat pengguna terbesar pagecache di Linux: data filesystem IO. Tidak seperti kebanyakan UNIX-like sistem operasi, Linux memiliki operasi file generik (subset dari operasi SYNVish vnode) untuk data IO melalui pagecache. Ini berarti bahwa data tidak akan langsung berinteraksi dengan sistem file di read/write/mmap, tetapi akan dibaca read/written from/ ke pagecache bila memungkinkan. Pagecache harus mendapatkan data dari filesystem low − level yang sebenarnya dalam hal pengguna ingin membaca dari halaman yang belum di memori, atau menulis data ke disk dalam hal memori menjadi rendah.
Di jalur baca, generic methods akan mencoba mencari halaman yang cocok dengan inode/index tuple.
hash = page_hash(inode−>i_mapping, index);Untuk mencoba apakah halaman tersebut benar-benar ada.
hash = page_hash(inode−>i_mapping, index); page =Ketika tidak ada, akan mengalokasikan free page baru, dan menambahkannya ke page− cache hash.
__find_page_nolock(inode−>i_mapping, index, *hash);
page = page_cache_alloc(); __add_to_page_cache(page, mapping,
index, hash);
Setelah halaman di-hash, menjalankan Operasi −>readpage address_space untuk benar-benar mengisi halaman dengan data.
error = mapping−>a_ops−>readpage(file, page);Untuk menulis ke filesystem ada dua jalur: satu untuk pemetaan yang dapat ditulis (mmap) dan satu untuk menulis (2) keluarga dari syscalls. Kasus mmap sangat sederhana, jadi ini akan dibahas lebih dulu. Ketika pengguna memodifikasi pemetaan, subsistem VM menandai halaman kotor.
SetPageDirty(page);Bit kernel bdflush yang mencoba untuk membuat halaman kosong, baik sebagai aktivitas latar belakang atau karena kehabisan memori akan mencoba untuk memanggil ->writepage pada halaman yang ditandai dengan jelas kotor.
cara kedua adalah _much_ lebih rumit. Untuk setiap halaman yang ditulis pengguna, pada dasarnya menggunakan: (for the full code see mm/filemap.c:generic_file_write()).
page = __grab_cache_page(mapping, index, &cached_page);Jadi pertama kita mencoba untuk menemukan halaman hash atau mengalokasikan yang baru, kemudian kita panggil >prepare_write address_space method, copy buffer pengguna ke memori kernel dan akhiri dengan −>commit_write method.Seperti yang mungkin Anda lihat −>prepare_write dan −>commit_write adalah secara fundamental berbeda dari −>readpage dan −>writepage, karena mereka tidak hanya dipanggil kapan physical IO sebenarnya diinginkan tetapi setiap kali pengguna memodifikasi file. Ada dua (atau lebih?) Cara untuk menangani ini, yang pertama menggunakan buffercache Linux untuk menunda physical IO, dengan mengisi page−>buffers pointer dengan buffer_heads yang akan digunakan try_to_free_buffers (fs/buffers.c) request IO sekali memori menjadi rendah, dan digunakan sangat luas di kernel saat ini. Cara lain hanya set halaman kotor dan bergantung pada −>writepage untuk melakukan semua pekerjaan. Karena kurangnya bitmap validitas di struct Halaman ini tidak berfungsi dengan filesystem yang memiliki granularitas lebih kecil kemudian PAGE_SIZE.
mapping−>a_ops−>prepare_write(file, page, offset,
offset+bytes); copy_from_user(kaddr+offset, buf, bytes);
mapping−>a_ops−>commit_write(file, page, offset,
offset+bytes);
0 Response to "Pengertian dan Penggunaan Linux Page Cache"
Posting Komentar
1. Berkomentar sesuai dengan topik artikel;
2. Menggunakan bahasa yang sopan;
3. Dilarang menyinggung SARA, Agama, dan berbau pornografi.