[GFS2] Update copyright date to 2006
[linux-2.6.git] / fs / gfs2 / page.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License v.2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/pagemap.h>
16 #include <linux/mm.h>
17 #include <linux/gfs2_ondisk.h>
18
19 #include "gfs2.h"
20 #include "lm_interface.h"
21 #include "incore.h"
22 #include "bmap.h"
23 #include "inode.h"
24 #include "page.h"
25 #include "trans.h"
26 #include "ops_address.h"
27 #include "util.h"
28
29 /**
30  * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
31  * @gl: the glock
32  *
33  */
34
35 void gfs2_pte_inval(struct gfs2_glock *gl)
36 {
37         struct gfs2_inode *ip;
38         struct inode *inode;
39
40         ip = gl->gl_object;
41         if (!ip || !S_ISREG(ip->i_di.di_mode))
42                 return;
43
44         if (!test_bit(GIF_PAGED, &ip->i_flags))
45                 return;
46
47         inode = gfs2_ip2v_lookup(ip);
48         if (inode) {
49                 unmap_shared_mapping_range(inode->i_mapping, 0, 0);
50                 iput(inode);
51
52                 if (test_bit(GIF_SW_PAGED, &ip->i_flags))
53                         set_bit(GLF_DIRTY, &gl->gl_flags);
54         }
55
56         clear_bit(GIF_SW_PAGED, &ip->i_flags);
57 }
58
59 /**
60  * gfs2_page_inval - Invalidate all pages associated with a glock
61  * @gl: the glock
62  *
63  */
64
65 void gfs2_page_inval(struct gfs2_glock *gl)
66 {
67         struct gfs2_inode *ip;
68         struct inode *inode;
69
70         ip = gl->gl_object;
71         if (!ip || !S_ISREG(ip->i_di.di_mode))
72                 return;
73
74         inode = gfs2_ip2v_lookup(ip);
75         if (inode) {
76                 struct address_space *mapping = inode->i_mapping;
77
78                 truncate_inode_pages(mapping, 0);
79                 gfs2_assert_withdraw(ip->i_sbd, !mapping->nrpages);
80
81                 iput(inode);
82         }
83
84         clear_bit(GIF_PAGED, &ip->i_flags);
85 }
86
87 /**
88  * gfs2_page_sync - Sync the data pages (not metadata) associated with a glock
89  * @gl: the glock
90  * @flags: DIO_START | DIO_WAIT
91  *
92  * Syncs data (not metadata) for a regular file.
93  * No-op for all other types.
94  */
95
96 void gfs2_page_sync(struct gfs2_glock *gl, int flags)
97 {
98         struct gfs2_inode *ip;
99         struct inode *inode;
100
101         ip = gl->gl_object;
102         if (!ip || !S_ISREG(ip->i_di.di_mode))
103                 return;
104
105         inode = gfs2_ip2v_lookup(ip);
106         if (inode) {
107                 struct address_space *mapping = inode->i_mapping;
108                 int error = 0;
109
110                 if (flags & DIO_START)
111                         filemap_fdatawrite(mapping);
112                 if (!error && (flags & DIO_WAIT))
113                         error = filemap_fdatawait(mapping);
114
115                 /* Put back any errors cleared by filemap_fdatawait()
116                    so they can be caught by someone who can pass them
117                    up to user space. */
118
119                 if (error == -ENOSPC)
120                         set_bit(AS_ENOSPC, &mapping->flags);
121                 else if (error)
122                         set_bit(AS_EIO, &mapping->flags);
123
124                 iput(inode);
125         }
126 }
127
128 /**
129  * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
130  * @ip: the inode
131  * @dibh: the dinode buffer
132  * @block: the block number that was allocated
133  * @private: any locked page held by the caller process
134  *
135  * Returns: errno
136  */
137
138 int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
139                         uint64_t block, void *private)
140 {
141         struct gfs2_sbd *sdp = ip->i_sbd;
142         struct inode *inode = ip->i_vnode;
143         struct page *page = (struct page *)private;
144         struct buffer_head *bh;
145         int release = 0;
146
147         if (!page || page->index) {
148                 page = grab_cache_page(inode->i_mapping, 0);
149                 if (!page)
150                         return -ENOMEM;
151                 release = 1;
152         }
153
154         if (!PageUptodate(page)) {
155                 void *kaddr = kmap(page);
156
157                 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
158                        ip->i_di.di_size);
159                 memset(kaddr + ip->i_di.di_size, 0,
160                        PAGE_CACHE_SIZE - ip->i_di.di_size);
161                 kunmap(page);
162
163                 SetPageUptodate(page);
164         }
165
166         if (!page_has_buffers(page))
167                 create_empty_buffers(page, 1 << inode->i_blkbits,
168                                      (1 << BH_Uptodate));
169
170         bh = page_buffers(page);
171
172         if (!buffer_mapped(bh))
173                 map_bh(bh, inode->i_sb, block);
174
175         set_buffer_uptodate(bh);
176         if ((sdp->sd_args.ar_data == GFS2_DATA_ORDERED) || gfs2_is_jdata(ip))
177                 gfs2_trans_add_bh(ip->i_gl, bh, 0);
178         mark_buffer_dirty(bh);
179
180         if (release) {
181                 unlock_page(page);
182                 page_cache_release(page);
183         }
184
185         return 0;
186 }
187
188 /**
189  * gfs2_block_truncate_page - Deal with zeroing out data for truncate
190  *
191  * This is partly borrowed from ext3.
192  */
193 int gfs2_block_truncate_page(struct address_space *mapping)
194 {
195         struct inode *inode = mapping->host;
196         struct gfs2_inode *ip = inode->u.generic_ip;
197         struct gfs2_sbd *sdp = ip->i_sbd;
198         loff_t from = inode->i_size;
199         unsigned long index = from >> PAGE_CACHE_SHIFT;
200         unsigned offset = from & (PAGE_CACHE_SIZE-1);
201         unsigned blocksize, iblock, length, pos;
202         struct buffer_head *bh;
203         struct page *page;
204         void *kaddr;
205         int err;
206
207         page = grab_cache_page(mapping, index);
208         if (!page)
209                 return 0;
210
211         blocksize = inode->i_sb->s_blocksize;
212         length = blocksize - (offset & (blocksize - 1));
213         iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
214
215         if (!page_has_buffers(page))
216                 create_empty_buffers(page, blocksize, 0);
217
218         /* Find the buffer that contains "offset" */
219         bh = page_buffers(page);
220         pos = blocksize;
221         while (offset >= pos) {
222                 bh = bh->b_this_page;
223                 iblock++;
224                 pos += blocksize;
225         }
226
227         err = 0;
228
229         if (!buffer_mapped(bh)) {
230                 gfs2_get_block(inode, iblock, bh, 0);
231                 /* unmapped? It's a hole - nothing to do */
232                 if (!buffer_mapped(bh))
233                         goto unlock;
234         }
235
236         /* Ok, it's mapped. Make sure it's up-to-date */
237         if (PageUptodate(page))
238                 set_buffer_uptodate(bh);
239
240         if (!buffer_uptodate(bh)) {
241                 err = -EIO;
242                 ll_rw_block(READ, 1, &bh);
243                 wait_on_buffer(bh);
244                 /* Uhhuh. Read error. Complain and punt. */
245                 if (!buffer_uptodate(bh))
246                         goto unlock;
247         }
248
249         if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip))
250                 gfs2_trans_add_bh(ip->i_gl, bh, 0);
251
252         kaddr = kmap_atomic(page, KM_USER0);
253         memset(kaddr + offset, 0, length);
254         flush_dcache_page(page);
255         kunmap_atomic(kaddr, KM_USER0);
256
257 unlock:
258         unlock_page(page);
259         page_cache_release(page);
260         return err;
261 }
262
263 void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
264                             unsigned int from, unsigned int to)
265 {
266         struct buffer_head *head = page_buffers(page);
267         unsigned int bsize = head->b_size;
268         struct buffer_head *bh;
269         unsigned int start, end;
270
271         for (bh = head, start = 0;
272              bh != head || !start;
273              bh = bh->b_this_page, start = end) {
274                 end = start + bsize;
275                 if (end <= from || start >= to)
276                         continue;
277                 gfs2_trans_add_bh(ip->i_gl, bh, 0);
278         }
279 }
280