blob: 1fda731c074b97dc83f72834d1668e9486d0792c [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
David Teiglandb3b94fa2006-01-16 16:50:04 +000010#include <linux/slab.h>
11#include <linux/spinlock.h>
12#include <linux/completion.h>
13#include <linux/buffer_head.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050014#include <linux/gfs2_ondisk.h>
Steven Whitehouse71b86f52006-03-28 14:14:04 -050015#include <linux/crc32.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020016#include <linux/lm_interface.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000017
18#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050019#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000020#include "bmap.h"
21#include "glock.h"
22#include "inode.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000023#include "meta_io.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000024#include "quota.h"
25#include "rgrp.h"
26#include "trans.h"
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000027#include "dir.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050028#include "util.h"
Steven Whitehouseba7f7292006-07-26 11:27:10 -040029#include "ops_address.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000030
31/* This doesn't need to be that large as max 64 bit pointers in a 4k
32 * block is 512, so __u16 is fine for that. It saves stack space to
33 * keep it small.
34 */
35struct metapath {
Steven Whitehousedbac6712008-01-29 09:12:55 +000036 struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
David Teiglandb3b94fa2006-01-16 16:50:04 +000037 __u16 mp_list[GFS2_MAX_META_HEIGHT];
38};
39
40typedef int (*block_call_t) (struct gfs2_inode *ip, struct buffer_head *dibh,
Al Virob44b84d2006-10-14 10:46:30 -040041 struct buffer_head *bh, __be64 *top,
42 __be64 *bottom, unsigned int height,
David Teiglandb3b94fa2006-01-16 16:50:04 +000043 void *data);
44
45struct strip_mine {
46 int sm_first;
47 unsigned int sm_height;
48};
49
50/**
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040051 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
52 * @ip: the inode
53 * @dibh: the dinode buffer
54 * @block: the block number that was allocated
55 * @private: any locked page held by the caller process
56 *
57 * Returns: errno
58 */
59
60static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
Steven Whitehousecd915492006-09-04 12:49:07 -040061 u64 block, struct page *page)
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040062{
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040063 struct inode *inode = &ip->i_inode;
64 struct buffer_head *bh;
65 int release = 0;
66
67 if (!page || page->index) {
68 page = grab_cache_page(inode->i_mapping, 0);
69 if (!page)
70 return -ENOMEM;
71 release = 1;
72 }
73
74 if (!PageUptodate(page)) {
75 void *kaddr = kmap(page);
76
77 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
78 ip->i_di.di_size);
79 memset(kaddr + ip->i_di.di_size, 0,
80 PAGE_CACHE_SIZE - ip->i_di.di_size);
81 kunmap(page);
82
83 SetPageUptodate(page);
84 }
85
86 if (!page_has_buffers(page))
87 create_empty_buffers(page, 1 << inode->i_blkbits,
88 (1 << BH_Uptodate));
89
90 bh = page_buffers(page);
91
92 if (!buffer_mapped(bh))
93 map_bh(bh, inode->i_sb, block);
94
95 set_buffer_uptodate(bh);
Steven Whitehouseeaf96522007-08-27 09:49:37 +010096 if (!gfs2_is_jdata(ip))
97 mark_buffer_dirty(bh);
Steven Whitehousebf36a712007-10-17 08:35:19 +010098 if (!gfs2_is_writeback(ip))
Bob Peterson84754872007-09-02 10:55:29 +010099 gfs2_trans_add_bh(ip->i_gl, bh, 0);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400100
101 if (release) {
102 unlock_page(page);
103 page_cache_release(page);
104 }
105
106 return 0;
107}
108
109/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000110 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
111 * @ip: The GFS2 inode to unstuff
112 * @unstuffer: the routine that handles unstuffing a non-zero length file
113 * @private: private data for the unstuffer
114 *
115 * This routine unstuffs a dinode and returns it to a "normal" state such
116 * that the height can be grown in the traditional way.
117 *
118 * Returns: errno
119 */
120
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400121int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000122{
123 struct buffer_head *bh, *dibh;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400124 struct gfs2_dinode *di;
Steven Whitehousecd915492006-09-04 12:49:07 -0400125 u64 block = 0;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000126 int isdir = gfs2_is_dir(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000127 int error;
128
129 down_write(&ip->i_rw_mutex);
130
131 error = gfs2_meta_inode_buffer(ip, &dibh);
132 if (error)
133 goto out;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400134
David Teiglandb3b94fa2006-01-16 16:50:04 +0000135 if (ip->i_di.di_size) {
136 /* Get a free block, fill it with the stuffed data,
137 and write it out to disk */
138
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000139 unsigned int n = 1;
140 block = gfs2_alloc_block(ip, &n);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000141 if (isdir) {
Steven Whitehouse5731be52008-02-01 13:16:55 +0000142 gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
Steven Whitehouse61e085a2006-04-24 10:07:13 -0400143 error = gfs2_dir_get_new_buffer(ip, block, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000144 if (error)
145 goto out_brelse;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400146 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000147 dibh, sizeof(struct gfs2_dinode));
148 brelse(bh);
149 } else {
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400150 error = gfs2_unstuffer_page(ip, dibh, block, page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000151 if (error)
152 goto out_brelse;
153 }
154 }
155
156 /* Set up the pointer to the new block */
157
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000158 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400159 di = (struct gfs2_dinode *)dibh->b_data;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000160 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
161
162 if (ip->i_di.di_size) {
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400163 *(__be64 *)(di + 1) = cpu_to_be64(block);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000164 ip->i_di.di_blocks++;
Steven Whitehouse9e2dbda2006-11-08 15:45:46 -0500165 gfs2_set_inode_blocks(&ip->i_inode);
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400166 di->di_blocks = cpu_to_be64(ip->i_di.di_blocks);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000167 }
168
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000169 ip->i_height = 1;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400170 di->di_height = cpu_to_be16(1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000171
Steven Whitehousea91ea692006-09-04 12:04:26 -0400172out_brelse:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000173 brelse(dibh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400174out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000175 up_write(&ip->i_rw_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000176 return error;
177}
178
179/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000180 * build_height - Build a metadata tree of the requested height
181 * @ip: The GFS2 inode
182 * @height: The height to build to
183 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000184 *
185 * Returns: errno
186 */
187
Steven Whitehousedbac6712008-01-29 09:12:55 +0000188static int build_height(struct inode *inode, struct metapath *mp, unsigned height)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000189{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400190 struct gfs2_inode *ip = GFS2_I(inode);
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000191 unsigned new_height = height - ip->i_height;
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400192 struct buffer_head *dibh;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400193 struct gfs2_dinode *di;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000194 int error;
Al Virob44b84d2006-10-14 10:46:30 -0400195 __be64 *bp;
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400196 u64 bn;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000197 unsigned n, i = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000198
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000199 if (height <= ip->i_height)
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400200 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000201
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400202 error = gfs2_meta_inode_buffer(ip, &dibh);
203 if (error)
204 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000205
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000206 do {
207 n = new_height - i;
208 bn = gfs2_alloc_block(ip, &n);
209 gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, n);
210 do {
211 mp->mp_bh[i] = gfs2_meta_new(ip->i_gl, bn++);
212 gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i], 1);
213 i++;
214 } while(i < n);
215 } while(i < new_height);
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400216
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400217 n = 0;
Steven Whitehousedbac6712008-01-29 09:12:55 +0000218 bn = mp->mp_bh[0]->b_blocknr;
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400219 if (new_height > 1) {
220 for(; n < new_height-1; n++) {
Steven Whitehousedbac6712008-01-29 09:12:55 +0000221 gfs2_metatype_set(mp->mp_bh[n], GFS2_METATYPE_IN,
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400222 GFS2_FORMAT_IN);
Steven Whitehousedbac6712008-01-29 09:12:55 +0000223 gfs2_buffer_clear_tail(mp->mp_bh[n],
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400224 sizeof(struct gfs2_meta_header));
Steven Whitehousedbac6712008-01-29 09:12:55 +0000225 bp = (__be64 *)(mp->mp_bh[n]->b_data +
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400226 sizeof(struct gfs2_meta_header));
Steven Whitehousedbac6712008-01-29 09:12:55 +0000227 *bp = cpu_to_be64(mp->mp_bh[n+1]->b_blocknr);
228 brelse(mp->mp_bh[n]);
229 mp->mp_bh[n] = NULL;
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400230 }
231 }
Steven Whitehousedbac6712008-01-29 09:12:55 +0000232 gfs2_metatype_set(mp->mp_bh[n], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
233 gfs2_buffer_copy_tail(mp->mp_bh[n], sizeof(struct gfs2_meta_header),
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400234 dibh, sizeof(struct gfs2_dinode));
Steven Whitehousedbac6712008-01-29 09:12:55 +0000235 brelse(mp->mp_bh[n]);
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400236 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400237 di = (struct gfs2_dinode *)dibh->b_data;
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400238 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400239 *(__be64 *)(di + 1) = cpu_to_be64(bn);
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000240 ip->i_height += new_height;
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400241 ip->i_di.di_blocks += new_height;
Steven Whitehouse9e2dbda2006-11-08 15:45:46 -0500242 gfs2_set_inode_blocks(&ip->i_inode);
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000243 di->di_height = cpu_to_be16(ip->i_height);
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400244 di->di_blocks = cpu_to_be64(ip->i_di.di_blocks);
Steven Whitehousee90c01e2006-05-12 12:09:15 -0400245 brelse(dibh);
246 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000247}
248
249/**
250 * find_metapath - Find path through the metadata tree
251 * @ip: The inode pointer
252 * @mp: The metapath to return the result in
253 * @block: The disk block to look up
254 *
255 * This routine returns a struct metapath structure that defines a path
256 * through the metadata of inode "ip" to get to block "block".
257 *
258 * Example:
259 * Given: "ip" is a height 3 file, "offset" is 101342453, and this is a
260 * filesystem with a blocksize of 4096.
261 *
262 * find_metapath() would return a struct metapath structure set to:
263 * mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,
264 * and mp_list[2] = 165.
265 *
266 * That means that in order to get to the block containing the byte at
267 * offset 101342453, we would load the indirect block pointed to by pointer
268 * 0 in the dinode. We would then load the indirect block pointed to by
269 * pointer 48 in that indirect block. We would then load the data block
270 * pointed to by pointer 165 in that indirect block.
271 *
272 * ----------------------------------------
273 * | Dinode | |
274 * | | 4|
275 * | |0 1 2 3 4 5 9|
276 * | | 6|
277 * ----------------------------------------
278 * |
279 * |
280 * V
281 * ----------------------------------------
282 * | Indirect Block |
283 * | 5|
284 * | 4 4 4 4 4 5 5 1|
285 * |0 5 6 7 8 9 0 1 2|
286 * ----------------------------------------
287 * |
288 * |
289 * V
290 * ----------------------------------------
291 * | Indirect Block |
292 * | 1 1 1 1 1 5|
293 * | 6 6 6 6 6 1|
294 * |0 3 4 5 6 7 2|
295 * ----------------------------------------
296 * |
297 * |
298 * V
299 * ----------------------------------------
300 * | Data block containing offset |
301 * | 101342453 |
302 * | |
303 * | |
304 * ----------------------------------------
305 *
306 */
307
Steven Whitehousecd915492006-09-04 12:49:07 -0400308static void find_metapath(struct gfs2_inode *ip, u64 block,
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500309 struct metapath *mp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000310{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400311 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000312 unsigned int i;
313
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000314 for (i = ip->i_height; i--;)
Bob Peterson7eabb772008-01-28 11:24:35 -0600315 mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000316
317}
318
319/**
320 * metapointer - Return pointer to start of metadata in a buffer
David Teiglandb3b94fa2006-01-16 16:50:04 +0000321 * @height: The metadata height (0 = dinode)
322 * @mp: The metapath
323 *
324 * Return a pointer to the block number of the next height of the metadata
325 * tree given a buffer containing the pointer to the current height of the
326 * metadata tree.
327 */
328
Steven Whitehousedbac6712008-01-29 09:12:55 +0000329static inline __be64 *metapointer(int *boundary, unsigned int height,
330 const struct metapath *mp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000331{
Steven Whitehousedbac6712008-01-29 09:12:55 +0000332 struct buffer_head *bh = mp->mp_bh[height];
David Teiglandb3b94fa2006-01-16 16:50:04 +0000333 unsigned int head_size = (height > 0) ?
334 sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
Al Virob44b84d2006-10-14 10:46:30 -0400335 __be64 *ptr;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400336 *boundary = 0;
Al Virob44b84d2006-10-14 10:46:30 -0400337 ptr = ((__be64 *)(bh->b_data + head_size)) + mp->mp_list[height];
338 if (ptr + 1 == (__be64 *)(bh->b_data + bh->b_size))
Steven Whitehousefd88de562006-05-05 16:59:11 -0400339 *boundary = 1;
340 return ptr;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000341}
342
343/**
344 * lookup_block - Get the next metadata block in metadata tree
345 * @ip: The GFS2 inode
David Teiglandb3b94fa2006-01-16 16:50:04 +0000346 * @height: The height of the tree (0 = dinode)
347 * @mp: The metapath
348 * @create: Non-zero if we may create a new meatdata block
349 * @new: Used to indicate if we did create a new metadata block
350 * @block: the returned disk block number
351 *
352 * Given a metatree, complete to a particular height, checks to see if the next
353 * height of the tree exists. If not the next height of the tree is created.
354 * The block number of the next height of the metadata tree is returned.
355 *
356 */
357
Steven Whitehousedbac6712008-01-29 09:12:55 +0000358static int lookup_block(struct gfs2_inode *ip, unsigned int height,
359 struct metapath *mp, int create,
Steven Whitehousecd915492006-09-04 12:49:07 -0400360 int *new, u64 *block)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000361{
Steven Whitehousefd88de562006-05-05 16:59:11 -0400362 int boundary;
Steven Whitehousedbac6712008-01-29 09:12:55 +0000363 __be64 *ptr = metapointer(&boundary, height, mp);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000364 unsigned int n = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000365
366 if (*ptr) {
367 *block = be64_to_cpu(*ptr);
Steven Whitehousefd88de562006-05-05 16:59:11 -0400368 return boundary;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000369 }
370
371 *block = 0;
372
373 if (!create)
Steven Whitehousefd88de562006-05-05 16:59:11 -0400374 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000375
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000376 *block = gfs2_alloc_block(ip, &n);
Steven Whitehouse16394312008-02-01 14:52:30 +0000377 if (height != ip->i_height - 1 || gfs2_is_dir(ip))
Steven Whitehouse5731be52008-02-01 13:16:55 +0000378 gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), *block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000379
Steven Whitehousedbac6712008-01-29 09:12:55 +0000380 gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[height], 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000381
382 *ptr = cpu_to_be64(*block);
383 ip->i_di.di_blocks++;
Steven Whitehouse9e2dbda2006-11-08 15:45:46 -0500384 gfs2_set_inode_blocks(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000385
386 *new = 1;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400387 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000388}
389
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000390static int lookup_metapath(struct inode *inode, struct metapath *mp,
Steven Whitehousedbac6712008-01-29 09:12:55 +0000391 int create, int *new, u64 *dblock)
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000392{
Steven Whitehousedbac6712008-01-29 09:12:55 +0000393 struct buffer_head *bh;
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000394 struct gfs2_inode *ip = GFS2_I(inode);
395 unsigned int end_of_metadata = ip->i_height - 1;
396 unsigned int x;
Steven Whitehousedbac6712008-01-29 09:12:55 +0000397 int ret = gfs2_meta_inode_buffer(ip, &bh);
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000398 if (ret)
399 return ret;
400
Steven Whitehousedbac6712008-01-29 09:12:55 +0000401 mp->mp_bh[0] = bh;
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000402
403 for (x = 0; x < end_of_metadata; x++) {
Steven Whitehousedbac6712008-01-29 09:12:55 +0000404 lookup_block(ip, x, mp, create, new, dblock);
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000405 if (!dblock)
406 return 0;
407
Steven Whitehousedbac6712008-01-29 09:12:55 +0000408 ret = gfs2_meta_indirect_buffer(ip, x+1, *dblock, *new, &mp->mp_bh[x+1]);
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000409 if (ret)
410 return ret;
411 }
412
Steven Whitehousedbac6712008-01-29 09:12:55 +0000413 return lookup_block(ip, end_of_metadata, mp, create, new, dblock);
414}
415
416static void release_metapath(struct metapath *mp)
417{
418 int i;
419
420 for (i = 0; i < GFS2_MAX_META_HEIGHT; i++)
421 if (mp->mp_bh[i])
422 brelse(mp->mp_bh[i]);
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000423}
424
Steven Whitehousefd88de562006-05-05 16:59:11 -0400425static inline void bmap_lock(struct inode *inode, int create)
426{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400427 struct gfs2_inode *ip = GFS2_I(inode);
Steven Whitehousefd88de562006-05-05 16:59:11 -0400428 if (create)
429 down_write(&ip->i_rw_mutex);
430 else
431 down_read(&ip->i_rw_mutex);
432}
433
434static inline void bmap_unlock(struct inode *inode, int create)
435{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400436 struct gfs2_inode *ip = GFS2_I(inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000437 if (create)
438 up_write(&ip->i_rw_mutex);
439 else
440 up_read(&ip->i_rw_mutex);
Steven Whitehousefd88de562006-05-05 16:59:11 -0400441}
David Teiglandb3b94fa2006-01-16 16:50:04 +0000442
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500443/**
444 * gfs2_block_map - Map a block from an inode to a disk block
445 * @inode: The inode
446 * @lblock: The logical block number
447 * @bh_map: The bh to be mapped
448 *
449 * Find the block number on the current device which corresponds to an
450 * inode's block. If the block had to be created, "new" will be set.
451 *
452 * Returns: errno
453 */
454
Bob Petersone9e1ef22007-12-10 14:13:27 -0600455int gfs2_block_map(struct inode *inode, sector_t lblock,
456 struct buffer_head *bh_map, int create)
Steven Whitehousefd88de562006-05-05 16:59:11 -0400457{
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500458 struct gfs2_inode *ip = GFS2_I(inode);
459 struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000460 unsigned int bsize = sdp->sd_sb.sb_bsize;
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500461 int error = 0;
462 int new = 0;
463 u64 dblock = 0;
464 int boundary;
465 unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400466 struct metapath mp;
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500467 u64 size;
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000468 const u64 *arr = sdp->sd_heightsize;
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500469 BUG_ON(maxlen == 0);
470
471 if (gfs2_assert_warn(sdp, !gfs2_is_stuffed(ip)))
472 return 0;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400473
Steven Whitehousedbac6712008-01-29 09:12:55 +0000474 memset(mp.mp_bh, 0, sizeof(mp.mp_bh));
Steven Whitehousefd88de562006-05-05 16:59:11 -0400475 bmap_lock(inode, create);
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500476 clear_buffer_mapped(bh_map);
477 clear_buffer_new(bh_map);
478 clear_buffer_boundary(bh_map);
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000479 if (gfs2_is_dir(ip)) {
480 bsize = sdp->sd_jbsize;
481 arr = sdp->sd_jheightsize;
482 }
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500483 size = (lblock + 1) * bsize;
484
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000485 if (size > arr[ip->i_height]) {
486 u8 height = ip->i_height;
487 if (!create)
488 goto out_ok;
489 while (size > arr[height])
490 height++;
Steven Whitehousedbac6712008-01-29 09:12:55 +0000491 error = build_height(inode, &mp, height);
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000492 if (error)
493 goto out_fail;
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500494 }
495
496 find_metapath(ip, lblock, &mp);
Steven Whitehousedbac6712008-01-29 09:12:55 +0000497 error = lookup_metapath(inode, &mp, create, &new, &dblock);
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000498 if (error < 0)
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500499 goto out_fail;
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000500 boundary = error;
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500501
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500502 if (dblock) {
503 map_bh(bh_map, inode->i_sb, dblock);
504 if (boundary)
505 set_buffer_boundary(bh_map);
506 if (new) {
Steven Whitehousedbac6712008-01-29 09:12:55 +0000507 gfs2_trans_add_bh(ip->i_gl, mp.mp_bh[0], 1);
508 gfs2_dinode_out(ip, mp.mp_bh[0]->b_data);
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500509 set_buffer_new(bh_map);
Steven Whitehousedbac6712008-01-29 09:12:55 +0000510 goto out_ok;
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500511 }
512 while(--maxlen && !buffer_boundary(bh_map)) {
513 u64 eblock;
Steven Whitehousedbac6712008-01-29 09:12:55 +0000514 mp.mp_list[ip->i_height - 1]++;
515 boundary = lookup_block(ip, ip->i_height - 1, &mp, 0, &new, &eblock);
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500516 if (eblock != ++dblock)
517 break;
518 bh_map->b_size += (1 << inode->i_blkbits);
519 if (boundary)
520 set_buffer_boundary(bh_map);
521 }
522 }
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500523out_ok:
524 error = 0;
525out_fail:
Steven Whitehousedbac6712008-01-29 09:12:55 +0000526 release_metapath(&mp);
Steven Whitehousefd88de562006-05-05 16:59:11 -0400527 bmap_unlock(inode, create);
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500528 return error;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400529}
530
Steven Whitehouse941e6d72008-01-28 08:47:38 +0000531/*
532 * Deprecated: do not use in new code
533 */
Steven Whitehousefd88de562006-05-05 16:59:11 -0400534int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
535{
Steven Whitehouse23591252006-10-13 17:25:45 -0400536 struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400537 int ret;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400538 int create = *new;
539
540 BUG_ON(!extlen);
541 BUG_ON(!dblock);
542 BUG_ON(!new);
543
Steven Whitehouse23591252006-10-13 17:25:45 -0400544 bh.b_size = 1 << (inode->i_blkbits + 5);
Bob Petersone9e1ef22007-12-10 14:13:27 -0600545 ret = gfs2_block_map(inode, lblock, &bh, create);
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400546 *extlen = bh.b_size >> inode->i_blkbits;
547 *dblock = bh.b_blocknr;
548 if (buffer_new(&bh))
549 *new = 1;
550 else
551 *new = 0;
552 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000553}
554
555/**
556 * recursive_scan - recursively scan through the end of a file
557 * @ip: the inode
558 * @dibh: the dinode buffer
559 * @mp: the path through the metadata to the point to start
560 * @height: the height the recursion is at
561 * @block: the indirect block to look at
562 * @first: 1 if this is the first block
563 * @bc: the call to make for each piece of metadata
564 * @data: data opaque to this function to pass to @bc
565 *
566 * When this is first called @height and @block should be zero and
567 * @first should be 1.
568 *
569 * Returns: errno
570 */
571
572static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh,
573 struct metapath *mp, unsigned int height,
Steven Whitehousecd915492006-09-04 12:49:07 -0400574 u64 block, int first, block_call_t bc,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000575 void *data)
576{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400577 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000578 struct buffer_head *bh = NULL;
Al Virob44b84d2006-10-14 10:46:30 -0400579 __be64 *top, *bottom;
Steven Whitehousecd915492006-09-04 12:49:07 -0400580 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000581 int error;
582 int mh_size = sizeof(struct gfs2_meta_header);
583
584 if (!height) {
585 error = gfs2_meta_inode_buffer(ip, &bh);
586 if (error)
587 return error;
588 dibh = bh;
589
Al Virob44b84d2006-10-14 10:46:30 -0400590 top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];
591 bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000592 } else {
593 error = gfs2_meta_indirect_buffer(ip, height, block, 0, &bh);
594 if (error)
595 return error;
596
Al Virob44b84d2006-10-14 10:46:30 -0400597 top = (__be64 *)(bh->b_data + mh_size) +
Jan Engelhardtc5392122006-09-05 14:30:40 +0200598 (first ? mp->mp_list[height] : 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000599
Al Virob44b84d2006-10-14 10:46:30 -0400600 bottom = (__be64 *)(bh->b_data + mh_size) + sdp->sd_inptrs;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000601 }
602
603 error = bc(ip, dibh, bh, top, bottom, height, data);
604 if (error)
605 goto out;
606
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000607 if (height < ip->i_height - 1)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000608 for (; top < bottom; top++, first = 0) {
609 if (!*top)
610 continue;
611
612 bn = be64_to_cpu(*top);
613
614 error = recursive_scan(ip, dibh, mp, height + 1, bn,
615 first, bc, data);
616 if (error)
617 break;
618 }
619
Steven Whitehousea91ea692006-09-04 12:04:26 -0400620out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000621 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000622 return error;
623}
624
625/**
626 * do_strip - Look for a layer a particular layer of the file and strip it off
627 * @ip: the inode
628 * @dibh: the dinode buffer
629 * @bh: A buffer of pointers
630 * @top: The first pointer in the buffer
631 * @bottom: One more than the last pointer
632 * @height: the height this buffer is at
633 * @data: a pointer to a struct strip_mine
634 *
635 * Returns: errno
636 */
637
638static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
Al Virob44b84d2006-10-14 10:46:30 -0400639 struct buffer_head *bh, __be64 *top, __be64 *bottom,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000640 unsigned int height, void *data)
641{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400642 struct strip_mine *sm = data;
643 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000644 struct gfs2_rgrp_list rlist;
Steven Whitehousecd915492006-09-04 12:49:07 -0400645 u64 bn, bstart;
646 u32 blen;
Al Virob44b84d2006-10-14 10:46:30 -0400647 __be64 *p;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000648 unsigned int rg_blocks = 0;
649 int metadata;
650 unsigned int revokes = 0;
651 int x;
652 int error;
653
654 if (!*top)
655 sm->sm_first = 0;
656
657 if (height != sm->sm_height)
658 return 0;
659
660 if (sm->sm_first) {
661 top++;
662 sm->sm_first = 0;
663 }
664
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000665 metadata = (height != ip->i_height - 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000666 if (metadata)
667 revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs;
668
Steven Whitehouse6dbd8222008-01-10 15:18:55 +0000669 error = gfs2_rindex_hold(sdp, &ip->i_alloc->al_ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000670 if (error)
671 return error;
672
673 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
674 bstart = 0;
675 blen = 0;
676
677 for (p = top; p < bottom; p++) {
678 if (!*p)
679 continue;
680
681 bn = be64_to_cpu(*p);
682
683 if (bstart + blen == bn)
684 blen++;
685 else {
686 if (bstart)
687 gfs2_rlist_add(sdp, &rlist, bstart);
688
689 bstart = bn;
690 blen = 1;
691 }
692 }
693
694 if (bstart)
695 gfs2_rlist_add(sdp, &rlist, bstart);
696 else
697 goto out; /* Nothing to do */
698
Bob Petersonfe6c9912008-01-28 11:13:02 -0600699 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000700
701 for (x = 0; x < rlist.rl_rgrps; x++) {
702 struct gfs2_rgrpd *rgd;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500703 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100704 rg_blocks += rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000705 }
706
707 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
708 if (error)
709 goto out_rlist;
710
711 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +
712 RES_INDIRECT + RES_STATFS + RES_QUOTA,
713 revokes);
714 if (error)
715 goto out_rg_gunlock;
716
717 down_write(&ip->i_rw_mutex);
718
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000719 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
720 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000721
722 bstart = 0;
723 blen = 0;
724
725 for (p = top; p < bottom; p++) {
726 if (!*p)
727 continue;
728
729 bn = be64_to_cpu(*p);
730
731 if (bstart + blen == bn)
732 blen++;
733 else {
734 if (bstart) {
735 if (metadata)
736 gfs2_free_meta(ip, bstart, blen);
737 else
738 gfs2_free_data(ip, bstart, blen);
739 }
740
741 bstart = bn;
742 blen = 1;
743 }
744
745 *p = 0;
746 if (!ip->i_di.di_blocks)
747 gfs2_consist_inode(ip);
748 ip->i_di.di_blocks--;
Steven Whitehouse9e2dbda2006-11-08 15:45:46 -0500749 gfs2_set_inode_blocks(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000750 }
751 if (bstart) {
752 if (metadata)
753 gfs2_free_meta(ip, bstart, blen);
754 else
755 gfs2_free_data(ip, bstart, blen);
756 }
757
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100758 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000759
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500760 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000761
762 up_write(&ip->i_rw_mutex);
763
764 gfs2_trans_end(sdp);
765
Steven Whitehousea91ea692006-09-04 12:04:26 -0400766out_rg_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000767 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400768out_rlist:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000769 gfs2_rlist_free(&rlist);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400770out:
Steven Whitehouse6dbd8222008-01-10 15:18:55 +0000771 gfs2_glock_dq_uninit(&ip->i_alloc->al_ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000772 return error;
773}
774
775/**
776 * do_grow - Make a file look bigger than it is
777 * @ip: the inode
778 * @size: the size to set the file to
779 *
780 * Called with an exclusive lock on @ip.
781 *
782 * Returns: errno
783 */
784
Steven Whitehousecd915492006-09-04 12:49:07 -0400785static int do_grow(struct gfs2_inode *ip, u64 size)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000786{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400787 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000788 struct gfs2_alloc *al;
789 struct buffer_head *dibh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000790 int error;
791
792 al = gfs2_alloc_get(ip);
793
794 error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
795 if (error)
796 goto out;
797
Steven Whitehouse2933f922006-11-01 13:23:29 -0500798 error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000799 if (error)
800 goto out_gunlock_q;
801
802 al->al_requested = sdp->sd_max_height + RES_DATA;
803
804 error = gfs2_inplace_reserve(ip);
805 if (error)
806 goto out_gunlock_q;
807
808 error = gfs2_trans_begin(sdp,
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100809 sdp->sd_max_height + al->al_rgd->rd_length +
David Teiglandb3b94fa2006-01-16 16:50:04 +0000810 RES_JDATA + RES_DINODE + RES_STATFS + RES_QUOTA, 0);
811 if (error)
812 goto out_ipres;
813
814 if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000815 const u64 *arr = sdp->sd_heightsize;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000816 if (gfs2_is_stuffed(ip)) {
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400817 error = gfs2_unstuff_dinode(ip, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000818 if (error)
819 goto out_end_trans;
820 }
821
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000822 down_write(&ip->i_rw_mutex);
823 if (size > arr[ip->i_height]) {
Steven Whitehousedbac6712008-01-29 09:12:55 +0000824 struct metapath mp;
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000825 u8 height = ip->i_height;
826 while(size > arr[height])
827 height++;
Steven Whitehousedbac6712008-01-29 09:12:55 +0000828 error = build_height(&ip->i_inode, &mp, height);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000829 }
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000830 up_write(&ip->i_rw_mutex);
831 if (error)
832 goto out_end_trans;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000833 }
834
835 ip->i_di.di_size = size;
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100836 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000837
838 error = gfs2_meta_inode_buffer(ip, &dibh);
839 if (error)
840 goto out_end_trans;
841
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000842 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500843 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000844 brelse(dibh);
845
Steven Whitehousea91ea692006-09-04 12:04:26 -0400846out_end_trans:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000847 gfs2_trans_end(sdp);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400848out_ipres:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000849 gfs2_inplace_release(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400850out_gunlock_q:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000851 gfs2_quota_unlock(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400852out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000853 gfs2_alloc_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000854 return error;
855}
856
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400857
858/**
859 * gfs2_block_truncate_page - Deal with zeroing out data for truncate
860 *
861 * This is partly borrowed from ext3.
862 */
863static int gfs2_block_truncate_page(struct address_space *mapping)
864{
865 struct inode *inode = mapping->host;
866 struct gfs2_inode *ip = GFS2_I(inode);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400867 loff_t from = inode->i_size;
868 unsigned long index = from >> PAGE_CACHE_SHIFT;
869 unsigned offset = from & (PAGE_CACHE_SIZE-1);
870 unsigned blocksize, iblock, length, pos;
871 struct buffer_head *bh;
872 struct page *page;
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400873 int err;
874
875 page = grab_cache_page(mapping, index);
876 if (!page)
877 return 0;
878
879 blocksize = inode->i_sb->s_blocksize;
880 length = blocksize - (offset & (blocksize - 1));
881 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
882
883 if (!page_has_buffers(page))
884 create_empty_buffers(page, blocksize, 0);
885
886 /* Find the buffer that contains "offset" */
887 bh = page_buffers(page);
888 pos = blocksize;
889 while (offset >= pos) {
890 bh = bh->b_this_page;
891 iblock++;
892 pos += blocksize;
893 }
894
895 err = 0;
896
897 if (!buffer_mapped(bh)) {
Bob Petersone9e1ef22007-12-10 14:13:27 -0600898 gfs2_block_map(inode, iblock, bh, 0);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400899 /* unmapped? It's a hole - nothing to do */
900 if (!buffer_mapped(bh))
901 goto unlock;
902 }
903
904 /* Ok, it's mapped. Make sure it's up-to-date */
905 if (PageUptodate(page))
906 set_buffer_uptodate(bh);
907
908 if (!buffer_uptodate(bh)) {
909 err = -EIO;
910 ll_rw_block(READ, 1, &bh);
911 wait_on_buffer(bh);
912 /* Uhhuh. Read error. Complain and punt. */
913 if (!buffer_uptodate(bh))
914 goto unlock;
S. Wendy Cheng1875f2f2007-06-25 21:14:31 -0400915 err = 0;
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400916 }
917
Steven Whitehousebf36a712007-10-17 08:35:19 +0100918 if (!gfs2_is_writeback(ip))
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400919 gfs2_trans_add_bh(ip->i_gl, bh, 0);
920
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800921 zero_user(page, offset, length);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400922
923unlock:
924 unlock_page(page);
925 page_cache_release(page);
926 return err;
927}
928
Steven Whitehousecd915492006-09-04 12:49:07 -0400929static int trunc_start(struct gfs2_inode *ip, u64 size)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000930{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400931 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000932 struct buffer_head *dibh;
933 int journaled = gfs2_is_jdata(ip);
934 int error;
935
936 error = gfs2_trans_begin(sdp,
Jan Engelhardtc5392122006-09-05 14:30:40 +0200937 RES_DINODE + (journaled ? RES_JDATA : 0), 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000938 if (error)
939 return error;
940
941 error = gfs2_meta_inode_buffer(ip, &dibh);
942 if (error)
943 goto out;
944
945 if (gfs2_is_stuffed(ip)) {
946 ip->i_di.di_size = size;
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100947 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000948 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500949 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000950 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + size);
951 error = 1;
952
953 } else {
Steven Whitehousecd915492006-09-04 12:49:07 -0400954 if (size & (u64)(sdp->sd_sb.sb_bsize - 1))
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400955 error = gfs2_block_truncate_page(ip->i_inode.i_mapping);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000956
957 if (!error) {
958 ip->i_di.di_size = size;
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100959 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000960 ip->i_di.di_flags |= GFS2_DIF_TRUNC_IN_PROG;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000961 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500962 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000963 }
964 }
965
966 brelse(dibh);
967
Steven Whitehousea91ea692006-09-04 12:04:26 -0400968out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000969 gfs2_trans_end(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000970 return error;
971}
972
Steven Whitehousecd915492006-09-04 12:49:07 -0400973static int trunc_dealloc(struct gfs2_inode *ip, u64 size)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000974{
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000975 unsigned int height = ip->i_height;
Steven Whitehousecd915492006-09-04 12:49:07 -0400976 u64 lblock;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000977 struct metapath mp;
978 int error;
979
980 if (!size)
981 lblock = 0;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000982 else
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400983 lblock = (size - 1) >> GFS2_SB(&ip->i_inode)->sd_sb.sb_bsize_shift;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000984
985 find_metapath(ip, lblock, &mp);
986 gfs2_alloc_get(ip);
987
988 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
989 if (error)
990 goto out;
991
992 while (height--) {
993 struct strip_mine sm;
994 sm.sm_first = !!size;
995 sm.sm_height = height;
996
997 error = recursive_scan(ip, NULL, &mp, 0, 0, 1, do_strip, &sm);
998 if (error)
999 break;
1000 }
1001
1002 gfs2_quota_unhold(ip);
1003
Steven Whitehousea91ea692006-09-04 12:04:26 -04001004out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001005 gfs2_alloc_put(ip);
1006 return error;
1007}
1008
1009static int trunc_end(struct gfs2_inode *ip)
1010{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001011 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001012 struct buffer_head *dibh;
1013 int error;
1014
1015 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1016 if (error)
1017 return error;
1018
1019 down_write(&ip->i_rw_mutex);
1020
1021 error = gfs2_meta_inode_buffer(ip, &dibh);
1022 if (error)
1023 goto out;
1024
1025 if (!ip->i_di.di_size) {
Steven Whitehouseecc30c72008-01-28 10:37:35 +00001026 ip->i_height = 0;
Steven Whitehousece276b02008-02-06 09:25:45 +00001027 ip->i_goal = ip->i_no_addr;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001028 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1029 }
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +01001030 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001031 ip->i_di.di_flags &= ~GFS2_DIF_TRUNC_IN_PROG;
1032
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001033 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001034 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001035 brelse(dibh);
1036
Steven Whitehousea91ea692006-09-04 12:04:26 -04001037out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001038 up_write(&ip->i_rw_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001039 gfs2_trans_end(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001040 return error;
1041}
1042
1043/**
1044 * do_shrink - make a file smaller
1045 * @ip: the inode
1046 * @size: the size to make the file
1047 * @truncator: function to truncate the last partial block
1048 *
1049 * Called with an exclusive lock on @ip.
1050 *
1051 * Returns: errno
1052 */
1053
Steven Whitehousecd915492006-09-04 12:49:07 -04001054static int do_shrink(struct gfs2_inode *ip, u64 size)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001055{
1056 int error;
1057
Steven Whitehouseaa6a85a2006-01-24 10:37:06 +00001058 error = trunc_start(ip, size);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001059 if (error < 0)
1060 return error;
1061 if (error > 0)
1062 return 0;
1063
1064 error = trunc_dealloc(ip, size);
1065 if (!error)
1066 error = trunc_end(ip);
1067
1068 return error;
1069}
1070
Wendy Chenga13b8c52007-08-20 09:29:53 -04001071static int do_touch(struct gfs2_inode *ip, u64 size)
1072{
1073 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1074 struct buffer_head *dibh;
1075 int error;
1076
1077 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1078 if (error)
1079 return error;
1080
1081 down_write(&ip->i_rw_mutex);
1082
1083 error = gfs2_meta_inode_buffer(ip, &dibh);
1084 if (error)
1085 goto do_touch_out;
1086
1087 ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1088 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1089 gfs2_dinode_out(ip, dibh->b_data);
1090 brelse(dibh);
1091
1092do_touch_out:
1093 up_write(&ip->i_rw_mutex);
1094 gfs2_trans_end(sdp);
1095 return error;
1096}
1097
David Teiglandb3b94fa2006-01-16 16:50:04 +00001098/**
Steven Whitehouse666a2c52006-01-18 10:29:04 +00001099 * gfs2_truncatei - make a file a given size
David Teiglandb3b94fa2006-01-16 16:50:04 +00001100 * @ip: the inode
1101 * @size: the size to make the file
1102 * @truncator: function to truncate the last partial block
1103 *
1104 * The file size can grow, shrink, or stay the same size.
1105 *
1106 * Returns: errno
1107 */
1108
Steven Whitehousecd915492006-09-04 12:49:07 -04001109int gfs2_truncatei(struct gfs2_inode *ip, u64 size)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001110{
1111 int error;
1112
Steven Whitehouseb60623c2006-11-01 12:22:46 -05001113 if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), S_ISREG(ip->i_inode.i_mode)))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001114 return -EINVAL;
1115
1116 if (size > ip->i_di.di_size)
1117 error = do_grow(ip, size);
Wendy Chenga13b8c52007-08-20 09:29:53 -04001118 else if (size < ip->i_di.di_size)
Steven Whitehouseaa6a85a2006-01-24 10:37:06 +00001119 error = do_shrink(ip, size);
Wendy Chenga13b8c52007-08-20 09:29:53 -04001120 else
1121 /* update time stamps */
1122 error = do_touch(ip, size);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001123
1124 return error;
1125}
1126
1127int gfs2_truncatei_resume(struct gfs2_inode *ip)
1128{
1129 int error;
1130 error = trunc_dealloc(ip, ip->i_di.di_size);
1131 if (!error)
1132 error = trunc_end(ip);
1133 return error;
1134}
1135
1136int gfs2_file_dealloc(struct gfs2_inode *ip)
1137{
1138 return trunc_dealloc(ip, 0);
1139}
1140
1141/**
1142 * gfs2_write_calc_reserv - calculate number of blocks needed to write to a file
1143 * @ip: the file
1144 * @len: the number of bytes to be written to the file
1145 * @data_blocks: returns the number of data blocks required
1146 * @ind_blocks: returns the number of indirect blocks required
1147 *
1148 */
1149
1150void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len,
1151 unsigned int *data_blocks, unsigned int *ind_blocks)
1152{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001153 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001154 unsigned int tmp;
1155
Steven Whitehouse18ec7d52006-02-08 11:50:51 +00001156 if (gfs2_is_dir(ip)) {
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001157 *data_blocks = DIV_ROUND_UP(len, sdp->sd_jbsize) + 2;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001158 *ind_blocks = 3 * (sdp->sd_max_jheight - 1);
1159 } else {
1160 *data_blocks = (len >> sdp->sd_sb.sb_bsize_shift) + 3;
1161 *ind_blocks = 3 * (sdp->sd_max_height - 1);
1162 }
1163
1164 for (tmp = *data_blocks; tmp > sdp->sd_diptrs;) {
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001165 tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001166 *ind_blocks += tmp;
1167 }
1168}
1169
1170/**
1171 * gfs2_write_alloc_required - figure out if a write will require an allocation
1172 * @ip: the file being written to
1173 * @offset: the offset to write to
1174 * @len: the number of bytes being written
1175 * @alloc_required: set to 1 if an alloc is required, 0 otherwise
1176 *
1177 * Returns: errno
1178 */
1179
Steven Whitehousecd915492006-09-04 12:49:07 -04001180int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001181 unsigned int len, int *alloc_required)
1182{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001183 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001184 struct buffer_head bh;
1185 unsigned int shift;
1186 u64 lblock, lblock_stop, size;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001187
1188 *alloc_required = 0;
1189
1190 if (!len)
1191 return 0;
1192
1193 if (gfs2_is_stuffed(ip)) {
1194 if (offset + len >
1195 sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
1196 *alloc_required = 1;
1197 return 0;
1198 }
1199
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001200 *alloc_required = 1;
1201 shift = sdp->sd_sb.sb_bsize_shift;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +00001202 if (gfs2_is_dir(ip)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001203 unsigned int bsize = sdp->sd_jbsize;
1204 lblock = offset;
1205 do_div(lblock, bsize);
1206 lblock_stop = offset + len + bsize - 1;
1207 do_div(lblock_stop, bsize);
1208 } else {
Steven Whitehouse1af53572008-01-16 14:24:05 +00001209 u64 end_of_file = (ip->i_di.di_size + sdp->sd_sb.sb_bsize - 1) >> shift;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001210 lblock = offset >> shift;
1211 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001212 if (lblock_stop > end_of_file)
Bob Peterson05220532008-01-11 13:44:50 -06001213 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001214 }
1215
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001216 size = (lblock_stop - lblock) << shift;
1217 do {
1218 bh.b_state = 0;
1219 bh.b_size = size;
1220 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
1221 if (!buffer_mapped(&bh))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001222 return 0;
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001223 size -= bh.b_size;
1224 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1225 } while(size > 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001226
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001227 *alloc_required = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001228 return 0;
1229}
1230