Eric Lee / linux-smarc-t335x-v3.2

Download as
Browse Code ยป

Commit f5c54804d9e3bb23d8924af09d9ca1c8de9560b6

Authored by Steven Whitehouse
1 parent 52ae7b7935
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

[GFS2] Fix uninitialised variable 

This fixes a bug where, in certain cases an uninitialised variable
could cause a dereference of a NULL pointer in gfs2_commit_write().
Also a typo in a comment is fixed at the same time.

Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

Showing 2 changed files with 2 additions and 1 deletions Inline Diff

fs/gfs2/ops_address.c
Diff comments   View file @ f5c5480
1 /* 1 /*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4 * 4 *
5 * This copyrighted material is made available to anyone wishing to use, 5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions 6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2. 7 * of the GNU General Public License version 2.
8 */ 8 */
9 9
10 #include <linux/sched.h> 10 #include <linux/sched.h>
11 #include <linux/slab.h> 11 #include <linux/slab.h>
12 #include <linux/spinlock.h> 12 #include <linux/spinlock.h>
13 #include <linux/completion.h> 13 #include <linux/completion.h>
14 #include <linux/buffer_head.h> 14 #include <linux/buffer_head.h>
15 #include <linux/pagemap.h> 15 #include <linux/pagemap.h>
16 #include <linux/pagevec.h> 16 #include <linux/pagevec.h>
17 #include <linux/mpage.h> 17 #include <linux/mpage.h>
18 #include <linux/fs.h> 18 #include <linux/fs.h>
19 #include <linux/gfs2_ondisk.h> 19 #include <linux/gfs2_ondisk.h>
20 #include <linux/lm_interface.h> 20 #include <linux/lm_interface.h>
21 21
22 #include "gfs2.h" 22 #include "gfs2.h"
23 #include "incore.h" 23 #include "incore.h"
24 #include "bmap.h" 24 #include "bmap.h"
25 #include "glock.h" 25 #include "glock.h"
26 #include "inode.h" 26 #include "inode.h"
27 #include "log.h" 27 #include "log.h"
28 #include "meta_io.h" 28 #include "meta_io.h"
29 #include "ops_address.h" 29 #include "ops_address.h"
30 #include "quota.h" 30 #include "quota.h"
31 #include "trans.h" 31 #include "trans.h"
32 #include "rgrp.h" 32 #include "rgrp.h"
33 #include "ops_file.h" 33 #include "ops_file.h"
34 #include "util.h" 34 #include "util.h"
35 #include "glops.h" 35 #include "glops.h"
36 36
37 37
38 static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page, 38 static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
39 unsigned int from, unsigned int to) 39 unsigned int from, unsigned int to)
40 { 40 {
41 struct buffer_head *head = page_buffers(page); 41 struct buffer_head *head = page_buffers(page);
42 unsigned int bsize = head->b_size; 42 unsigned int bsize = head->b_size;
43 struct buffer_head *bh; 43 struct buffer_head *bh;
44 unsigned int start, end; 44 unsigned int start, end;
45 45
46 for (bh = head, start = 0; bh != head || !start; 46 for (bh = head, start = 0; bh != head || !start;
47 bh = bh->b_this_page, start = end) { 47 bh = bh->b_this_page, start = end) {
48 end = start + bsize; 48 end = start + bsize;
49 if (end <= from || start >= to) 49 if (end <= from || start >= to)
50 continue; 50 continue;
51 gfs2_trans_add_bh(ip->i_gl, bh, 0); 51 gfs2_trans_add_bh(ip->i_gl, bh, 0);
52 } 52 }
53 } 53 }
54 54
55 /** 55 /**
56 * gfs2_get_block - Fills in a buffer head with details about a block 56 * gfs2_get_block - Fills in a buffer head with details about a block
57 * @inode: The inode 57 * @inode: The inode
58 * @lblock: The block number to look up 58 * @lblock: The block number to look up
59 * @bh_result: The buffer head to return the result in 59 * @bh_result: The buffer head to return the result in
60 * @create: Non-zero if we may add block to the file 60 * @create: Non-zero if we may add block to the file
61 * 61 *
62 * Returns: errno 62 * Returns: errno
63 */ 63 */
64 64
65 int gfs2_get_block(struct inode *inode, sector_t lblock, 65 int gfs2_get_block(struct inode *inode, sector_t lblock,
66 struct buffer_head *bh_result, int create) 66 struct buffer_head *bh_result, int create)
67 { 67 {
68 return gfs2_block_map(inode, lblock, create, bh_result, 32); 68 return gfs2_block_map(inode, lblock, create, bh_result, 32);
69 } 69 }
70 70
71 /** 71 /**
72 * gfs2_get_block_noalloc - Fills in a buffer head with details about a block 72 * gfs2_get_block_noalloc - Fills in a buffer head with details about a block
73 * @inode: The inode 73 * @inode: The inode
74 * @lblock: The block number to look up 74 * @lblock: The block number to look up
75 * @bh_result: The buffer head to return the result in 75 * @bh_result: The buffer head to return the result in
76 * @create: Non-zero if we may add block to the file 76 * @create: Non-zero if we may add block to the file
77 * 77 *
78 * Returns: errno 78 * Returns: errno
79 */ 79 */
80 80
81 static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock, 81 static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
82 struct buffer_head *bh_result, int create) 82 struct buffer_head *bh_result, int create)
83 { 83 {
84 int error; 84 int error;
85 85
86 error = gfs2_block_map(inode, lblock, 0, bh_result, 1); 86 error = gfs2_block_map(inode, lblock, 0, bh_result, 1);
87 if (error) 87 if (error)
88 return error; 88 return error;
89 if (bh_result->b_blocknr == 0) 89 if (bh_result->b_blocknr == 0)
90 return -EIO; 90 return -EIO;
91 return 0; 91 return 0;
92 } 92 }
93 93
94 static int gfs2_get_block_direct(struct inode *inode, sector_t lblock, 94 static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
95 struct buffer_head *bh_result, int create) 95 struct buffer_head *bh_result, int create)
96 { 96 {
97 return gfs2_block_map(inode, lblock, 0, bh_result, 32); 97 return gfs2_block_map(inode, lblock, 0, bh_result, 32);
98 } 98 }
99 99
100 /** 100 /**
101 * gfs2_writepage - Write complete page 101 * gfs2_writepage - Write complete page
102 * @page: Page to write 102 * @page: Page to write
103 * 103 *
104 * Returns: errno 104 * Returns: errno
105 * 105 *
106 * Some of this is copied from block_write_full_page() although we still 106 * Some of this is copied from block_write_full_page() although we still
107 * call it to do most of the work. 107 * call it to do most of the work.
108 */ 108 */
109 109
110 static int gfs2_writepage(struct page *page, struct writeback_control *wbc) 110 static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
111 { 111 {
112 struct inode *inode = page->mapping->host; 112 struct inode *inode = page->mapping->host;
113 struct gfs2_inode *ip = GFS2_I(inode); 113 struct gfs2_inode *ip = GFS2_I(inode);
114 struct gfs2_sbd *sdp = GFS2_SB(inode); 114 struct gfs2_sbd *sdp = GFS2_SB(inode);
115 loff_t i_size = i_size_read(inode); 115 loff_t i_size = i_size_read(inode);
116 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT; 116 pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
117 unsigned offset; 117 unsigned offset;
118 int error; 118 int error;
119 int done_trans = 0; 119 int done_trans = 0;
120 120
121 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) { 121 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
122 unlock_page(page); 122 unlock_page(page);
123 return -EIO; 123 return -EIO;
124 } 124 }
125 if (current->journal_info) 125 if (current->journal_info)
126 goto out_ignore; 126 goto out_ignore;
127 127
128 /* Is the page fully outside i_size? (truncate in progress) */ 128 /* Is the page fully outside i_size? (truncate in progress) */
129 offset = i_size & (PAGE_CACHE_SIZE-1); 129 offset = i_size & (PAGE_CACHE_SIZE-1);
130 if (page->index > end_index || (page->index == end_index && !offset)) { 130 if (page->index > end_index || (page->index == end_index && !offset)) {
131 page->mapping->a_ops->invalidatepage(page, 0); 131 page->mapping->a_ops->invalidatepage(page, 0);
132 unlock_page(page); 132 unlock_page(page);
133 return 0; /* don't care */ 133 return 0; /* don't care */
134 } 134 }
135 135
136 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) { 136 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) {
137 error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0); 137 error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
138 if (error) 138 if (error)
139 goto out_ignore; 139 goto out_ignore;
140 if (!page_has_buffers(page)) { 140 if (!page_has_buffers(page)) {
141 create_empty_buffers(page, inode->i_sb->s_blocksize, 141 create_empty_buffers(page, inode->i_sb->s_blocksize,
142 (1 << BH_Dirty)|(1 << BH_Uptodate)); 142 (1 << BH_Dirty)|(1 << BH_Uptodate));
143 } 143 }
144 gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1); 144 gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
145 done_trans = 1; 145 done_trans = 1;
146 } 146 }
147 error = block_write_full_page(page, gfs2_get_block_noalloc, wbc); 147 error = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
148 if (done_trans) 148 if (done_trans)
149 gfs2_trans_end(sdp); 149 gfs2_trans_end(sdp);
150 gfs2_meta_cache_flush(ip); 150 gfs2_meta_cache_flush(ip);
151 return error; 151 return error;
152 152
153 out_ignore: 153 out_ignore:
154 redirty_page_for_writepage(wbc, page); 154 redirty_page_for_writepage(wbc, page);
155 unlock_page(page); 155 unlock_page(page);
156 return 0; 156 return 0;
157 } 157 }
158 158
159 static int zero_readpage(struct page *page) 159 static int zero_readpage(struct page *page)
160 { 160 {
161 void *kaddr; 161 void *kaddr;
162 162
163 kaddr = kmap_atomic(page, KM_USER0); 163 kaddr = kmap_atomic(page, KM_USER0);
164 memset(kaddr, 0, PAGE_CACHE_SIZE); 164 memset(kaddr, 0, PAGE_CACHE_SIZE);
165 kunmap_atomic(page, KM_USER0); 165 kunmap_atomic(page, KM_USER0);
166 166
167 SetPageUptodate(page); 167 SetPageUptodate(page);
168 168
169 return 0; 169 return 0;
170 } 170 }
171 171
172 /** 172 /**
173 * stuffed_readpage - Fill in a Linux page with stuffed file data 173 * stuffed_readpage - Fill in a Linux page with stuffed file data
174 * @ip: the inode 174 * @ip: the inode
175 * @page: the page 175 * @page: the page
176 * 176 *
177 * Returns: errno 177 * Returns: errno
178 */ 178 */
179 179
180 static int stuffed_readpage(struct gfs2_inode *ip, struct page *page) 180 static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
181 { 181 {
182 struct buffer_head *dibh; 182 struct buffer_head *dibh;
183 void *kaddr; 183 void *kaddr;
184 int error; 184 int error;
185 185
186 /* Only the first page of a stuffed file might contain data */ 186 /* Only the first page of a stuffed file might contain data */
187 if (unlikely(page->index)) 187 if (unlikely(page->index))
188 return zero_readpage(page); 188 return zero_readpage(page);
189 189
190 error = gfs2_meta_inode_buffer(ip, &dibh); 190 error = gfs2_meta_inode_buffer(ip, &dibh);
191 if (error) 191 if (error)
192 return error; 192 return error;
193 193
194 kaddr = kmap_atomic(page, KM_USER0); 194 kaddr = kmap_atomic(page, KM_USER0);
195 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), 195 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
196 ip->i_di.di_size); 196 ip->i_di.di_size);
197 memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size); 197 memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
198 kunmap_atomic(page, KM_USER0); 198 kunmap_atomic(page, KM_USER0);
199 199
200 brelse(dibh); 200 brelse(dibh);
201 201
202 SetPageUptodate(page); 202 SetPageUptodate(page);
203 203
204 return 0; 204 return 0;
205 } 205 }
206 206
207 207
208 /** 208 /**
209 * gfs2_readpage - readpage with locking 209 * gfs2_readpage - readpage with locking
210 * @file: The file to read a page for. N.B. This may be NULL if we are 210 * @file: The file to read a page for. N.B. This may be NULL if we are
211 * reading an internal file. 211 * reading an internal file.
212 * @page: The page to read 212 * @page: The page to read
213 * 213 *
214 * Returns: errno 214 * Returns: errno
215 */ 215 */
216 216
217 static int gfs2_readpage(struct file *file, struct page *page) 217 static int gfs2_readpage(struct file *file, struct page *page)
218 { 218 {
219 struct gfs2_inode *ip = GFS2_I(page->mapping->host); 219 struct gfs2_inode *ip = GFS2_I(page->mapping->host);
220 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host); 220 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
221 struct gfs2_file *gf = NULL; 221 struct gfs2_file *gf = NULL;
222 struct gfs2_holder gh; 222 struct gfs2_holder gh;
223 int error; 223 int error;
224 int do_unlock = 0; 224 int do_unlock = 0;
225 225
226 if (likely(file != &gfs2_internal_file_sentinel)) { 226 if (likely(file != &gfs2_internal_file_sentinel)) {
227 if (file) { 227 if (file) {
228 gf = file->private_data; 228 gf = file->private_data;
229 if (test_bit(GFF_EXLOCK, &gf->f_flags)) 229 if (test_bit(GFF_EXLOCK, &gf->f_flags))
230 /* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */ 230 /* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */
231 goto skip_lock; 231 goto skip_lock;
232 } 232 }
233 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|GL_AOP, &gh); 233 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|GL_AOP, &gh);
234 do_unlock = 1; 234 do_unlock = 1;
235 error = gfs2_glock_nq_m_atime(1, &gh); 235 error = gfs2_glock_nq_m_atime(1, &gh);
236 if (unlikely(error)) 236 if (unlikely(error))
237 goto out_unlock; 237 goto out_unlock;
238 } 238 }
239 239
240 skip_lock: 240 skip_lock:
241 if (gfs2_is_stuffed(ip)) { 241 if (gfs2_is_stuffed(ip)) {
242 error = stuffed_readpage(ip, page); 242 error = stuffed_readpage(ip, page);
243 unlock_page(page); 243 unlock_page(page);
244 } else 244 } else
245 error = mpage_readpage(page, gfs2_get_block); 245 error = mpage_readpage(page, gfs2_get_block);
246 246
247 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) 247 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
248 error = -EIO; 248 error = -EIO;
249 249
250 if (do_unlock) { 250 if (do_unlock) {
251 gfs2_glock_dq_m(1, &gh); 251 gfs2_glock_dq_m(1, &gh);
252 gfs2_holder_uninit(&gh); 252 gfs2_holder_uninit(&gh);
253 } 253 }
254 out: 254 out:
255 return error; 255 return error;
256 out_unlock: 256 out_unlock:
257 unlock_page(page); 257 unlock_page(page);
258 if (do_unlock) 258 if (do_unlock)
259 gfs2_holder_uninit(&gh); 259 gfs2_holder_uninit(&gh);
260 goto out; 260 goto out;
261 } 261 }
262 262
263 /** 263 /**
264 * gfs2_readpages - Read a bunch of pages at once 264 * gfs2_readpages - Read a bunch of pages at once
265 * 265 *
266 * Some notes: 266 * Some notes:
267 * 1. This is only for readahead, so we can simply ignore any things 267 * 1. This is only for readahead, so we can simply ignore any things
268 * which are slightly inconvenient (such as locking conflicts between 268 * which are slightly inconvenient (such as locking conflicts between
269 * the page lock and the glock) and return having done no I/O. Its 269 * the page lock and the glock) and return having done no I/O. Its
270 * obviously not something we'd want to do on too regular a basis. 270 * obviously not something we'd want to do on too regular a basis.
271 * Any I/O we ignore at this time will be done via readpage later. 271 * Any I/O we ignore at this time will be done via readpage later.
272 * 2. We have to handle stuffed files here too. 272 * 2. We have to handle stuffed files here too.
273 * 3. mpage_readpages() does most of the heavy lifting in the common case. 273 * 3. mpage_readpages() does most of the heavy lifting in the common case.
274 * 4. gfs2_get_block() is relied upon to set BH_Boundary in the right places. 274 * 4. gfs2_get_block() is relied upon to set BH_Boundary in the right places.
275 * 5. We use LM_FLAG_TRY_1CB here, effectively we then have lock-ahead as 275 * 5. We use LM_FLAG_TRY_1CB here, effectively we then have lock-ahead as
276 * well as read-ahead. 276 * well as read-ahead.
277 */ 277 */
278 static int gfs2_readpages(struct file *file, struct address_space *mapping, 278 static int gfs2_readpages(struct file *file, struct address_space *mapping,
279 struct list_head *pages, unsigned nr_pages) 279 struct list_head *pages, unsigned nr_pages)
280 { 280 {
281 struct inode *inode = mapping->host; 281 struct inode *inode = mapping->host;
282 struct gfs2_inode *ip = GFS2_I(inode); 282 struct gfs2_inode *ip = GFS2_I(inode);
283 struct gfs2_sbd *sdp = GFS2_SB(inode); 283 struct gfs2_sbd *sdp = GFS2_SB(inode);
284 struct gfs2_holder gh; 284 struct gfs2_holder gh;
285 unsigned page_idx; 285 unsigned page_idx;
286 int ret; 286 int ret;
287 int do_unlock = 0; 287 int do_unlock = 0;
288 288
289 if (likely(file != &gfs2_internal_file_sentinel)) { 289 if (likely(file != &gfs2_internal_file_sentinel)) {
290 if (file) { 290 if (file) {
291 struct gfs2_file *gf = file->private_data; 291 struct gfs2_file *gf = file->private_data;
292 if (test_bit(GFF_EXLOCK, &gf->f_flags)) 292 if (test_bit(GFF_EXLOCK, &gf->f_flags))
293 goto skip_lock; 293 goto skip_lock;
294 } 294 }
295 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 295 gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
296 LM_FLAG_TRY_1CB|GL_ATIME|GL_AOP, &gh); 296 LM_FLAG_TRY_1CB|GL_ATIME|GL_AOP, &gh);
297 do_unlock = 1; 297 do_unlock = 1;
298 ret = gfs2_glock_nq_m_atime(1, &gh); 298 ret = gfs2_glock_nq_m_atime(1, &gh);
299 if (ret == GLR_TRYFAILED) 299 if (ret == GLR_TRYFAILED)
300 goto out_noerror; 300 goto out_noerror;
301 if (unlikely(ret)) 301 if (unlikely(ret))
302 goto out_unlock; 302 goto out_unlock;
303 } 303 }
304 skip_lock: 304 skip_lock:
305 if (gfs2_is_stuffed(ip)) { 305 if (gfs2_is_stuffed(ip)) {
306 struct pagevec lru_pvec; 306 struct pagevec lru_pvec;
307 pagevec_init(&lru_pvec, 0); 307 pagevec_init(&lru_pvec, 0);
308 for (page_idx = 0; page_idx < nr_pages; page_idx++) { 308 for (page_idx = 0; page_idx < nr_pages; page_idx++) {
309 struct page *page = list_entry(pages->prev, struct page, lru); 309 struct page *page = list_entry(pages->prev, struct page, lru);
310 prefetchw(&page->flags); 310 prefetchw(&page->flags);
311 list_del(&page->lru); 311 list_del(&page->lru);
312 if (!add_to_page_cache(page, mapping, 312 if (!add_to_page_cache(page, mapping,
313 page->index, GFP_KERNEL)) { 313 page->index, GFP_KERNEL)) {
314 ret = stuffed_readpage(ip, page); 314 ret = stuffed_readpage(ip, page);
315 unlock_page(page); 315 unlock_page(page);
316 if (!pagevec_add(&lru_pvec, page)) 316 if (!pagevec_add(&lru_pvec, page))
317 __pagevec_lru_add(&lru_pvec); 317 __pagevec_lru_add(&lru_pvec);
318 } else { 318 } else {
319 page_cache_release(page); 319 page_cache_release(page);
320 } 320 }
321 } 321 }
322 pagevec_lru_add(&lru_pvec); 322 pagevec_lru_add(&lru_pvec);
323 ret = 0; 323 ret = 0;
324 } else { 324 } else {
325 /* What we really want to do .... */ 325 /* What we really want to do .... */
326 ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block); 326 ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
327 } 327 }
328 328
329 if (do_unlock) { 329 if (do_unlock) {
330 gfs2_glock_dq_m(1, &gh); 330 gfs2_glock_dq_m(1, &gh);
331 gfs2_holder_uninit(&gh); 331 gfs2_holder_uninit(&gh);
332 } 332 }
333 out: 333 out:
334 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) 334 if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
335 ret = -EIO; 335 ret = -EIO;
336 return ret; 336 return ret;
337 out_noerror: 337 out_noerror:
338 ret = 0; 338 ret = 0;
339 out_unlock: 339 out_unlock:
340 /* unlock all pages, we can't do any I/O right now */ 340 /* unlock all pages, we can't do any I/O right now */
341 for (page_idx = 0; page_idx < nr_pages; page_idx++) { 341 for (page_idx = 0; page_idx < nr_pages; page_idx++) {
342 struct page *page = list_entry(pages->prev, struct page, lru); 342 struct page *page = list_entry(pages->prev, struct page, lru);
343 list_del(&page->lru); 343 list_del(&page->lru);
344 unlock_page(page); 344 unlock_page(page);
345 page_cache_release(page); 345 page_cache_release(page);
346 } 346 }
347 if (do_unlock) 347 if (do_unlock)
348 gfs2_holder_uninit(&gh); 348 gfs2_holder_uninit(&gh);
349 goto out; 349 goto out;
350 } 350 }
351 351
352 /** 352 /**
353 * gfs2_prepare_write - Prepare to write a page to a file 353 * gfs2_prepare_write - Prepare to write a page to a file
354 * @file: The file to write to 354 * @file: The file to write to
355 * @page: The page which is to be prepared for writing 355 * @page: The page which is to be prepared for writing
356 * @from: From (byte range within page) 356 * @from: From (byte range within page)
357 * @to: To (byte range within page) 357 * @to: To (byte range within page)
358 * 358 *
359 * Returns: errno 359 * Returns: errno
360 */ 360 */
361 361
362 static int gfs2_prepare_write(struct file *file, struct page *page, 362 static int gfs2_prepare_write(struct file *file, struct page *page,
363 unsigned from, unsigned to) 363 unsigned from, unsigned to)
364 { 364 {
365 struct gfs2_inode *ip = GFS2_I(page->mapping->host); 365 struct gfs2_inode *ip = GFS2_I(page->mapping->host);
366 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host); 366 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
367 unsigned int data_blocks, ind_blocks, rblocks; 367 unsigned int data_blocks, ind_blocks, rblocks;
368 int alloc_required; 368 int alloc_required;
369 int error = 0; 369 int error = 0;
370 loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + from; 370 loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + from;
371 loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to; 371 loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
372 struct gfs2_alloc *al; 372 struct gfs2_alloc *al;
373 unsigned int write_len = to - from; 373 unsigned int write_len = to - from;
374 374
375 375
376 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|GL_AOP, &ip->i_gh); 376 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|GL_AOP, &ip->i_gh);
377 error = gfs2_glock_nq_m_atime(1, &ip->i_gh); 377 error = gfs2_glock_nq_m_atime(1, &ip->i_gh);
378 if (error) 378 if (error)
379 goto out_uninit; 379 goto out_uninit;
380 380
381 gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks); 381 gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks);
382 382
383 error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required); 383 error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required);
384 if (error) 384 if (error)
385 goto out_unlock; 385 goto out_unlock;
386 386
387 387
388 ip->i_alloc.al_requested = 0;
388 if (alloc_required) { 389 if (alloc_required) {
389 al = gfs2_alloc_get(ip); 390 al = gfs2_alloc_get(ip);
390 391
391 error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); 392 error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
392 if (error) 393 if (error)
393 goto out_alloc_put; 394 goto out_alloc_put;
394 395
395 error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid); 396 error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid);
396 if (error) 397 if (error)
397 goto out_qunlock; 398 goto out_qunlock;
398 399
399 al->al_requested = data_blocks + ind_blocks; 400 al->al_requested = data_blocks + ind_blocks;
400 error = gfs2_inplace_reserve(ip); 401 error = gfs2_inplace_reserve(ip);
401 if (error) 402 if (error)
402 goto out_qunlock; 403 goto out_qunlock;
403 } 404 }
404 405
405 rblocks = RES_DINODE + ind_blocks; 406 rblocks = RES_DINODE + ind_blocks;
406 if (gfs2_is_jdata(ip)) 407 if (gfs2_is_jdata(ip))
407 rblocks += data_blocks ? data_blocks : 1; 408 rblocks += data_blocks ? data_blocks : 1;
408 if (ind_blocks || data_blocks) 409 if (ind_blocks || data_blocks)
409 rblocks += RES_STATFS + RES_QUOTA; 410 rblocks += RES_STATFS + RES_QUOTA;
410 411
411 error = gfs2_trans_begin(sdp, rblocks, 0); 412 error = gfs2_trans_begin(sdp, rblocks, 0);
412 if (error) 413 if (error)
413 goto out; 414 goto out;
414 415
415 if (gfs2_is_stuffed(ip)) { 416 if (gfs2_is_stuffed(ip)) {
416 if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) { 417 if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
417 error = gfs2_unstuff_dinode(ip, page); 418 error = gfs2_unstuff_dinode(ip, page);
418 if (error == 0) 419 if (error == 0)
419 goto prepare_write; 420 goto prepare_write;
420 } else if (!PageUptodate(page)) 421 } else if (!PageUptodate(page))
421 error = stuffed_readpage(ip, page); 422 error = stuffed_readpage(ip, page);
422 goto out; 423 goto out;
423 } 424 }
424 425
425 prepare_write: 426 prepare_write:
426 error = block_prepare_write(page, from, to, gfs2_get_block); 427 error = block_prepare_write(page, from, to, gfs2_get_block);
427 428
428 out: 429 out:
429 if (error) { 430 if (error) {
430 gfs2_trans_end(sdp); 431 gfs2_trans_end(sdp);
431 if (alloc_required) { 432 if (alloc_required) {
432 gfs2_inplace_release(ip); 433 gfs2_inplace_release(ip);
433 out_qunlock: 434 out_qunlock:
434 gfs2_quota_unlock(ip); 435 gfs2_quota_unlock(ip);
435 out_alloc_put: 436 out_alloc_put:
436 gfs2_alloc_put(ip); 437 gfs2_alloc_put(ip);
437 } 438 }
438 out_unlock: 439 out_unlock:
439 gfs2_glock_dq_m(1, &ip->i_gh); 440 gfs2_glock_dq_m(1, &ip->i_gh);
440 out_uninit: 441 out_uninit:
441 gfs2_holder_uninit(&ip->i_gh); 442 gfs2_holder_uninit(&ip->i_gh);
442 } 443 }
443 444
444 return error; 445 return error;
445 } 446 }
446 447
447 /** 448 /**
448 * gfs2_commit_write - Commit write to a file 449 * gfs2_commit_write - Commit write to a file
449 * @file: The file to write to 450 * @file: The file to write to
450 * @page: The page containing the data 451 * @page: The page containing the data
451 * @from: From (byte range within page) 452 * @from: From (byte range within page)
452 * @to: To (byte range within page) 453 * @to: To (byte range within page)
453 * 454 *
454 * Returns: errno 455 * Returns: errno
455 */ 456 */
456 457
457 static int gfs2_commit_write(struct file *file, struct page *page, 458 static int gfs2_commit_write(struct file *file, struct page *page,
458 unsigned from, unsigned to) 459 unsigned from, unsigned to)
459 { 460 {
460 struct inode *inode = page->mapping->host; 461 struct inode *inode = page->mapping->host;
461 struct gfs2_inode *ip = GFS2_I(inode); 462 struct gfs2_inode *ip = GFS2_I(inode);
462 struct gfs2_sbd *sdp = GFS2_SB(inode); 463 struct gfs2_sbd *sdp = GFS2_SB(inode);
463 int error = -EOPNOTSUPP; 464 int error = -EOPNOTSUPP;
464 struct buffer_head *dibh; 465 struct buffer_head *dibh;
465 struct gfs2_alloc *al = &ip->i_alloc; 466 struct gfs2_alloc *al = &ip->i_alloc;
466 struct gfs2_dinode *di; 467 struct gfs2_dinode *di;
467 468
468 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl))) 469 if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
469 goto fail_nounlock; 470 goto fail_nounlock;
470 471
471 error = gfs2_meta_inode_buffer(ip, &dibh); 472 error = gfs2_meta_inode_buffer(ip, &dibh);
472 if (error) 473 if (error)
473 goto fail_endtrans; 474 goto fail_endtrans;
474 475
475 gfs2_trans_add_bh(ip->i_gl, dibh, 1); 476 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
476 di = (struct gfs2_dinode *)dibh->b_data; 477 di = (struct gfs2_dinode *)dibh->b_data;
477 478
478 if (gfs2_is_stuffed(ip)) { 479 if (gfs2_is_stuffed(ip)) {
479 u64 file_size; 480 u64 file_size;
480 void *kaddr; 481 void *kaddr;
481 482
482 file_size = ((u64)page->index << PAGE_CACHE_SHIFT) + to; 483 file_size = ((u64)page->index << PAGE_CACHE_SHIFT) + to;
483 484
484 kaddr = kmap_atomic(page, KM_USER0); 485 kaddr = kmap_atomic(page, KM_USER0);
485 memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from, 486 memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
486 kaddr + from, to - from); 487 kaddr + from, to - from);
487 kunmap_atomic(page, KM_USER0); 488 kunmap_atomic(page, KM_USER0);
488 489
489 SetPageUptodate(page); 490 SetPageUptodate(page);
490 491
491 if (inode->i_size < file_size) 492 if (inode->i_size < file_size)
492 i_size_write(inode, file_size); 493 i_size_write(inode, file_size);
493 } else { 494 } else {
494 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || 495 if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED ||
495 gfs2_is_jdata(ip)) 496 gfs2_is_jdata(ip))
496 gfs2_page_add_databufs(ip, page, from, to); 497 gfs2_page_add_databufs(ip, page, from, to);
497 error = generic_commit_write(file, page, from, to); 498 error = generic_commit_write(file, page, from, to);
498 if (error) 499 if (error)
499 goto fail; 500 goto fail;
500 } 501 }
501 502
502 if (ip->i_di.di_size < inode->i_size) { 503 if (ip->i_di.di_size < inode->i_size) {
503 ip->i_di.di_size = inode->i_size; 504 ip->i_di.di_size = inode->i_size;
504 di->di_size = cpu_to_be64(inode->i_size); 505 di->di_size = cpu_to_be64(inode->i_size);
505 } 506 }
506 507
507 di->di_mode = cpu_to_be32(inode->i_mode); 508 di->di_mode = cpu_to_be32(inode->i_mode);
508 di->di_atime = cpu_to_be64(inode->i_atime.tv_sec); 509 di->di_atime = cpu_to_be64(inode->i_atime.tv_sec);
509 di->di_mtime = cpu_to_be64(inode->i_mtime.tv_sec); 510 di->di_mtime = cpu_to_be64(inode->i_mtime.tv_sec);
510 di->di_ctime = cpu_to_be64(inode->i_ctime.tv_sec); 511 di->di_ctime = cpu_to_be64(inode->i_ctime.tv_sec);
511 512
512 brelse(dibh); 513 brelse(dibh);
513 gfs2_trans_end(sdp); 514 gfs2_trans_end(sdp);
514 if (al->al_requested) { 515 if (al->al_requested) {
515 gfs2_inplace_release(ip); 516 gfs2_inplace_release(ip);
516 gfs2_quota_unlock(ip); 517 gfs2_quota_unlock(ip);
517 gfs2_alloc_put(ip); 518 gfs2_alloc_put(ip);
518 } 519 }
519 gfs2_glock_dq_m(1, &ip->i_gh); 520 gfs2_glock_dq_m(1, &ip->i_gh);
520 gfs2_holder_uninit(&ip->i_gh); 521 gfs2_holder_uninit(&ip->i_gh);
521 return 0; 522 return 0;
522 523
523 fail: 524 fail:
524 brelse(dibh); 525 brelse(dibh);
525 fail_endtrans: 526 fail_endtrans:
526 gfs2_trans_end(sdp); 527 gfs2_trans_end(sdp);
527 if (al->al_requested) { 528 if (al->al_requested) {
528 gfs2_inplace_release(ip); 529 gfs2_inplace_release(ip);
529 gfs2_quota_unlock(ip); 530 gfs2_quota_unlock(ip);
530 gfs2_alloc_put(ip); 531 gfs2_alloc_put(ip);
531 } 532 }
532 gfs2_glock_dq_m(1, &ip->i_gh); 533 gfs2_glock_dq_m(1, &ip->i_gh);
533 gfs2_holder_uninit(&ip->i_gh); 534 gfs2_holder_uninit(&ip->i_gh);
534 fail_nounlock: 535 fail_nounlock:
535 ClearPageUptodate(page); 536 ClearPageUptodate(page);
536 return error; 537 return error;
537 } 538 }
538 539
539 /** 540 /**
540 * gfs2_bmap - Block map function 541 * gfs2_bmap - Block map function
541 * @mapping: Address space info 542 * @mapping: Address space info
542 * @lblock: The block to map 543 * @lblock: The block to map
543 * 544 *
544 * Returns: The disk address for the block or 0 on hole or error 545 * Returns: The disk address for the block or 0 on hole or error
545 */ 546 */
546 547
547 static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock) 548 static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
548 { 549 {
549 struct gfs2_inode *ip = GFS2_I(mapping->host); 550 struct gfs2_inode *ip = GFS2_I(mapping->host);
550 struct gfs2_holder i_gh; 551 struct gfs2_holder i_gh;
551 sector_t dblock = 0; 552 sector_t dblock = 0;
552 int error; 553 int error;
553 554
554 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); 555 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
555 if (error) 556 if (error)
556 return 0; 557 return 0;
557 558
558 if (!gfs2_is_stuffed(ip)) 559 if (!gfs2_is_stuffed(ip))
559 dblock = generic_block_bmap(mapping, lblock, gfs2_get_block); 560 dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
560 561
561 gfs2_glock_dq_uninit(&i_gh); 562 gfs2_glock_dq_uninit(&i_gh);
562 563
563 return dblock; 564 return dblock;
564 } 565 }
565 566
566 static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh) 567 static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
567 { 568 {
568 struct gfs2_bufdata *bd; 569 struct gfs2_bufdata *bd;
569 570
570 gfs2_log_lock(sdp); 571 gfs2_log_lock(sdp);
571 bd = bh->b_private; 572 bd = bh->b_private;
572 if (bd) { 573 if (bd) {
573 bd->bd_bh = NULL; 574 bd->bd_bh = NULL;
574 bh->b_private = NULL; 575 bh->b_private = NULL;
575 } 576 }
576 gfs2_log_unlock(sdp); 577 gfs2_log_unlock(sdp);
577 578
578 lock_buffer(bh); 579 lock_buffer(bh);
579 clear_buffer_dirty(bh); 580 clear_buffer_dirty(bh);
580 bh->b_bdev = NULL; 581 bh->b_bdev = NULL;
581 clear_buffer_mapped(bh); 582 clear_buffer_mapped(bh);
582 clear_buffer_req(bh); 583 clear_buffer_req(bh);
583 clear_buffer_new(bh); 584 clear_buffer_new(bh);
584 clear_buffer_delay(bh); 585 clear_buffer_delay(bh);
585 unlock_buffer(bh); 586 unlock_buffer(bh);
586 } 587 }
587 588
588 static void gfs2_invalidatepage(struct page *page, unsigned long offset) 589 static void gfs2_invalidatepage(struct page *page, unsigned long offset)
589 { 590 {
590 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host); 591 struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
591 struct buffer_head *head, *bh, *next; 592 struct buffer_head *head, *bh, *next;
592 unsigned int curr_off = 0; 593 unsigned int curr_off = 0;
593 594
594 BUG_ON(!PageLocked(page)); 595 BUG_ON(!PageLocked(page));
595 if (!page_has_buffers(page)) 596 if (!page_has_buffers(page))
596 return; 597 return;
597 598
598 bh = head = page_buffers(page); 599 bh = head = page_buffers(page);
599 do { 600 do {
600 unsigned int next_off = curr_off + bh->b_size; 601 unsigned int next_off = curr_off + bh->b_size;
601 next = bh->b_this_page; 602 next = bh->b_this_page;
602 603
603 if (offset <= curr_off) 604 if (offset <= curr_off)
604 discard_buffer(sdp, bh); 605 discard_buffer(sdp, bh);
605 606
606 curr_off = next_off; 607 curr_off = next_off;
607 bh = next; 608 bh = next;
608 } while (bh != head); 609 } while (bh != head);
609 610
610 if (!offset) 611 if (!offset)
611 try_to_release_page(page, 0); 612 try_to_release_page(page, 0);
612 613
613 return; 614 return;
614 } 615 }
615 616
616 static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb, 617 static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
617 const struct iovec *iov, loff_t offset, 618 const struct iovec *iov, loff_t offset,
618 unsigned long nr_segs) 619 unsigned long nr_segs)
619 { 620 {
620 struct file *file = iocb->ki_filp; 621 struct file *file = iocb->ki_filp;
621 struct inode *inode = file->f_mapping->host; 622 struct inode *inode = file->f_mapping->host;
622 struct gfs2_inode *ip = GFS2_I(inode); 623 struct gfs2_inode *ip = GFS2_I(inode);
623 struct gfs2_holder gh; 624 struct gfs2_holder gh;
624 int rv; 625 int rv;
625 626
626 if (rw == READ) 627 if (rw == READ)
627 mutex_lock(&inode->i_mutex); 628 mutex_lock(&inode->i_mutex);
628 /* 629 /*
629 * Shared lock, even if its a write, since we do no allocation 630 * Shared lock, even if its a write, since we do no allocation
630 * on this path. All we need change is atime. 631 * on this path. All we need change is atime.
631 */ 632 */
632 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh); 633 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
633 rv = gfs2_glock_nq_m_atime(1, &gh); 634 rv = gfs2_glock_nq_m_atime(1, &gh);
634 if (rv) 635 if (rv)
635 goto out; 636 goto out;
636 637
637 if (offset > i_size_read(inode)) 638 if (offset > i_size_read(inode))
638 goto out; 639 goto out;
639 640
640 /* 641 /*
641 * Should we return an error here? I can't see that O_DIRECT for 642 * Should we return an error here? I can't see that O_DIRECT for
642 * a journaled file makes any sense. For now we'll silently fall 643 * a journaled file makes any sense. For now we'll silently fall
643 * back to buffered I/O, likewise we do the same for stuffed 644 * back to buffered I/O, likewise we do the same for stuffed
644 * files since they are (a) small and (b) unaligned. 645 * files since they are (a) small and (b) unaligned.
645 */ 646 */
646 if (gfs2_is_jdata(ip)) 647 if (gfs2_is_jdata(ip))
647 goto out; 648 goto out;
648 649
649 if (gfs2_is_stuffed(ip)) 650 if (gfs2_is_stuffed(ip))
650 goto out; 651 goto out;
651 652
652 rv = blockdev_direct_IO_own_locking(rw, iocb, inode, 653 rv = blockdev_direct_IO_own_locking(rw, iocb, inode,
653 inode->i_sb->s_bdev, 654 inode->i_sb->s_bdev,
654 iov, offset, nr_segs, 655 iov, offset, nr_segs,
655 gfs2_get_block_direct, NULL); 656 gfs2_get_block_direct, NULL);
656 out: 657 out:
657 gfs2_glock_dq_m(1, &gh); 658 gfs2_glock_dq_m(1, &gh);
658 gfs2_holder_uninit(&gh); 659 gfs2_holder_uninit(&gh);
659 if (rw == READ) 660 if (rw == READ)
660 mutex_unlock(&inode->i_mutex); 661 mutex_unlock(&inode->i_mutex);
661 662
662 return rv; 663 return rv;
663 } 664 }
664 665
665 /** 666 /**
666 * stuck_releasepage - We're stuck in gfs2_releasepage(). Print stuff out. 667 * stuck_releasepage - We're stuck in gfs2_releasepage(). Print stuff out.
667 * @bh: the buffer we're stuck on 668 * @bh: the buffer we're stuck on
668 * 669 *
669 */ 670 */
670 671
671 static void stuck_releasepage(struct buffer_head *bh) 672 static void stuck_releasepage(struct buffer_head *bh)
672 { 673 {
673 struct inode *inode = bh->b_page->mapping->host; 674 struct inode *inode = bh->b_page->mapping->host;
674 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info; 675 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
675 struct gfs2_bufdata *bd = bh->b_private; 676 struct gfs2_bufdata *bd = bh->b_private;
676 struct gfs2_glock *gl; 677 struct gfs2_glock *gl;
677 static unsigned limit = 0; 678 static unsigned limit = 0;
678 679
679 if (limit > 3) 680 if (limit > 3)
680 return; 681 return;
681 limit++; 682 limit++;
682 683
683 fs_warn(sdp, "stuck in gfs2_releasepage() %p\n", inode); 684 fs_warn(sdp, "stuck in gfs2_releasepage() %p\n", inode);
684 fs_warn(sdp, "blkno = %llu, bh->b_count = %d\n", 685 fs_warn(sdp, "blkno = %llu, bh->b_count = %d\n",
685 (unsigned long long)bh->b_blocknr, atomic_read(&bh->b_count)); 686 (unsigned long long)bh->b_blocknr, atomic_read(&bh->b_count));
686 fs_warn(sdp, "pinned = %u\n", buffer_pinned(bh)); 687 fs_warn(sdp, "pinned = %u\n", buffer_pinned(bh));
687 fs_warn(sdp, "bh->b_private = %s\n", (bd) ? "!NULL" : "NULL"); 688 fs_warn(sdp, "bh->b_private = %s\n", (bd) ? "!NULL" : "NULL");
688 689
689 if (!bd) 690 if (!bd)
690 return; 691 return;
691 692
692 gl = bd->bd_gl; 693 gl = bd->bd_gl;
693 694
694 fs_warn(sdp, "gl = (%u, %llu)\n", 695 fs_warn(sdp, "gl = (%u, %llu)\n",
695 gl->gl_name.ln_type, (unsigned long long)gl->gl_name.ln_number); 696 gl->gl_name.ln_type, (unsigned long long)gl->gl_name.ln_number);
696 697
697 fs_warn(sdp, "bd_list_tr = %s, bd_le.le_list = %s\n", 698 fs_warn(sdp, "bd_list_tr = %s, bd_le.le_list = %s\n",
698 (list_empty(&bd->bd_list_tr)) ? "no" : "yes", 699 (list_empty(&bd->bd_list_tr)) ? "no" : "yes",
699 (list_empty(&bd->bd_le.le_list)) ? "no" : "yes"); 700 (list_empty(&bd->bd_le.le_list)) ? "no" : "yes");
700 701
701 if (gl->gl_ops == &gfs2_inode_glops) { 702 if (gl->gl_ops == &gfs2_inode_glops) {
702 struct gfs2_inode *ip = gl->gl_object; 703 struct gfs2_inode *ip = gl->gl_object;
703 unsigned int x; 704 unsigned int x;
704 705
705 if (!ip) 706 if (!ip)
706 return; 707 return;
707 708
708 fs_warn(sdp, "ip = %llu %llu\n", 709 fs_warn(sdp, "ip = %llu %llu\n",
709 (unsigned long long)ip->i_num.no_formal_ino, 710 (unsigned long long)ip->i_num.no_formal_ino,
710 (unsigned long long)ip->i_num.no_addr); 711 (unsigned long long)ip->i_num.no_addr);
711 712
712 for (x = 0; x < GFS2_MAX_META_HEIGHT; x++) 713 for (x = 0; x < GFS2_MAX_META_HEIGHT; x++)
713 fs_warn(sdp, "ip->i_cache[%u] = %s\n", 714 fs_warn(sdp, "ip->i_cache[%u] = %s\n",
714 x, (ip->i_cache[x]) ? "!NULL" : "NULL"); 715 x, (ip->i_cache[x]) ? "!NULL" : "NULL");
715 } 716 }
716 } 717 }
717 718
718 /** 719 /**
719 * gfs2_releasepage - free the metadata associated with a page 720 * gfs2_releasepage - free the metadata associated with a page
720 * @page: the page that's being released 721 * @page: the page that's being released
721 * @gfp_mask: passed from Linux VFS, ignored by us 722 * @gfp_mask: passed from Linux VFS, ignored by us
722 * 723 *
723 * Call try_to_free_buffers() if the buffers in this page can be 724 * Call try_to_free_buffers() if the buffers in this page can be
724 * released. 725 * released.
725 * 726 *
726 * Returns: 0 727 * Returns: 0
727 */ 728 */
728 729
729 int gfs2_releasepage(struct page *page, gfp_t gfp_mask) 730 int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
730 { 731 {
731 struct inode *aspace = page->mapping->host; 732 struct inode *aspace = page->mapping->host;
732 struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info; 733 struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info;
733 struct buffer_head *bh, *head; 734 struct buffer_head *bh, *head;
734 struct gfs2_bufdata *bd; 735 struct gfs2_bufdata *bd;
735 unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ; 736 unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
736 737
737 if (!page_has_buffers(page)) 738 if (!page_has_buffers(page))
738 goto out; 739 goto out;
739 740
740 head = bh = page_buffers(page); 741 head = bh = page_buffers(page);
741 do { 742 do {
742 while (atomic_read(&bh->b_count)) { 743 while (atomic_read(&bh->b_count)) {
743 if (!atomic_read(&aspace->i_writecount)) 744 if (!atomic_read(&aspace->i_writecount))
744 return 0; 745 return 0;
745 746
746 if (time_after_eq(jiffies, t)) { 747 if (time_after_eq(jiffies, t)) {
747 stuck_releasepage(bh); 748 stuck_releasepage(bh);
748 /* should we withdraw here? */ 749 /* should we withdraw here? */
749 return 0; 750 return 0;
750 } 751 }
751 752
752 yield(); 753 yield();
753 } 754 }
754 755
755 gfs2_assert_warn(sdp, !buffer_pinned(bh)); 756 gfs2_assert_warn(sdp, !buffer_pinned(bh));
756 gfs2_assert_warn(sdp, !buffer_dirty(bh)); 757 gfs2_assert_warn(sdp, !buffer_dirty(bh));
757 758
758 gfs2_log_lock(sdp); 759 gfs2_log_lock(sdp);
759 bd = bh->b_private; 760 bd = bh->b_private;
760 if (bd) { 761 if (bd) {
761 gfs2_assert_warn(sdp, bd->bd_bh == bh); 762 gfs2_assert_warn(sdp, bd->bd_bh == bh);
762 gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr)); 763 gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
763 gfs2_assert_warn(sdp, !bd->bd_ail); 764 gfs2_assert_warn(sdp, !bd->bd_ail);
764 bd->bd_bh = NULL; 765 bd->bd_bh = NULL;
765 if (!list_empty(&bd->bd_le.le_list)) 766 if (!list_empty(&bd->bd_le.le_list))
766 bd = NULL; 767 bd = NULL;
767 bh->b_private = NULL; 768 bh->b_private = NULL;
768 } 769 }
769 gfs2_log_unlock(sdp); 770 gfs2_log_unlock(sdp);
770 if (bd) 771 if (bd)
771 kmem_cache_free(gfs2_bufdata_cachep, bd); 772 kmem_cache_free(gfs2_bufdata_cachep, bd);
772 773
773 bh = bh->b_this_page; 774 bh = bh->b_this_page;
774 } while (bh != head); 775 } while (bh != head);
775 776
776 out: 777 out:
777 return try_to_free_buffers(page); 778 return try_to_free_buffers(page);
778 } 779 }
779 780
780 const struct address_space_operations gfs2_file_aops = { 781 const struct address_space_operations gfs2_file_aops = {
781 .writepage = gfs2_writepage, 782 .writepage = gfs2_writepage,
782 .readpage = gfs2_readpage, 783 .readpage = gfs2_readpage,
783 .readpages = gfs2_readpages, 784 .readpages = gfs2_readpages,
784 .sync_page = block_sync_page, 785 .sync_page = block_sync_page,
785 .prepare_write = gfs2_prepare_write, 786 .prepare_write = gfs2_prepare_write,
786 .commit_write = gfs2_commit_write, 787 .commit_write = gfs2_commit_write,
787 .bmap = gfs2_bmap, 788 .bmap = gfs2_bmap,
788 .invalidatepage = gfs2_invalidatepage, 789 .invalidatepage = gfs2_invalidatepage,
789 .releasepage = gfs2_releasepage, 790 .releasepage = gfs2_releasepage,
790 .direct_IO = gfs2_direct_IO, 791 .direct_IO = gfs2_direct_IO,
791 }; 792 };
792 793
793 794
1 /* 1 /*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4 * 4 *
5 * This copyrighted material is made available to anyone wishing to use, 5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions 6 * modify, copy, or redistribute it subject to the terms and conditions
7 * of the GNU General Public License version 2. 7 * of the GNU General Public License version 2.
8 */ 8 */
9 9
10 #ifndef __RGRP_DOT_H__ 10 #ifndef __RGRP_DOT_H__
11 #define __RGRP_DOT_H__ 11 #define __RGRP_DOT_H__
12 12
13 struct gfs2_rgrpd; 13 struct gfs2_rgrpd;
14 struct gfs2_sbd; 14 struct gfs2_sbd;
15 struct gfs2_holder; 15 struct gfs2_holder;
16 16
17 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd); 17 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd);
18 18
19 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk); 19 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk);
20 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp); 20 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp);
21 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd); 21 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd);
22 22
23 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp); 23 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp);
24 int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh); 24 int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh);
25 25
26 int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd); 26 int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd);
27 void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd); 27 void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd);
28 void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd); 28 void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd);
29 29
30 void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd); 30 void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd);
31 31
32 struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip); 32 struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip);
33 static inline void gfs2_alloc_put(struct gfs2_inode *ip) 33 static inline void gfs2_alloc_put(struct gfs2_inode *ip)
34 { 34 {
35 return; /* Se we can see where ip->i_alloc is used */ 35 return; /* So we can see where ip->i_alloc is used */
36 } 36 }
37 37
38 int gfs2_inplace_reserve_i(struct gfs2_inode *ip, 38 int gfs2_inplace_reserve_i(struct gfs2_inode *ip,
39 char *file, unsigned int line); 39 char *file, unsigned int line);
40 #define gfs2_inplace_reserve(ip) \ 40 #define gfs2_inplace_reserve(ip) \
41 gfs2_inplace_reserve_i((ip), __FILE__, __LINE__) 41 gfs2_inplace_reserve_i((ip), __FILE__, __LINE__)
42 42
43 void gfs2_inplace_release(struct gfs2_inode *ip); 43 void gfs2_inplace_release(struct gfs2_inode *ip);
44 44
45 unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block); 45 unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block);
46 46
47 u64 gfs2_alloc_data(struct gfs2_inode *ip); 47 u64 gfs2_alloc_data(struct gfs2_inode *ip);
48 u64 gfs2_alloc_meta(struct gfs2_inode *ip); 48 u64 gfs2_alloc_meta(struct gfs2_inode *ip);
49 u64 gfs2_alloc_di(struct gfs2_inode *ip, u64 *generation); 49 u64 gfs2_alloc_di(struct gfs2_inode *ip, u64 *generation);
50 50
51 void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen); 51 void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen);
52 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen); 52 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen);
53 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip); 53 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip);
54 void gfs2_unlink_di(struct inode *inode); 54 void gfs2_unlink_di(struct inode *inode);
55 55
56 struct gfs2_rgrp_list { 56 struct gfs2_rgrp_list {
57 unsigned int rl_rgrps; 57 unsigned int rl_rgrps;
58 unsigned int rl_space; 58 unsigned int rl_space;
59 struct gfs2_rgrpd **rl_rgd; 59 struct gfs2_rgrpd **rl_rgd;
60 struct gfs2_holder *rl_ghs; 60 struct gfs2_holder *rl_ghs;
61 }; 61 };
62 62
63 void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist, 63 void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist,
64 u64 block); 64 u64 block);
65 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state, 65 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state,
66 int flags); 66 int flags);
67 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist); 67 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist);
68 68
69 #endif /* __RGRP_DOT_H__ */ 69 #endif /* __RGRP_DOT_H__ */
70 70