blob: 51f940e76c5e329b5d3e43b07a84485e0f512c6c [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/spinlock.h>
11#include <linux/completion.h>
12#include <linux/buffer_head.h>
Benjamin Marzinski64dd1532011-09-12 18:15:24 -050013#include <linux/blkdev.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>
Bob Peterson39743202017-02-16 10:27:16 -050016#include <linux/iomap.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"
Steven Whitehouse45138992013-01-28 09:30:07 +000026#include "log.h"
Bob Peterson4c16c362011-02-23 16:11:33 -050027#include "super.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000028#include "trans.h"
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000029#include "dir.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050030#include "util.h"
Steven Whitehouse63997772009-06-12 08:49:20 +010031#include "trace_gfs2.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000032
33/* This doesn't need to be that large as max 64 bit pointers in a 4k
34 * block is 512, so __u16 is fine for that. It saves stack space to
35 * keep it small.
36 */
37struct metapath {
Steven Whitehousedbac6712008-01-29 09:12:55 +000038 struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
David Teiglandb3b94fa2006-01-16 16:50:04 +000039 __u16 mp_list[GFS2_MAX_META_HEIGHT];
Bob Peterson5f8bd442016-10-28 14:29:29 -050040 int mp_fheight; /* find_metapath height */
41 int mp_aheight; /* actual height (lookup height) */
David Teiglandb3b94fa2006-01-16 16:50:04 +000042};
43
David Teiglandb3b94fa2006-01-16 16:50:04 +000044/**
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040045 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
46 * @ip: the inode
47 * @dibh: the dinode buffer
48 * @block: the block number that was allocated
Steven Whitehouseff8f33c2010-08-11 09:37:53 +010049 * @page: The (optional) page. This is looked up if @page is NULL
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040050 *
51 * Returns: errno
52 */
53
54static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
Steven Whitehousecd915492006-09-04 12:49:07 -040055 u64 block, struct page *page)
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040056{
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040057 struct inode *inode = &ip->i_inode;
58 struct buffer_head *bh;
59 int release = 0;
60
61 if (!page || page->index) {
Bob Peterson220cca22012-03-19 15:25:50 -040062 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040063 if (!page)
64 return -ENOMEM;
65 release = 1;
66 }
67
68 if (!PageUptodate(page)) {
69 void *kaddr = kmap(page);
Steven Whitehouse602c89d2010-03-25 14:32:43 +000070 u64 dsize = i_size_read(inode);
71
Andreas Gruenbacher235628c2017-11-14 16:53:12 +010072 if (dsize > gfs2_max_stuffed_size(ip))
73 dsize = gfs2_max_stuffed_size(ip);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040074
Steven Whitehouse602c89d2010-03-25 14:32:43 +000075 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030076 memset(kaddr + dsize, 0, PAGE_SIZE - dsize);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040077 kunmap(page);
78
79 SetPageUptodate(page);
80 }
81
82 if (!page_has_buffers(page))
Fabian Frederick47a9a522016-08-02 12:05:27 -050083 create_empty_buffers(page, BIT(inode->i_blkbits),
84 BIT(BH_Uptodate));
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040085
86 bh = page_buffers(page);
87
88 if (!buffer_mapped(bh))
89 map_bh(bh, inode->i_sb, block);
90
91 set_buffer_uptodate(bh);
Steven Whitehouseeaf96522007-08-27 09:49:37 +010092 if (!gfs2_is_jdata(ip))
93 mark_buffer_dirty(bh);
Steven Whitehousebf36a712007-10-17 08:35:19 +010094 if (!gfs2_is_writeback(ip))
Steven Whitehouse350a9b02012-12-14 12:36:02 +000095 gfs2_trans_add_data(ip->i_gl, bh);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040096
97 if (release) {
98 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030099 put_page(page);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400100 }
101
102 return 0;
103}
104
105/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000106 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
107 * @ip: The GFS2 inode to unstuff
Steven Whitehouseff8f33c2010-08-11 09:37:53 +0100108 * @page: The (optional) page. This is looked up if the @page is NULL
David Teiglandb3b94fa2006-01-16 16:50:04 +0000109 *
110 * This routine unstuffs a dinode and returns it to a "normal" state such
111 * that the height can be grown in the traditional way.
112 *
113 * Returns: errno
114 */
115
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400116int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000117{
118 struct buffer_head *bh, *dibh;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400119 struct gfs2_dinode *di;
Steven Whitehousecd915492006-09-04 12:49:07 -0400120 u64 block = 0;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000121 int isdir = gfs2_is_dir(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000122 int error;
123
124 down_write(&ip->i_rw_mutex);
125
126 error = gfs2_meta_inode_buffer(ip, &dibh);
127 if (error)
128 goto out;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400129
Steven Whitehousea2e0f792010-08-11 09:53:11 +0100130 if (i_size_read(&ip->i_inode)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000131 /* Get a free block, fill it with the stuffed data,
132 and write it out to disk */
133
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000134 unsigned int n = 1;
Bob Peterson6e87ed02011-11-18 10:58:32 -0500135 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
Steven Whitehouse09010972009-05-20 10:48:47 +0100136 if (error)
137 goto out_brelse;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000138 if (isdir) {
Steven Whitehouse5731be52008-02-01 13:16:55 +0000139 gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
Steven Whitehouse61e085a2006-04-24 10:07:13 -0400140 error = gfs2_dir_get_new_buffer(ip, block, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000141 if (error)
142 goto out_brelse;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400143 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000144 dibh, sizeof(struct gfs2_dinode));
145 brelse(bh);
146 } else {
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400147 error = gfs2_unstuffer_page(ip, dibh, block, page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000148 if (error)
149 goto out_brelse;
150 }
151 }
152
153 /* Set up the pointer to the new block */
154
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000155 gfs2_trans_add_meta(ip->i_gl, dibh);
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400156 di = (struct gfs2_dinode *)dibh->b_data;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000157 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
158
Steven Whitehousea2e0f792010-08-11 09:53:11 +0100159 if (i_size_read(&ip->i_inode)) {
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400160 *(__be64 *)(di + 1) = cpu_to_be64(block);
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000161 gfs2_add_inode_blocks(&ip->i_inode, 1);
162 di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000163 }
164
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000165 ip->i_height = 1;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400166 di->di_height = cpu_to_be16(1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000167
Steven Whitehousea91ea692006-09-04 12:04:26 -0400168out_brelse:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000169 brelse(dibh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400170out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000171 up_write(&ip->i_rw_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000172 return error;
173}
174
David Teiglandb3b94fa2006-01-16 16:50:04 +0000175
176/**
177 * find_metapath - Find path through the metadata tree
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000178 * @sdp: The superblock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000179 * @mp: The metapath to return the result in
180 * @block: The disk block to look up
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000181 * @height: The pre-calculated height of the metadata tree
David Teiglandb3b94fa2006-01-16 16:50:04 +0000182 *
183 * This routine returns a struct metapath structure that defines a path
184 * through the metadata of inode "ip" to get to block "block".
185 *
186 * Example:
187 * Given: "ip" is a height 3 file, "offset" is 101342453, and this is a
188 * filesystem with a blocksize of 4096.
189 *
190 * find_metapath() would return a struct metapath structure set to:
191 * mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,
192 * and mp_list[2] = 165.
193 *
194 * That means that in order to get to the block containing the byte at
195 * offset 101342453, we would load the indirect block pointed to by pointer
196 * 0 in the dinode. We would then load the indirect block pointed to by
197 * pointer 48 in that indirect block. We would then load the data block
198 * pointed to by pointer 165 in that indirect block.
199 *
200 * ----------------------------------------
201 * | Dinode | |
202 * | | 4|
203 * | |0 1 2 3 4 5 9|
204 * | | 6|
205 * ----------------------------------------
206 * |
207 * |
208 * V
209 * ----------------------------------------
210 * | Indirect Block |
211 * | 5|
212 * | 4 4 4 4 4 5 5 1|
213 * |0 5 6 7 8 9 0 1 2|
214 * ----------------------------------------
215 * |
216 * |
217 * V
218 * ----------------------------------------
219 * | Indirect Block |
220 * | 1 1 1 1 1 5|
221 * | 6 6 6 6 6 1|
222 * |0 3 4 5 6 7 2|
223 * ----------------------------------------
224 * |
225 * |
226 * V
227 * ----------------------------------------
228 * | Data block containing offset |
229 * | 101342453 |
230 * | |
231 * | |
232 * ----------------------------------------
233 *
234 */
235
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000236static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
237 struct metapath *mp, unsigned int height)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000238{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000239 unsigned int i;
240
Bob Peterson5f8bd442016-10-28 14:29:29 -0500241 mp->mp_fheight = height;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000242 for (i = height; i--;)
Bob Peterson7eabb772008-01-28 11:24:35 -0600243 mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000244}
245
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500246static inline unsigned int metapath_branch_start(const struct metapath *mp)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000247{
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500248 if (mp->mp_list[0] == 0)
249 return 2;
250 return 1;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000251}
252
David Teiglandb3b94fa2006-01-16 16:50:04 +0000253/**
Andreas Gruenbacher20cdc192017-09-22 07:39:54 -0500254 * metaptr1 - Return the first possible metadata pointer in a metapath buffer
Bob Petersond552a2b2017-02-06 08:28:32 -0500255 * @height: The metadata height (0 = dinode)
256 * @mp: The metapath
257 */
258static inline __be64 *metaptr1(unsigned int height, const struct metapath *mp)
259{
260 struct buffer_head *bh = mp->mp_bh[height];
261 if (height == 0)
262 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)));
263 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header)));
264}
265
266/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000267 * metapointer - Return pointer to start of metadata in a buffer
David Teiglandb3b94fa2006-01-16 16:50:04 +0000268 * @height: The metadata height (0 = dinode)
269 * @mp: The metapath
270 *
271 * Return a pointer to the block number of the next height of the metadata
272 * tree given a buffer containing the pointer to the current height of the
273 * metadata tree.
274 */
275
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000276static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000277{
Bob Petersond552a2b2017-02-06 08:28:32 -0500278 __be64 *p = metaptr1(height, mp);
279 return p + mp->mp_list[height];
David Teiglandb3b94fa2006-01-16 16:50:04 +0000280}
281
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +0100282static void gfs2_metapath_ra(struct gfs2_glock *gl, __be64 *start, __be64 *end)
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100283{
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100284 const __be64 *t;
285
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +0100286 for (t = start; t < end; t++) {
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100287 struct buffer_head *rabh;
288
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100289 if (!*t)
290 continue;
291
292 rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);
293 if (trylock_buffer(rabh)) {
294 if (!buffer_uptodate(rabh)) {
295 rabh->b_end_io = end_buffer_read_sync;
Coly Lie477b242017-07-21 07:48:22 -0500296 submit_bh(REQ_OP_READ,
297 REQ_RAHEAD | REQ_META | REQ_PRIO,
298 rabh);
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100299 continue;
300 }
301 unlock_buffer(rabh);
302 }
303 brelse(rabh);
304 }
305}
306
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100307static int __fillup_metapath(struct gfs2_inode *ip, struct metapath *mp,
308 unsigned int x, unsigned int h)
Bob Petersond552a2b2017-02-06 08:28:32 -0500309{
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100310 for (; x < h; x++) {
311 __be64 *ptr = metapointer(x, mp);
312 u64 dblock = be64_to_cpu(*ptr);
313 int ret;
Bob Petersond552a2b2017-02-06 08:28:32 -0500314
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100315 if (!dblock)
316 break;
317 ret = gfs2_meta_indirect_buffer(ip, x + 1, dblock, &mp->mp_bh[x + 1]);
318 if (ret)
319 return ret;
320 }
321 mp->mp_aheight = x + 1;
322 return 0;
Bob Petersond552a2b2017-02-06 08:28:32 -0500323}
324
325/**
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000326 * lookup_metapath - Walk the metadata tree to a specific point
327 * @ip: The inode
David Teiglandb3b94fa2006-01-16 16:50:04 +0000328 * @mp: The metapath
David Teiglandb3b94fa2006-01-16 16:50:04 +0000329 *
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000330 * Assumes that the inode's buffer has already been looked up and
331 * hooked onto mp->mp_bh[0] and that the metapath has been initialised
332 * by find_metapath().
David Teiglandb3b94fa2006-01-16 16:50:04 +0000333 *
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000334 * If this function encounters part of the tree which has not been
335 * allocated, it returns the current height of the tree at the point
336 * at which it found the unallocated block. Blocks which are found are
337 * added to the mp->mp_bh[] list.
338 *
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100339 * Returns: error
David Teiglandb3b94fa2006-01-16 16:50:04 +0000340 */
341
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000342static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000343{
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100344 return __fillup_metapath(ip, mp, 0, ip->i_height - 1);
Steven Whitehousedbac6712008-01-29 09:12:55 +0000345}
346
Bob Petersond552a2b2017-02-06 08:28:32 -0500347/**
348 * fillup_metapath - fill up buffers for the metadata path to a specific height
349 * @ip: The inode
350 * @mp: The metapath
351 * @h: The height to which it should be mapped
352 *
353 * Similar to lookup_metapath, but does lookups for a range of heights
354 *
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100355 * Returns: error or the number of buffers filled
Bob Petersond552a2b2017-02-06 08:28:32 -0500356 */
357
358static int fillup_metapath(struct gfs2_inode *ip, struct metapath *mp, int h)
359{
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100360 unsigned int x = 0;
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100361 int ret;
Bob Petersond552a2b2017-02-06 08:28:32 -0500362
363 if (h) {
364 /* find the first buffer we need to look up. */
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100365 for (x = h - 1; x > 0; x--) {
366 if (mp->mp_bh[x])
367 break;
Bob Petersond552a2b2017-02-06 08:28:32 -0500368 }
369 }
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100370 ret = __fillup_metapath(ip, mp, x, h);
371 if (ret)
372 return ret;
373 return mp->mp_aheight - x - 1;
Bob Petersond552a2b2017-02-06 08:28:32 -0500374}
375
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000376static inline void release_metapath(struct metapath *mp)
Steven Whitehousedbac6712008-01-29 09:12:55 +0000377{
378 int i;
379
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000380 for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
381 if (mp->mp_bh[i] == NULL)
382 break;
383 brelse(mp->mp_bh[i]);
384 }
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000385}
386
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000387/**
388 * gfs2_extent_length - Returns length of an extent of blocks
389 * @start: Start of the buffer
390 * @len: Length of the buffer in bytes
391 * @ptr: Current position in the buffer
392 * @limit: Max extent length to return (0 = unlimited)
393 * @eob: Set to 1 if we hit "end of block"
394 *
395 * If the first block is zero (unallocated) it will return the number of
396 * unallocated blocks in the extent, otherwise it will return the number
397 * of contiguous blocks in the extent.
398 *
399 * Returns: The length of the extent (minimum of one block)
400 */
401
Bob Petersonb6507382014-08-06 09:08:36 -0400402static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __be64 *ptr, size_t limit, int *eob)
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000403{
404 const __be64 *end = (start + len);
405 const __be64 *first = ptr;
406 u64 d = be64_to_cpu(*ptr);
407
408 *eob = 0;
409 do {
410 ptr++;
411 if (ptr >= end)
412 break;
413 if (limit && --limit == 0)
414 break;
415 if (d)
416 d++;
417 } while(be64_to_cpu(*ptr) == d);
418 if (ptr >= end)
419 *eob = 1;
420 return (ptr - first);
421}
422
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000423static inline void bmap_lock(struct gfs2_inode *ip, int create)
Steven Whitehousefd88de562006-05-05 16:59:11 -0400424{
Steven Whitehousefd88de562006-05-05 16:59:11 -0400425 if (create)
426 down_write(&ip->i_rw_mutex);
427 else
428 down_read(&ip->i_rw_mutex);
429}
430
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000431static inline void bmap_unlock(struct gfs2_inode *ip, int create)
Steven Whitehousefd88de562006-05-05 16:59:11 -0400432{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000433 if (create)
434 up_write(&ip->i_rw_mutex);
435 else
436 up_read(&ip->i_rw_mutex);
Steven Whitehousefd88de562006-05-05 16:59:11 -0400437}
David Teiglandb3b94fa2006-01-16 16:50:04 +0000438
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000439static inline __be64 *gfs2_indirect_init(struct metapath *mp,
440 struct gfs2_glock *gl, unsigned int i,
441 unsigned offset, u64 bn)
442{
443 __be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
444 ((i > 1) ? sizeof(struct gfs2_meta_header) :
445 sizeof(struct gfs2_dinode)));
446 BUG_ON(i < 1);
447 BUG_ON(mp->mp_bh[i] != NULL);
448 mp->mp_bh[i] = gfs2_meta_new(gl, bn);
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000449 gfs2_trans_add_meta(gl, mp->mp_bh[i]);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000450 gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
451 gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
452 ptr += offset;
453 *ptr = cpu_to_be64(bn);
454 return ptr;
455}
456
457enum alloc_state {
458 ALLOC_DATA = 0,
459 ALLOC_GROW_DEPTH = 1,
460 ALLOC_GROW_HEIGHT = 2,
461 /* ALLOC_UNSTUFF = 3, TBD and rather complicated */
462};
463
464/**
465 * gfs2_bmap_alloc - Build a metadata tree of the requested height
466 * @inode: The GFS2 inode
467 * @lblock: The logical starting block of the extent
468 * @bh_map: This is used to return the mapping details
Bob Peterson5f8bd442016-10-28 14:29:29 -0500469 * @zero_new: True if newly allocated blocks should be zeroed
470 * @mp: The metapath, with proper height information calculated
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000471 * @maxlen: The max number of data blocks to alloc
Bob Peterson5f8bd442016-10-28 14:29:29 -0500472 * @dblock: Pointer to return the resulting new block
473 * @dblks: Pointer to return the number of blocks allocated
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000474 *
475 * In this routine we may have to alloc:
476 * i) Indirect blocks to grow the metadata tree height
477 * ii) Indirect blocks to fill in lower part of the metadata tree
478 * iii) Data blocks
479 *
480 * The function is in two parts. The first part works out the total
481 * number of blocks which we need. The second part does the actual
482 * allocation asking for an extent at a time (if enough contiguous free
483 * blocks are available, there will only be one request per bmap call)
484 * and uses the state machine to initialise the blocks in order.
485 *
486 * Returns: errno on error
487 */
488
Bob Peterson39743202017-02-16 10:27:16 -0500489static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,
490 unsigned flags, struct metapath *mp)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000491{
492 struct gfs2_inode *ip = GFS2_I(inode);
493 struct gfs2_sbd *sdp = GFS2_SB(inode);
Benjamin Marzinski64dd1532011-09-12 18:15:24 -0500494 struct super_block *sb = sdp->sd_vfs;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000495 struct buffer_head *dibh = mp->mp_bh[0];
Bob Peterson5f8bd442016-10-28 14:29:29 -0500496 u64 bn;
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500497 unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
Bob Peterson39743202017-02-16 10:27:16 -0500498 unsigned dblks = 0;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000499 unsigned ptrs_per_blk;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500500 const unsigned end_of_metadata = mp->mp_fheight - 1;
Benjamin Marzinski64dd1532011-09-12 18:15:24 -0500501 int ret;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000502 enum alloc_state state;
503 __be64 *ptr;
504 __be64 zero_bn = 0;
Bob Peterson39743202017-02-16 10:27:16 -0500505 size_t maxlen = iomap->length >> inode->i_blkbits;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000506
Bob Peterson5f8bd442016-10-28 14:29:29 -0500507 BUG_ON(mp->mp_aheight < 1);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000508 BUG_ON(dibh == NULL);
509
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000510 gfs2_trans_add_meta(ip->i_gl, dibh);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000511
Bob Peterson5f8bd442016-10-28 14:29:29 -0500512 if (mp->mp_fheight == mp->mp_aheight) {
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000513 struct buffer_head *bh;
Bob Peterson39743202017-02-16 10:27:16 -0500514 int eob;
515
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000516 /* Bottom indirect block exists, find unalloced extent size */
517 ptr = metapointer(end_of_metadata, mp);
518 bh = mp->mp_bh[end_of_metadata];
Bob Peterson39743202017-02-16 10:27:16 -0500519 dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr,
520 maxlen, &eob);
521 BUG_ON(dblks < 1);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000522 state = ALLOC_DATA;
523 } else {
524 /* Need to allocate indirect blocks */
Bob Peterson5f8bd442016-10-28 14:29:29 -0500525 ptrs_per_blk = mp->mp_fheight > 1 ? sdp->sd_inptrs :
526 sdp->sd_diptrs;
Bob Peterson39743202017-02-16 10:27:16 -0500527 dblks = min(maxlen, (size_t)(ptrs_per_blk -
528 mp->mp_list[end_of_metadata]));
Bob Peterson5f8bd442016-10-28 14:29:29 -0500529 if (mp->mp_fheight == ip->i_height) {
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000530 /* Writing into existing tree, extend tree down */
Bob Peterson5f8bd442016-10-28 14:29:29 -0500531 iblks = mp->mp_fheight - mp->mp_aheight;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000532 state = ALLOC_GROW_DEPTH;
533 } else {
534 /* Building up tree height */
535 state = ALLOC_GROW_HEIGHT;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500536 iblks = mp->mp_fheight - ip->i_height;
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500537 branch_start = metapath_branch_start(mp);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500538 iblks += (mp->mp_fheight - branch_start);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000539 }
540 }
541
542 /* start of the second part of the function (state machine) */
543
Bob Peterson39743202017-02-16 10:27:16 -0500544 blks = dblks + iblks;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500545 i = mp->mp_aheight;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000546 do {
Steven Whitehouse09010972009-05-20 10:48:47 +0100547 int error;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000548 n = blks - alloced;
Bob Peterson6e87ed02011-11-18 10:58:32 -0500549 error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
Steven Whitehouse09010972009-05-20 10:48:47 +0100550 if (error)
551 return error;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000552 alloced += n;
553 if (state != ALLOC_DATA || gfs2_is_jdata(ip))
554 gfs2_trans_add_unrevoke(sdp, bn, n);
555 switch (state) {
556 /* Growing height of tree */
557 case ALLOC_GROW_HEIGHT:
558 if (i == 1) {
559 ptr = (__be64 *)(dibh->b_data +
560 sizeof(struct gfs2_dinode));
561 zero_bn = *ptr;
562 }
Bob Peterson5f8bd442016-10-28 14:29:29 -0500563 for (; i - 1 < mp->mp_fheight - ip->i_height && n > 0;
564 i++, n--)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000565 gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500566 if (i - 1 == mp->mp_fheight - ip->i_height) {
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000567 i--;
568 gfs2_buffer_copy_tail(mp->mp_bh[i],
569 sizeof(struct gfs2_meta_header),
570 dibh, sizeof(struct gfs2_dinode));
571 gfs2_buffer_clear_tail(dibh,
572 sizeof(struct gfs2_dinode) +
573 sizeof(__be64));
574 ptr = (__be64 *)(mp->mp_bh[i]->b_data +
575 sizeof(struct gfs2_meta_header));
576 *ptr = zero_bn;
577 state = ALLOC_GROW_DEPTH;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500578 for(i = branch_start; i < mp->mp_fheight; i++) {
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000579 if (mp->mp_bh[i] == NULL)
580 break;
581 brelse(mp->mp_bh[i]);
582 mp->mp_bh[i] = NULL;
583 }
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500584 i = branch_start;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000585 }
586 if (n == 0)
587 break;
588 /* Branching from existing tree */
589 case ALLOC_GROW_DEPTH:
Bob Peterson5f8bd442016-10-28 14:29:29 -0500590 if (i > 1 && i < mp->mp_fheight)
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000591 gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[i-1]);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500592 for (; i < mp->mp_fheight && n > 0; i++, n--)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000593 gfs2_indirect_init(mp, ip->i_gl, i,
594 mp->mp_list[i-1], bn++);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500595 if (i == mp->mp_fheight)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000596 state = ALLOC_DATA;
597 if (n == 0)
598 break;
599 /* Tree complete, adding data blocks */
600 case ALLOC_DATA:
Bob Peterson39743202017-02-16 10:27:16 -0500601 BUG_ON(n > dblks);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000602 BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000603 gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[end_of_metadata]);
Bob Peterson39743202017-02-16 10:27:16 -0500604 dblks = n;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000605 ptr = metapointer(end_of_metadata, mp);
Bob Peterson39743202017-02-16 10:27:16 -0500606 iomap->addr = bn << inode->i_blkbits;
607 iomap->flags |= IOMAP_F_NEW;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000608 while (n-- > 0)
609 *ptr++ = cpu_to_be64(bn++);
Bob Peterson39743202017-02-16 10:27:16 -0500610 if (flags & IOMAP_ZERO) {
611 ret = sb_issue_zeroout(sb, iomap->addr >> inode->i_blkbits,
612 dblks, GFP_NOFS);
Benjamin Marzinski64dd1532011-09-12 18:15:24 -0500613 if (ret) {
614 fs_err(sdp,
615 "Failed to zero data buffers\n");
Bob Peterson39743202017-02-16 10:27:16 -0500616 flags &= ~IOMAP_ZERO;
Benjamin Marzinski64dd1532011-09-12 18:15:24 -0500617 }
618 }
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000619 break;
620 }
Bob Peterson39743202017-02-16 10:27:16 -0500621 } while (iomap->addr == IOMAP_NULL_ADDR);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000622
Bob Peterson39743202017-02-16 10:27:16 -0500623 iomap->length = (u64)dblks << inode->i_blkbits;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500624 ip->i_height = mp->mp_fheight;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000625 gfs2_add_inode_blocks(&ip->i_inode, alloced);
626 gfs2_dinode_out(ip, mp->mp_bh[0]->b_data);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000627 return 0;
628}
629
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500630/**
Bob Peterson39743202017-02-16 10:27:16 -0500631 * hole_size - figure out the size of a hole
632 * @inode: The inode
633 * @lblock: The logical starting block number
634 * @mp: The metapath
635 *
636 * Returns: The hole size in bytes
637 *
638 */
639static u64 hole_size(struct inode *inode, sector_t lblock, struct metapath *mp)
640{
641 struct gfs2_inode *ip = GFS2_I(inode);
642 struct gfs2_sbd *sdp = GFS2_SB(inode);
643 struct metapath mp_eof;
644 u64 factor = 1;
645 int hgt;
646 u64 holesz = 0;
647 const __be64 *first, *end, *ptr;
648 const struct buffer_head *bh;
649 u64 lblock_stop = (i_size_read(inode) - 1) >> inode->i_blkbits;
650 int zeroptrs;
651 bool done = false;
652
653 /* Get another metapath, to the very last byte */
654 find_metapath(sdp, lblock_stop, &mp_eof, ip->i_height);
655 for (hgt = ip->i_height - 1; hgt >= 0 && !done; hgt--) {
656 bh = mp->mp_bh[hgt];
657 if (bh) {
658 zeroptrs = 0;
659 first = metapointer(hgt, mp);
660 end = (const __be64 *)(bh->b_data + bh->b_size);
661
662 for (ptr = first; ptr < end; ptr++) {
663 if (*ptr) {
664 done = true;
665 break;
666 } else {
667 zeroptrs++;
668 }
669 }
670 } else {
671 zeroptrs = sdp->sd_inptrs;
672 }
673 if (factor * zeroptrs >= lblock_stop - lblock + 1) {
674 holesz = lblock_stop - lblock + 1;
675 break;
676 }
677 holesz += factor * zeroptrs;
678
679 factor *= sdp->sd_inptrs;
680 if (hgt && (mp->mp_list[hgt - 1] < mp_eof.mp_list[hgt - 1]))
681 (mp->mp_list[hgt - 1])++;
682 }
683 return holesz << inode->i_blkbits;
684}
685
686static void gfs2_stuffed_iomap(struct inode *inode, struct iomap *iomap)
687{
688 struct gfs2_inode *ip = GFS2_I(inode);
689
690 iomap->addr = (ip->i_no_addr << inode->i_blkbits) +
691 sizeof(struct gfs2_dinode);
692 iomap->offset = 0;
693 iomap->length = i_size_read(inode);
694 iomap->type = IOMAP_MAPPED;
695 iomap->flags = IOMAP_F_DATA_INLINE;
696}
697
698/**
699 * gfs2_iomap_begin - Map blocks from an inode to disk blocks
700 * @inode: The inode
701 * @pos: Starting position in bytes
702 * @length: Length to map, in bytes
703 * @flags: iomap flags
704 * @iomap: The iomap structure
705 *
706 * Returns: errno
707 */
708int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
709 unsigned flags, struct iomap *iomap)
710{
711 struct gfs2_inode *ip = GFS2_I(inode);
712 struct gfs2_sbd *sdp = GFS2_SB(inode);
713 struct metapath mp = { .mp_aheight = 1, };
714 unsigned int factor = sdp->sd_sb.sb_bsize;
715 const u64 *arr = sdp->sd_heightsize;
716 __be64 *ptr;
717 sector_t lblock;
718 sector_t lend;
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700719 int ret = 0;
Bob Peterson39743202017-02-16 10:27:16 -0500720 int eob;
721 unsigned int len;
722 struct buffer_head *bh;
723 u8 height;
724
725 trace_gfs2_iomap_start(ip, pos, length, flags);
726 if (!length) {
727 ret = -EINVAL;
728 goto out;
729 }
730
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700731 if (gfs2_is_stuffed(ip)) {
732 if (flags & IOMAP_REPORT) {
733 gfs2_stuffed_iomap(inode, iomap);
734 if (pos >= iomap->length)
735 ret = -ENOENT;
736 goto out;
737 }
738 BUG_ON(!(flags & IOMAP_WRITE));
Bob Peterson39743202017-02-16 10:27:16 -0500739 }
740
741 lblock = pos >> inode->i_blkbits;
742 lend = (pos + length + sdp->sd_sb.sb_bsize - 1) >> inode->i_blkbits;
743
744 iomap->offset = lblock << inode->i_blkbits;
745 iomap->addr = IOMAP_NULL_ADDR;
746 iomap->type = IOMAP_HOLE;
747 iomap->length = (u64)(lend - lblock) << inode->i_blkbits;
748 iomap->flags = IOMAP_F_MERGED;
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700749 bmap_lock(ip, flags & IOMAP_WRITE);
Bob Peterson39743202017-02-16 10:27:16 -0500750
751 /*
752 * Directory data blocks have a struct gfs2_meta_header header, so the
753 * remaining size is smaller than the filesystem block size. Logical
754 * block numbers for directories are in units of this remaining size!
755 */
756 if (gfs2_is_dir(ip)) {
757 factor = sdp->sd_jbsize;
758 arr = sdp->sd_jheightsize;
759 }
760
761 ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);
762 if (ret)
763 goto out_release;
764
765 height = ip->i_height;
766 while ((lblock + 1) * factor > arr[height])
767 height++;
768 find_metapath(sdp, lblock, &mp, height);
769 if (height > ip->i_height || gfs2_is_stuffed(ip))
770 goto do_alloc;
771
772 ret = lookup_metapath(ip, &mp);
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100773 if (ret)
Bob Peterson39743202017-02-16 10:27:16 -0500774 goto out_release;
775
776 if (mp.mp_aheight != ip->i_height)
777 goto do_alloc;
778
779 ptr = metapointer(ip->i_height - 1, &mp);
780 if (*ptr == 0)
781 goto do_alloc;
782
783 iomap->type = IOMAP_MAPPED;
784 iomap->addr = be64_to_cpu(*ptr) << inode->i_blkbits;
785
786 bh = mp.mp_bh[ip->i_height - 1];
787 len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, lend - lblock, &eob);
788 if (eob)
789 iomap->flags |= IOMAP_F_BOUNDARY;
790 iomap->length = (u64)len << inode->i_blkbits;
791
Bob Peterson39743202017-02-16 10:27:16 -0500792out_release:
793 release_metapath(&mp);
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700794 bmap_unlock(ip, flags & IOMAP_WRITE);
Bob Peterson39743202017-02-16 10:27:16 -0500795out:
796 trace_gfs2_iomap_end(ip, iomap, ret);
797 return ret;
798
799do_alloc:
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700800 if (flags & IOMAP_WRITE) {
801 ret = gfs2_iomap_alloc(inode, iomap, flags, &mp);
802 } else if (flags & IOMAP_REPORT) {
803 loff_t size = i_size_read(inode);
804 if (pos >= size)
Bob Peterson39743202017-02-16 10:27:16 -0500805 ret = -ENOENT;
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700806 else if (height <= ip->i_height)
807 iomap->length = hole_size(inode, lblock, &mp);
808 else
809 iomap->length = size - pos;
Bob Peterson39743202017-02-16 10:27:16 -0500810 }
Bob Peterson39743202017-02-16 10:27:16 -0500811 goto out_release;
812}
813
814/**
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500815 * gfs2_block_map - Map a block from an inode to a disk block
816 * @inode: The inode
817 * @lblock: The logical block number
818 * @bh_map: The bh to be mapped
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000819 * @create: True if its ok to alloc blocks to satify the request
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500820 *
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000821 * Sets buffer_mapped() if successful, sets buffer_boundary() if a
822 * read of metadata will be required before the next block can be
823 * mapped. Sets buffer_new() if new blocks were allocated.
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500824 *
825 * Returns: errno
826 */
827
Bob Petersone9e1ef22007-12-10 14:13:27 -0600828int gfs2_block_map(struct inode *inode, sector_t lblock,
829 struct buffer_head *bh_map, int create)
Steven Whitehousefd88de562006-05-05 16:59:11 -0400830{
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500831 struct gfs2_inode *ip = GFS2_I(inode);
Bob Peterson39743202017-02-16 10:27:16 -0500832 struct iomap iomap;
833 int ret, flags = 0;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000834
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -0500835 clear_buffer_mapped(bh_map);
836 clear_buffer_new(bh_map);
837 clear_buffer_boundary(bh_map);
Steven Whitehouse63997772009-06-12 08:49:20 +0100838 trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
Andreas Gruenbacher20cdc192017-09-22 07:39:54 -0500839
Bob Peterson39743202017-02-16 10:27:16 -0500840 if (create)
841 flags |= IOMAP_WRITE;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500842 if (buffer_zeronew(bh_map))
Bob Peterson39743202017-02-16 10:27:16 -0500843 flags |= IOMAP_ZERO;
844 ret = gfs2_iomap_begin(inode, (loff_t)lblock << inode->i_blkbits,
845 bh_map->b_size, flags, &iomap);
846 if (ret) {
847 if (!create && ret == -ENOENT) {
848 /* Return unmapped buffer beyond the end of file. */
849 ret = 0;
850 }
851 goto out;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500852 }
Bob Peterson39743202017-02-16 10:27:16 -0500853
854 if (iomap.length > bh_map->b_size) {
855 iomap.length = bh_map->b_size;
856 iomap.flags &= ~IOMAP_F_BOUNDARY;
857 }
858 if (iomap.addr != IOMAP_NULL_ADDR)
859 map_bh(bh_map, inode->i_sb, iomap.addr >> inode->i_blkbits);
860 bh_map->b_size = iomap.length;
861 if (iomap.flags & IOMAP_F_BOUNDARY)
862 set_buffer_boundary(bh_map);
863 if (iomap.flags & IOMAP_F_NEW)
864 set_buffer_new(bh_map);
865
866out:
867 trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
868 return ret;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400869}
870
Steven Whitehouse941e6d72008-01-28 08:47:38 +0000871/*
872 * Deprecated: do not use in new code
873 */
Steven Whitehousefd88de562006-05-05 16:59:11 -0400874int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
875{
Steven Whitehouse23591252006-10-13 17:25:45 -0400876 struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400877 int ret;
Steven Whitehousefd88de562006-05-05 16:59:11 -0400878 int create = *new;
879
880 BUG_ON(!extlen);
881 BUG_ON(!dblock);
882 BUG_ON(!new);
883
Fabian Frederick47a9a522016-08-02 12:05:27 -0500884 bh.b_size = BIT(inode->i_blkbits + (create ? 0 : 5));
Bob Petersone9e1ef22007-12-10 14:13:27 -0600885 ret = gfs2_block_map(inode, lblock, &bh, create);
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -0400886 *extlen = bh.b_size >> inode->i_blkbits;
887 *dblock = bh.b_blocknr;
888 if (buffer_new(&bh))
889 *new = 1;
890 else
891 *new = 0;
892 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000893}
894
895/**
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +0100896 * gfs2_block_zero_range - Deal with zeroing out data
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400897 *
898 * This is partly borrowed from ext3.
899 */
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +0100900static int gfs2_block_zero_range(struct inode *inode, loff_t from,
901 unsigned int length)
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400902{
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +0100903 struct address_space *mapping = inode->i_mapping;
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400904 struct gfs2_inode *ip = GFS2_I(inode);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300905 unsigned long index = from >> PAGE_SHIFT;
906 unsigned offset = from & (PAGE_SIZE-1);
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +0100907 unsigned blocksize, iblock, pos;
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400908 struct buffer_head *bh;
909 struct page *page;
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400910 int err;
911
Bob Peterson220cca22012-03-19 15:25:50 -0400912 page = find_or_create_page(mapping, index, GFP_NOFS);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400913 if (!page)
914 return 0;
915
916 blocksize = inode->i_sb->s_blocksize;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300917 iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400918
919 if (!page_has_buffers(page))
920 create_empty_buffers(page, blocksize, 0);
921
922 /* Find the buffer that contains "offset" */
923 bh = page_buffers(page);
924 pos = blocksize;
925 while (offset >= pos) {
926 bh = bh->b_this_page;
927 iblock++;
928 pos += blocksize;
929 }
930
931 err = 0;
932
933 if (!buffer_mapped(bh)) {
Bob Petersone9e1ef22007-12-10 14:13:27 -0600934 gfs2_block_map(inode, iblock, bh, 0);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400935 /* unmapped? It's a hole - nothing to do */
936 if (!buffer_mapped(bh))
937 goto unlock;
938 }
939
940 /* Ok, it's mapped. Make sure it's up-to-date */
941 if (PageUptodate(page))
942 set_buffer_uptodate(bh);
943
944 if (!buffer_uptodate(bh)) {
945 err = -EIO;
Mike Christiedfec8a12016-06-05 14:31:44 -0500946 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400947 wait_on_buffer(bh);
948 /* Uhhuh. Read error. Complain and punt. */
949 if (!buffer_uptodate(bh))
950 goto unlock;
S. Wendy Cheng1875f2f2007-06-25 21:14:31 -0400951 err = 0;
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400952 }
953
Steven Whitehousebf36a712007-10-17 08:35:19 +0100954 if (!gfs2_is_writeback(ip))
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000955 gfs2_trans_add_data(ip->i_gl, bh);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400956
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800957 zero_user(page, offset, length);
Steven Whitehouse40bc9a22009-06-10 09:09:40 +0100958 mark_buffer_dirty(bh);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400959unlock:
960 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300961 put_page(page);
Steven Whitehouseba7f7292006-07-26 11:27:10 -0400962 return err;
963}
964
Fabian Frederickc62baf62014-05-14 18:32:31 +0200965#define GFS2_JTRUNC_REVOKES 8192
966
Steven Whitehousefa731fc2012-11-13 09:50:28 +0000967/**
968 * gfs2_journaled_truncate - Wrapper for truncate_pagecache for jdata files
969 * @inode: The inode being truncated
970 * @oldsize: The original (larger) size
971 * @newsize: The new smaller size
972 *
973 * With jdata files, we have to journal a revoke for each block which is
974 * truncated. As a result, we need to split this into separate transactions
975 * if the number of pages being truncated gets too large.
976 */
977
Steven Whitehousefa731fc2012-11-13 09:50:28 +0000978static int gfs2_journaled_truncate(struct inode *inode, u64 oldsize, u64 newsize)
979{
980 struct gfs2_sbd *sdp = GFS2_SB(inode);
981 u64 max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
982 u64 chunk;
983 int error;
984
985 while (oldsize != newsize) {
Andreas Gruenbachere7fdf002017-12-12 16:47:20 +0100986 struct gfs2_trans *tr;
987 unsigned int offs;
988
Steven Whitehousefa731fc2012-11-13 09:50:28 +0000989 chunk = oldsize - newsize;
990 if (chunk > max_chunk)
991 chunk = max_chunk;
Andreas Gruenbachere7fdf002017-12-12 16:47:20 +0100992
993 offs = oldsize & ~PAGE_MASK;
994 if (offs && chunk > PAGE_SIZE)
995 chunk = offs + ((chunk - offs) & PAGE_MASK);
996
Kirill A. Shutemov7caef262013-09-12 15:13:56 -0700997 truncate_pagecache(inode, oldsize - chunk);
Steven Whitehousefa731fc2012-11-13 09:50:28 +0000998 oldsize -= chunk;
Andreas Gruenbachere7fdf002017-12-12 16:47:20 +0100999
1000 tr = current->journal_info;
1001 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
1002 continue;
1003
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001004 gfs2_trans_end(sdp);
1005 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
1006 if (error)
1007 return error;
1008 }
1009
1010 return 0;
1011}
1012
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001013static int trunc_start(struct inode *inode, u64 newsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001014{
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001015 struct gfs2_inode *ip = GFS2_I(inode);
1016 struct gfs2_sbd *sdp = GFS2_SB(inode);
Andreas Gruenbacher80990f402017-12-12 16:42:01 +01001017 struct buffer_head *dibh = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001018 int journaled = gfs2_is_jdata(ip);
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001019 u64 oldsize = inode->i_size;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001020 int error;
1021
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001022 if (journaled)
1023 error = gfs2_trans_begin(sdp, RES_DINODE + RES_JDATA, GFS2_JTRUNC_REVOKES);
1024 else
1025 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001026 if (error)
1027 return error;
1028
1029 error = gfs2_meta_inode_buffer(ip, &dibh);
1030 if (error)
1031 goto out;
1032
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001033 gfs2_trans_add_meta(ip->i_gl, dibh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001034
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001035 if (gfs2_is_stuffed(ip)) {
1036 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1037 } else {
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +01001038 unsigned int blocksize = i_blocksize(inode);
1039 unsigned int offs = newsize & (blocksize - 1);
1040 if (offs) {
1041 error = gfs2_block_zero_range(inode, newsize,
1042 blocksize - offs);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001043 if (error)
Andreas Gruenbacher80990f402017-12-12 16:42:01 +01001044 goto out;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001045 }
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001046 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001047 }
1048
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001049 i_size_write(inode, newsize);
Deepa Dinamani078cd822016-09-14 07:48:04 -07001050 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001051 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001052
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001053 if (journaled)
1054 error = gfs2_journaled_truncate(inode, oldsize, newsize);
1055 else
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07001056 truncate_pagecache(inode, newsize);
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001057
Steven Whitehousea91ea692006-09-04 12:04:26 -04001058out:
Andreas Gruenbacher80990f402017-12-12 16:42:01 +01001059 brelse(dibh);
1060 if (current->journal_info)
1061 gfs2_trans_end(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001062 return error;
1063}
1064
Bob Petersond552a2b2017-02-06 08:28:32 -05001065/**
1066 * sweep_bh_for_rgrps - find an rgrp in a meta buffer and free blocks therein
1067 * @ip: inode
1068 * @rg_gh: holder of resource group glock
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001069 * @bh: buffer head to sweep
1070 * @start: starting point in bh
1071 * @end: end point in bh
1072 * @meta: true if bh points to metadata (rather than data)
Bob Petersond552a2b2017-02-06 08:28:32 -05001073 * @btotal: place to keep count of total blocks freed
Bob Petersond552a2b2017-02-06 08:28:32 -05001074 *
1075 * We sweep a metadata buffer (provided by the metapath) for blocks we need to
1076 * free, and free them all. However, we do it one rgrp at a time. If this
1077 * block has references to multiple rgrps, we break it into individual
1078 * transactions. This allows other processes to use the rgrps while we're
1079 * focused on a single one, for better concurrency / performance.
1080 * At every transaction boundary, we rewrite the inode into the journal.
1081 * That way the bitmaps are kept consistent with the inode and we can recover
1082 * if we're interrupted by power-outages.
1083 *
1084 * Returns: 0, or return code if an error occurred.
1085 * *btotal has the total number of blocks freed
1086 */
1087static int sweep_bh_for_rgrps(struct gfs2_inode *ip, struct gfs2_holder *rd_gh,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001088 struct buffer_head *bh, __be64 *start, __be64 *end,
1089 bool meta, u32 *btotal)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001090{
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +00001091 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Bob Petersond552a2b2017-02-06 08:28:32 -05001092 struct gfs2_rgrpd *rgd;
1093 struct gfs2_trans *tr;
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001094 __be64 *p;
Bob Petersond552a2b2017-02-06 08:28:32 -05001095 int blks_outside_rgrp;
1096 u64 bn, bstart, isize_blks;
1097 s64 blen; /* needs to be s64 or gfs2_add_inode_blocks breaks */
Bob Petersond552a2b2017-02-06 08:28:32 -05001098 int ret = 0;
1099 bool buf_in_tr = false; /* buffer was added to transaction */
David Teiglandb3b94fa2006-01-16 16:50:04 +00001100
Bob Petersond552a2b2017-02-06 08:28:32 -05001101more_rgrps:
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001102 rgd = NULL;
1103 if (gfs2_holder_initialized(rd_gh)) {
1104 rgd = gfs2_glock2rgrp(rd_gh->gh_gl);
1105 gfs2_assert_withdraw(sdp,
1106 gfs2_glock_is_locked_by_me(rd_gh->gh_gl));
1107 }
Bob Petersond552a2b2017-02-06 08:28:32 -05001108 blks_outside_rgrp = 0;
1109 bstart = 0;
1110 blen = 0;
Bob Petersond552a2b2017-02-06 08:28:32 -05001111
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001112 for (p = start; p < end; p++) {
Bob Petersond552a2b2017-02-06 08:28:32 -05001113 if (!*p)
1114 continue;
1115 bn = be64_to_cpu(*p);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001116
1117 if (rgd) {
1118 if (!rgrp_contains_block(rgd, bn)) {
1119 blks_outside_rgrp++;
1120 continue;
1121 }
Bob Petersond552a2b2017-02-06 08:28:32 -05001122 } else {
Steven Whitehouse90bcab92017-12-22 13:13:07 +01001123 rgd = gfs2_blk2rgrpd(sdp, bn, true);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001124 if (unlikely(!rgd)) {
1125 ret = -EIO;
1126 goto out;
1127 }
Bob Petersond552a2b2017-02-06 08:28:32 -05001128 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1129 0, rd_gh);
1130 if (ret)
1131 goto out;
1132
1133 /* Must be done with the rgrp glock held: */
1134 if (gfs2_rs_active(&ip->i_res) &&
1135 rgd == ip->i_res.rs_rbm.rgd)
1136 gfs2_rs_deltree(&ip->i_res);
1137 }
1138
Bob Petersond552a2b2017-02-06 08:28:32 -05001139 /* The size of our transactions will be unknown until we
1140 actually process all the metadata blocks that relate to
1141 the rgrp. So we estimate. We know it can't be more than
1142 the dinode's i_blocks and we don't want to exceed the
1143 journal flush threshold, sd_log_thresh2. */
1144 if (current->journal_info == NULL) {
1145 unsigned int jblocks_rqsted, revokes;
1146
1147 jblocks_rqsted = rgd->rd_length + RES_DINODE +
1148 RES_INDIRECT;
1149 isize_blks = gfs2_get_inode_blocks(&ip->i_inode);
1150 if (isize_blks > atomic_read(&sdp->sd_log_thresh2))
1151 jblocks_rqsted +=
1152 atomic_read(&sdp->sd_log_thresh2);
1153 else
1154 jblocks_rqsted += isize_blks;
1155 revokes = jblocks_rqsted;
1156 if (meta)
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001157 revokes += end - start;
Bob Petersond552a2b2017-02-06 08:28:32 -05001158 else if (ip->i_depth)
1159 revokes += sdp->sd_inptrs;
1160 ret = gfs2_trans_begin(sdp, jblocks_rqsted, revokes);
1161 if (ret)
1162 goto out_unlock;
1163 down_write(&ip->i_rw_mutex);
1164 }
1165 /* check if we will exceed the transaction blocks requested */
1166 tr = current->journal_info;
1167 if (tr->tr_num_buf_new + RES_STATFS +
1168 RES_QUOTA >= atomic_read(&sdp->sd_log_thresh2)) {
1169 /* We set blks_outside_rgrp to ensure the loop will
1170 be repeated for the same rgrp, but with a new
1171 transaction. */
1172 blks_outside_rgrp++;
1173 /* This next part is tricky. If the buffer was added
1174 to the transaction, we've already set some block
1175 pointers to 0, so we better follow through and free
1176 them, or we will introduce corruption (so break).
1177 This may be impossible, or at least rare, but I
1178 decided to cover the case regardless.
1179
1180 If the buffer was not added to the transaction
1181 (this call), doing so would exceed our transaction
1182 size, so we need to end the transaction and start a
1183 new one (so goto). */
1184
1185 if (buf_in_tr)
1186 break;
1187 goto out_unlock;
1188 }
1189
1190 gfs2_trans_add_meta(ip->i_gl, bh);
1191 buf_in_tr = true;
1192 *p = 0;
1193 if (bstart + blen == bn) {
1194 blen++;
1195 continue;
1196 }
1197 if (bstart) {
1198 __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1199 (*btotal) += blen;
1200 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1201 }
1202 bstart = bn;
1203 blen = 1;
1204 }
1205 if (bstart) {
1206 __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1207 (*btotal) += blen;
1208 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1209 }
1210out_unlock:
1211 if (!ret && blks_outside_rgrp) { /* If buffer still has non-zero blocks
1212 outside the rgrp we just processed,
1213 do it all over again. */
1214 if (current->journal_info) {
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001215 struct buffer_head *dibh;
1216
1217 ret = gfs2_meta_inode_buffer(ip, &dibh);
1218 if (ret)
1219 goto out;
Bob Petersond552a2b2017-02-06 08:28:32 -05001220
1221 /* Every transaction boundary, we rewrite the dinode
1222 to keep its di_blocks current in case of failure. */
1223 ip->i_inode.i_mtime = ip->i_inode.i_ctime =
Stephen Rothwellb32c8c72017-05-08 15:59:34 -07001224 current_time(&ip->i_inode);
Bob Petersond552a2b2017-02-06 08:28:32 -05001225 gfs2_trans_add_meta(ip->i_gl, dibh);
1226 gfs2_dinode_out(ip, dibh->b_data);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001227 brelse(dibh);
Bob Petersond552a2b2017-02-06 08:28:32 -05001228 up_write(&ip->i_rw_mutex);
1229 gfs2_trans_end(sdp);
1230 }
1231 gfs2_glock_dq_uninit(rd_gh);
1232 cond_resched();
1233 goto more_rgrps;
1234 }
1235out:
1236 return ret;
1237}
1238
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001239static bool mp_eq_to_hgt(struct metapath *mp, __u16 *list, unsigned int h)
1240{
1241 if (memcmp(mp->mp_list, list, h * sizeof(mp->mp_list[0])))
1242 return false;
1243 return true;
1244}
1245
Bob Petersond552a2b2017-02-06 08:28:32 -05001246/**
1247 * find_nonnull_ptr - find a non-null pointer given a metapath and height
Bob Petersond552a2b2017-02-06 08:28:32 -05001248 * @mp: starting metapath
1249 * @h: desired height to search
1250 *
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001251 * Assumes the metapath is valid (with buffers) out to height h.
Bob Petersond552a2b2017-02-06 08:28:32 -05001252 * Returns: true if a non-null pointer was found in the metapath buffer
1253 * false if all remaining pointers are NULL in the buffer
1254 */
1255static bool find_nonnull_ptr(struct gfs2_sbd *sdp, struct metapath *mp,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001256 unsigned int h,
1257 __u16 *end_list, unsigned int end_aligned)
Bob Petersond552a2b2017-02-06 08:28:32 -05001258{
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001259 struct buffer_head *bh = mp->mp_bh[h];
1260 __be64 *first, *ptr, *end;
Bob Petersond552a2b2017-02-06 08:28:32 -05001261
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001262 first = metaptr1(h, mp);
1263 ptr = first + mp->mp_list[h];
1264 end = (__be64 *)(bh->b_data + bh->b_size);
1265 if (end_list && mp_eq_to_hgt(mp, end_list, h)) {
1266 bool keep_end = h < end_aligned;
1267 end = first + end_list[h] + keep_end;
1268 }
1269
1270 while (ptr < end) {
Bob Petersonc4a9d182017-08-30 09:26:09 -05001271 if (*ptr) { /* if we have a non-null pointer */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001272 mp->mp_list[h] = ptr - first;
Bob Petersonc4a9d182017-08-30 09:26:09 -05001273 h++;
1274 if (h < GFS2_MAX_META_HEIGHT)
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001275 mp->mp_list[h] = 0;
Bob Petersond552a2b2017-02-06 08:28:32 -05001276 return true;
Bob Petersonc4a9d182017-08-30 09:26:09 -05001277 }
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001278 ptr++;
Bob Petersond552a2b2017-02-06 08:28:32 -05001279 }
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001280 return false;
Bob Petersond552a2b2017-02-06 08:28:32 -05001281}
1282
1283enum dealloc_states {
1284 DEALLOC_MP_FULL = 0, /* Strip a metapath with all buffers read in */
1285 DEALLOC_MP_LOWER = 1, /* lower the metapath strip height */
1286 DEALLOC_FILL_MP = 2, /* Fill in the metapath to the given height. */
1287 DEALLOC_DONE = 3, /* process complete */
1288};
1289
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001290static inline void
1291metapointer_range(struct metapath *mp, int height,
1292 __u16 *start_list, unsigned int start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001293 __u16 *end_list, unsigned int end_aligned,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001294 __be64 **start, __be64 **end)
1295{
1296 struct buffer_head *bh = mp->mp_bh[height];
1297 __be64 *first;
1298
1299 first = metaptr1(height, mp);
1300 *start = first;
1301 if (mp_eq_to_hgt(mp, start_list, height)) {
1302 bool keep_start = height < start_aligned;
1303 *start = first + start_list[height] + keep_start;
1304 }
1305 *end = (__be64 *)(bh->b_data + bh->b_size);
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001306 if (end_list && mp_eq_to_hgt(mp, end_list, height)) {
1307 bool keep_end = height < end_aligned;
1308 *end = first + end_list[height] + keep_end;
1309 }
1310}
1311
1312static inline bool walk_done(struct gfs2_sbd *sdp,
1313 struct metapath *mp, int height,
1314 __u16 *end_list, unsigned int end_aligned)
1315{
1316 __u16 end;
1317
1318 if (end_list) {
1319 bool keep_end = height < end_aligned;
1320 if (!mp_eq_to_hgt(mp, end_list, height))
1321 return false;
1322 end = end_list[height] + keep_end;
1323 } else
1324 end = (height > 0) ? sdp->sd_inptrs : sdp->sd_diptrs;
1325 return mp->mp_list[height] >= end;
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001326}
1327
Bob Petersond552a2b2017-02-06 08:28:32 -05001328/**
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001329 * punch_hole - deallocate blocks in a file
Bob Petersond552a2b2017-02-06 08:28:32 -05001330 * @ip: inode to truncate
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001331 * @offset: the start of the hole
1332 * @length: the size of the hole (or 0 for truncate)
Bob Petersond552a2b2017-02-06 08:28:32 -05001333 *
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001334 * Punch a hole into a file or truncate a file at a given position. This
1335 * function operates in whole blocks (@offset and @length are rounded
1336 * accordingly); partially filled blocks must be cleared otherwise.
1337 *
1338 * This function works from the bottom up, and from the right to the left. In
1339 * other words, it strips off the highest layer (data) before stripping any of
1340 * the metadata. Doing it this way is best in case the operation is interrupted
1341 * by power failure, etc. The dinode is rewritten in every transaction to
1342 * guarantee integrity.
Bob Petersond552a2b2017-02-06 08:28:32 -05001343 */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001344static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length)
Bob Petersond552a2b2017-02-06 08:28:32 -05001345{
1346 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001347 struct metapath mp = {};
Bob Petersond552a2b2017-02-06 08:28:32 -05001348 struct buffer_head *dibh, *bh;
1349 struct gfs2_holder rd_gh;
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001350 unsigned int bsize_shift = sdp->sd_sb.sb_bsize_shift;
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001351 u64 lblock = (offset + (1 << bsize_shift) - 1) >> bsize_shift;
1352 __u16 start_list[GFS2_MAX_META_HEIGHT];
1353 __u16 __end_list[GFS2_MAX_META_HEIGHT], *end_list = NULL;
Andreas Gruenbacher4e56a642017-12-14 17:11:03 +01001354 unsigned int start_aligned, uninitialized_var(end_aligned);
Bob Petersond552a2b2017-02-06 08:28:32 -05001355 unsigned int strip_h = ip->i_height - 1;
1356 u32 btotal = 0;
1357 int ret, state;
1358 int mp_h; /* metapath buffers are read in to this height */
Bob Petersond552a2b2017-02-06 08:28:32 -05001359 u64 prev_bnr = 0;
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001360 __be64 *start, *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001361
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001362 /*
1363 * The start position of the hole is defined by lblock, start_list, and
1364 * start_aligned. The end position of the hole is defined by lend,
1365 * end_list, and end_aligned.
1366 *
1367 * start_aligned and end_aligned define down to which height the start
1368 * and end positions are aligned to the metadata tree (i.e., the
1369 * position is a multiple of the metadata granularity at the height
1370 * above). This determines at which heights additional meta pointers
1371 * needs to be preserved for the remaining data.
1372 */
David Teiglandb3b94fa2006-01-16 16:50:04 +00001373
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001374 if (length) {
1375 u64 maxsize = sdp->sd_heightsize[ip->i_height];
1376 u64 end_offset = offset + length;
1377 u64 lend;
1378
1379 /*
1380 * Clip the end at the maximum file size for the given height:
1381 * that's how far the metadata goes; files bigger than that
1382 * will have additional layers of indirection.
1383 */
1384 if (end_offset > maxsize)
1385 end_offset = maxsize;
1386 lend = end_offset >> bsize_shift;
1387
1388 if (lblock >= lend)
1389 return 0;
1390
1391 find_metapath(sdp, lend, &mp, ip->i_height);
1392 end_list = __end_list;
1393 memcpy(end_list, mp.mp_list, sizeof(mp.mp_list));
1394
1395 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1396 if (end_list[mp_h])
1397 break;
1398 }
1399 end_aligned = mp_h;
1400 }
1401
1402 find_metapath(sdp, lblock, &mp, ip->i_height);
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001403 memcpy(start_list, mp.mp_list, sizeof(start_list));
1404
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001405 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1406 if (start_list[mp_h])
1407 break;
1408 }
1409 start_aligned = mp_h;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001410
Bob Petersond552a2b2017-02-06 08:28:32 -05001411 ret = gfs2_meta_inode_buffer(ip, &dibh);
1412 if (ret)
1413 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001414
Bob Petersond552a2b2017-02-06 08:28:32 -05001415 mp.mp_bh[0] = dibh;
1416 ret = lookup_metapath(ip, &mp);
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001417 if (ret)
1418 goto out_metapath;
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001419
1420 /* issue read-ahead on metadata */
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001421 for (mp_h = 0; mp_h < mp.mp_aheight - 1; mp_h++) {
1422 metapointer_range(&mp, mp_h, start_list, start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001423 end_list, end_aligned, &start, &end);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001424 gfs2_metapath_ra(ip->i_gl, start, end);
1425 }
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001426
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001427 if (mp.mp_aheight == ip->i_height)
Bob Petersond552a2b2017-02-06 08:28:32 -05001428 state = DEALLOC_MP_FULL; /* We have a complete metapath */
1429 else
1430 state = DEALLOC_FILL_MP; /* deal with partial metapath */
1431
1432 ret = gfs2_rindex_update(sdp);
1433 if (ret)
1434 goto out_metapath;
1435
1436 ret = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1437 if (ret)
1438 goto out_metapath;
1439 gfs2_holder_mark_uninitialized(&rd_gh);
1440
1441 mp_h = strip_h;
1442
1443 while (state != DEALLOC_DONE) {
1444 switch (state) {
1445 /* Truncate a full metapath at the given strip height.
1446 * Note that strip_h == mp_h in order to be in this state. */
1447 case DEALLOC_MP_FULL:
Bob Petersond552a2b2017-02-06 08:28:32 -05001448 bh = mp.mp_bh[mp_h];
1449 gfs2_assert_withdraw(sdp, bh);
1450 if (gfs2_assert_withdraw(sdp,
1451 prev_bnr != bh->b_blocknr)) {
1452 printk(KERN_EMERG "GFS2: fsid=%s:inode %llu, "
1453 "block:%llu, i_h:%u, s_h:%u, mp_h:%u\n",
1454 sdp->sd_fsname,
1455 (unsigned long long)ip->i_no_addr,
1456 prev_bnr, ip->i_height, strip_h, mp_h);
1457 }
1458 prev_bnr = bh->b_blocknr;
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001459
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001460 if (gfs2_metatype_check(sdp, bh,
1461 (mp_h ? GFS2_METATYPE_IN :
1462 GFS2_METATYPE_DI))) {
1463 ret = -EIO;
1464 goto out;
1465 }
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001466
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001467 /*
1468 * Below, passing end_aligned as 0 gives us the
1469 * metapointer range excluding the end point: the end
1470 * point is the first metapath we must not deallocate!
1471 */
1472
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001473 metapointer_range(&mp, mp_h, start_list, start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001474 end_list, 0 /* end_aligned */,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001475 &start, &end);
1476 ret = sweep_bh_for_rgrps(ip, &rd_gh, mp.mp_bh[mp_h],
1477 start, end,
1478 mp_h != ip->i_height - 1,
1479 &btotal);
1480
Bob Petersond552a2b2017-02-06 08:28:32 -05001481 /* If we hit an error or just swept dinode buffer,
1482 just exit. */
1483 if (ret || !mp_h) {
1484 state = DEALLOC_DONE;
1485 break;
1486 }
1487 state = DEALLOC_MP_LOWER;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001488 break;
Bob Petersond552a2b2017-02-06 08:28:32 -05001489
1490 /* lower the metapath strip height */
1491 case DEALLOC_MP_LOWER:
1492 /* We're done with the current buffer, so release it,
1493 unless it's the dinode buffer. Then back up to the
1494 previous pointer. */
1495 if (mp_h) {
1496 brelse(mp.mp_bh[mp_h]);
1497 mp.mp_bh[mp_h] = NULL;
1498 }
1499 /* If we can't get any lower in height, we've stripped
1500 off all we can. Next step is to back up and start
1501 stripping the previous level of metadata. */
1502 if (mp_h == 0) {
1503 strip_h--;
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001504 memcpy(mp.mp_list, start_list, sizeof(start_list));
Bob Petersond552a2b2017-02-06 08:28:32 -05001505 mp_h = strip_h;
1506 state = DEALLOC_FILL_MP;
1507 break;
1508 }
1509 mp.mp_list[mp_h] = 0;
1510 mp_h--; /* search one metadata height down */
Bob Petersond552a2b2017-02-06 08:28:32 -05001511 mp.mp_list[mp_h]++;
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001512 if (walk_done(sdp, &mp, mp_h, end_list, end_aligned))
1513 break;
Bob Petersond552a2b2017-02-06 08:28:32 -05001514 /* Here we've found a part of the metapath that is not
1515 * allocated. We need to search at that height for the
1516 * next non-null pointer. */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001517 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned)) {
Bob Petersond552a2b2017-02-06 08:28:32 -05001518 state = DEALLOC_FILL_MP;
1519 mp_h++;
1520 }
1521 /* No more non-null pointers at this height. Back up
1522 to the previous height and try again. */
1523 break; /* loop around in the same state */
1524
1525 /* Fill the metapath with buffers to the given height. */
1526 case DEALLOC_FILL_MP:
1527 /* Fill the buffers out to the current height. */
1528 ret = fillup_metapath(ip, &mp, mp_h);
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001529 if (ret < 0)
Bob Petersond552a2b2017-02-06 08:28:32 -05001530 goto out;
1531
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001532 /* issue read-ahead on metadata */
1533 if (mp.mp_aheight > 1) {
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001534 for (; ret > 1; ret--) {
1535 metapointer_range(&mp, mp.mp_aheight - ret,
1536 start_list, start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001537 end_list, end_aligned,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001538 &start, &end);
1539 gfs2_metapath_ra(ip->i_gl, start, end);
1540 }
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001541 }
1542
Bob Petersond552a2b2017-02-06 08:28:32 -05001543 /* If buffers found for the entire strip height */
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001544 if (mp.mp_aheight - 1 == strip_h) {
Bob Petersond552a2b2017-02-06 08:28:32 -05001545 state = DEALLOC_MP_FULL;
1546 break;
1547 }
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001548 if (mp.mp_aheight < ip->i_height) /* We have a partial height */
1549 mp_h = mp.mp_aheight - 1;
Bob Petersond552a2b2017-02-06 08:28:32 -05001550
1551 /* If we find a non-null block pointer, crawl a bit
1552 higher up in the metapath and try again, otherwise
1553 we need to look lower for a new starting point. */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001554 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned))
Bob Petersond552a2b2017-02-06 08:28:32 -05001555 mp_h++;
1556 else
1557 state = DEALLOC_MP_LOWER;
1558 break;
1559 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001560 }
1561
Bob Petersond552a2b2017-02-06 08:28:32 -05001562 if (btotal) {
1563 if (current->journal_info == NULL) {
1564 ret = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS +
1565 RES_QUOTA, 0);
1566 if (ret)
1567 goto out;
1568 down_write(&ip->i_rw_mutex);
1569 }
1570 gfs2_statfs_change(sdp, 0, +btotal, 0);
1571 gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
1572 ip->i_inode.i_gid);
Stephen Rothwellb32c8c72017-05-08 15:59:34 -07001573 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Bob Petersond552a2b2017-02-06 08:28:32 -05001574 gfs2_trans_add_meta(ip->i_gl, dibh);
1575 gfs2_dinode_out(ip, dibh->b_data);
1576 up_write(&ip->i_rw_mutex);
1577 gfs2_trans_end(sdp);
1578 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001579
Bob Petersond552a2b2017-02-06 08:28:32 -05001580out:
1581 if (gfs2_holder_initialized(&rd_gh))
1582 gfs2_glock_dq_uninit(&rd_gh);
1583 if (current->journal_info) {
1584 up_write(&ip->i_rw_mutex);
1585 gfs2_trans_end(sdp);
1586 cond_resched();
1587 }
1588 gfs2_quota_unhold(ip);
1589out_metapath:
1590 release_metapath(&mp);
1591 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001592}
1593
1594static int trunc_end(struct gfs2_inode *ip)
1595{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001596 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001597 struct buffer_head *dibh;
1598 int error;
1599
1600 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1601 if (error)
1602 return error;
1603
1604 down_write(&ip->i_rw_mutex);
1605
1606 error = gfs2_meta_inode_buffer(ip, &dibh);
1607 if (error)
1608 goto out;
1609
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001610 if (!i_size_read(&ip->i_inode)) {
Steven Whitehouseecc30c72008-01-28 10:37:35 +00001611 ip->i_height = 0;
Steven Whitehousece276b02008-02-06 09:25:45 +00001612 ip->i_goal = ip->i_no_addr;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001613 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
Steven Whitehouse45138992013-01-28 09:30:07 +00001614 gfs2_ordered_del_inode(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001615 }
Deepa Dinamani078cd822016-09-14 07:48:04 -07001616 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001617 ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001618
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001619 gfs2_trans_add_meta(ip->i_gl, dibh);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001620 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001621 brelse(dibh);
1622
Steven Whitehousea91ea692006-09-04 12:04:26 -04001623out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001624 up_write(&ip->i_rw_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001625 gfs2_trans_end(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001626 return error;
1627}
1628
1629/**
1630 * do_shrink - make a file smaller
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001631 * @inode: the inode
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001632 * @newsize: the size to make the file
David Teiglandb3b94fa2006-01-16 16:50:04 +00001633 *
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001634 * Called with an exclusive lock on @inode. The @size must
1635 * be equal to or smaller than the current inode size.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001636 *
1637 * Returns: errno
1638 */
1639
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001640static int do_shrink(struct inode *inode, u64 newsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001641{
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001642 struct gfs2_inode *ip = GFS2_I(inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001643 int error;
1644
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001645 error = trunc_start(inode, newsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001646 if (error < 0)
1647 return error;
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001648 if (gfs2_is_stuffed(ip))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001649 return 0;
1650
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001651 error = punch_hole(ip, newsize, 0);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001652 if (error == 0)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001653 error = trunc_end(ip);
1654
1655 return error;
1656}
1657
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001658void gfs2_trim_blocks(struct inode *inode)
Wendy Chenga13b8c52007-08-20 09:29:53 -04001659{
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001660 int ret;
1661
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001662 ret = do_shrink(inode, inode->i_size);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001663 WARN_ON(ret != 0);
1664}
1665
1666/**
1667 * do_grow - Touch and update inode size
1668 * @inode: The inode
1669 * @size: The new size
1670 *
1671 * This function updates the timestamps on the inode and
1672 * may also increase the size of the inode. This function
1673 * must not be called with @size any smaller than the current
1674 * inode size.
1675 *
1676 * Although it is not strictly required to unstuff files here,
1677 * earlier versions of GFS2 have a bug in the stuffed file reading
1678 * code which will result in a buffer overrun if the size is larger
1679 * than the max stuffed file size. In order to prevent this from
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001680 * occurring, such files are unstuffed, but in other cases we can
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001681 * just update the inode size directly.
1682 *
1683 * Returns: 0 on success, or -ve on error
1684 */
1685
1686static int do_grow(struct inode *inode, u64 size)
1687{
1688 struct gfs2_inode *ip = GFS2_I(inode);
1689 struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001690 struct gfs2_alloc_parms ap = { .target = 1, };
Wendy Chenga13b8c52007-08-20 09:29:53 -04001691 struct buffer_head *dibh;
1692 int error;
Bob Peterson2f7ee352012-04-12 09:19:30 -04001693 int unstuff = 0;
Wendy Chenga13b8c52007-08-20 09:29:53 -04001694
Andreas Gruenbacher235628c2017-11-14 16:53:12 +01001695 if (gfs2_is_stuffed(ip) && size > gfs2_max_stuffed_size(ip)) {
Abhi Dasb8fbf472015-03-18 12:03:41 -05001696 error = gfs2_quota_lock_check(ip, &ap);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001697 if (error)
Bob Peterson5407e242012-05-18 09:28:23 -04001698 return error;
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001699
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001700 error = gfs2_inplace_reserve(ip, &ap);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001701 if (error)
1702 goto do_grow_qunlock;
Bob Peterson2f7ee352012-04-12 09:19:30 -04001703 unstuff = 1;
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001704 }
1705
Bob Petersona01aedf2013-06-27 12:47:51 -04001706 error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
1707 (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
1708 0 : RES_QUOTA), 0);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001709 if (error)
1710 goto do_grow_release;
1711
Bob Peterson2f7ee352012-04-12 09:19:30 -04001712 if (unstuff) {
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001713 error = gfs2_unstuff_dinode(ip, NULL);
1714 if (error)
1715 goto do_end_trans;
1716 }
Wendy Chenga13b8c52007-08-20 09:29:53 -04001717
1718 error = gfs2_meta_inode_buffer(ip, &dibh);
1719 if (error)
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001720 goto do_end_trans;
Wendy Chenga13b8c52007-08-20 09:29:53 -04001721
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001722 i_size_write(inode, size);
Deepa Dinamani078cd822016-09-14 07:48:04 -07001723 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001724 gfs2_trans_add_meta(ip->i_gl, dibh);
Wendy Chenga13b8c52007-08-20 09:29:53 -04001725 gfs2_dinode_out(ip, dibh->b_data);
1726 brelse(dibh);
1727
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001728do_end_trans:
Wendy Chenga13b8c52007-08-20 09:29:53 -04001729 gfs2_trans_end(sdp);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001730do_grow_release:
Bob Peterson2f7ee352012-04-12 09:19:30 -04001731 if (unstuff) {
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001732 gfs2_inplace_release(ip);
1733do_grow_qunlock:
1734 gfs2_quota_unlock(ip);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001735 }
Wendy Chenga13b8c52007-08-20 09:29:53 -04001736 return error;
1737}
1738
David Teiglandb3b94fa2006-01-16 16:50:04 +00001739/**
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001740 * gfs2_setattr_size - make a file a given size
1741 * @inode: the inode
1742 * @newsize: the size to make the file
David Teiglandb3b94fa2006-01-16 16:50:04 +00001743 *
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001744 * The file size can grow, shrink, or stay the same size. This
1745 * is called holding i_mutex and an exclusive glock on the inode
1746 * in question.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001747 *
1748 * Returns: errno
1749 */
1750
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001751int gfs2_setattr_size(struct inode *inode, u64 newsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001752{
Steven Whitehouseaf5c2692013-09-27 12:49:33 +01001753 struct gfs2_inode *ip = GFS2_I(inode);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001754 int ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001755
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001756 BUG_ON(!S_ISREG(inode->i_mode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001757
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001758 ret = inode_newsize_ok(inode, newsize);
1759 if (ret)
1760 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001761
Christoph Hellwig562c72aa52011-06-24 14:29:45 -04001762 inode_dio_wait(inode);
1763
Bob Petersonb54e9a02015-10-26 10:40:28 -05001764 ret = gfs2_rsqa_alloc(ip);
Bob Petersond2b47cf2013-02-01 12:03:02 -05001765 if (ret)
Bob Peterson2b3dcf32013-05-28 10:04:44 -04001766 goto out;
Bob Petersond2b47cf2013-02-01 12:03:02 -05001767
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001768 if (newsize >= inode->i_size) {
Bob Peterson2b3dcf32013-05-28 10:04:44 -04001769 ret = do_grow(inode, newsize);
1770 goto out;
1771 }
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001772
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001773 ret = do_shrink(inode, newsize);
Bob Peterson2b3dcf32013-05-28 10:04:44 -04001774out:
Bob Petersona097dc7e2015-07-16 08:28:04 -05001775 gfs2_rsqa_delete(ip, NULL);
Bob Peterson2b3dcf32013-05-28 10:04:44 -04001776 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001777}
1778
1779int gfs2_truncatei_resume(struct gfs2_inode *ip)
1780{
1781 int error;
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001782 error = punch_hole(ip, i_size_read(&ip->i_inode), 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001783 if (!error)
1784 error = trunc_end(ip);
1785 return error;
1786}
1787
1788int gfs2_file_dealloc(struct gfs2_inode *ip)
1789{
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001790 return punch_hole(ip, 0, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001791}
1792
1793/**
Steven Whitehouseb50f2272014-03-03 13:35:57 +00001794 * gfs2_free_journal_extents - Free cached journal bmap info
1795 * @jd: The journal
1796 *
1797 */
1798
1799void gfs2_free_journal_extents(struct gfs2_jdesc *jd)
1800{
1801 struct gfs2_journal_extent *jext;
1802
1803 while(!list_empty(&jd->extent_list)) {
1804 jext = list_entry(jd->extent_list.next, struct gfs2_journal_extent, list);
1805 list_del(&jext->list);
1806 kfree(jext);
1807 }
1808}
1809
1810/**
1811 * gfs2_add_jextent - Add or merge a new extent to extent cache
1812 * @jd: The journal descriptor
1813 * @lblock: The logical block at start of new extent
Fabian Frederickc62baf62014-05-14 18:32:31 +02001814 * @dblock: The physical block at start of new extent
Steven Whitehouseb50f2272014-03-03 13:35:57 +00001815 * @blocks: Size of extent in fs blocks
1816 *
1817 * Returns: 0 on success or -ENOMEM
1818 */
1819
1820static int gfs2_add_jextent(struct gfs2_jdesc *jd, u64 lblock, u64 dblock, u64 blocks)
1821{
1822 struct gfs2_journal_extent *jext;
1823
1824 if (!list_empty(&jd->extent_list)) {
1825 jext = list_entry(jd->extent_list.prev, struct gfs2_journal_extent, list);
1826 if ((jext->dblock + jext->blocks) == dblock) {
1827 jext->blocks += blocks;
1828 return 0;
1829 }
1830 }
1831
1832 jext = kzalloc(sizeof(struct gfs2_journal_extent), GFP_NOFS);
1833 if (jext == NULL)
1834 return -ENOMEM;
1835 jext->dblock = dblock;
1836 jext->lblock = lblock;
1837 jext->blocks = blocks;
1838 list_add_tail(&jext->list, &jd->extent_list);
1839 jd->nr_extents++;
1840 return 0;
1841}
1842
1843/**
1844 * gfs2_map_journal_extents - Cache journal bmap info
1845 * @sdp: The super block
1846 * @jd: The journal to map
1847 *
1848 * Create a reusable "extent" mapping from all logical
1849 * blocks to all physical blocks for the given journal. This will save
1850 * us time when writing journal blocks. Most journals will have only one
1851 * extent that maps all their logical blocks. That's because gfs2.mkfs
1852 * arranges the journal blocks sequentially to maximize performance.
1853 * So the extent would map the first block for the entire file length.
1854 * However, gfs2_jadd can happen while file activity is happening, so
1855 * those journals may not be sequential. Less likely is the case where
1856 * the users created their own journals by mounting the metafs and
1857 * laying it out. But it's still possible. These journals might have
1858 * several extents.
1859 *
1860 * Returns: 0 on success, or error on failure
1861 */
1862
1863int gfs2_map_journal_extents(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
1864{
1865 u64 lblock = 0;
1866 u64 lblock_stop;
1867 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
1868 struct buffer_head bh;
1869 unsigned int shift = sdp->sd_sb.sb_bsize_shift;
1870 u64 size;
1871 int rc;
1872
1873 lblock_stop = i_size_read(jd->jd_inode) >> shift;
1874 size = (lblock_stop - lblock) << shift;
1875 jd->nr_extents = 0;
1876 WARN_ON(!list_empty(&jd->extent_list));
1877
1878 do {
1879 bh.b_state = 0;
1880 bh.b_blocknr = 0;
1881 bh.b_size = size;
1882 rc = gfs2_block_map(jd->jd_inode, lblock, &bh, 0);
1883 if (rc || !buffer_mapped(&bh))
1884 goto fail;
1885 rc = gfs2_add_jextent(jd, lblock, bh.b_blocknr, bh.b_size >> shift);
1886 if (rc)
1887 goto fail;
1888 size -= bh.b_size;
1889 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1890 } while(size > 0);
1891
1892 fs_info(sdp, "journal %d mapped with %u extents\n", jd->jd_jid,
1893 jd->nr_extents);
1894 return 0;
1895
1896fail:
1897 fs_warn(sdp, "error %d mapping journal %u at offset %llu (extent %u)\n",
1898 rc, jd->jd_jid,
1899 (unsigned long long)(i_size_read(jd->jd_inode) - size),
1900 jd->nr_extents);
1901 fs_warn(sdp, "bmap=%d lblock=%llu block=%llu, state=0x%08lx, size=%llu\n",
1902 rc, (unsigned long long)lblock, (unsigned long long)bh.b_blocknr,
1903 bh.b_state, (unsigned long long)bh.b_size);
1904 gfs2_free_journal_extents(jd);
1905 return rc;
1906}
1907
1908/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00001909 * gfs2_write_alloc_required - figure out if a write will require an allocation
1910 * @ip: the file being written to
1911 * @offset: the offset to write to
1912 * @len: the number of bytes being written
David Teiglandb3b94fa2006-01-16 16:50:04 +00001913 *
Bob Peterson461cb412010-06-24 19:21:20 -04001914 * Returns: 1 if an alloc is required, 0 otherwise
David Teiglandb3b94fa2006-01-16 16:50:04 +00001915 */
1916
Steven Whitehousecd915492006-09-04 12:49:07 -04001917int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
Bob Peterson461cb412010-06-24 19:21:20 -04001918 unsigned int len)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001919{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001920 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001921 struct buffer_head bh;
1922 unsigned int shift;
1923 u64 lblock, lblock_stop, size;
Steven Whitehouse7ed122e2008-12-10 10:28:10 +00001924 u64 end_of_file;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001925
David Teiglandb3b94fa2006-01-16 16:50:04 +00001926 if (!len)
1927 return 0;
1928
1929 if (gfs2_is_stuffed(ip)) {
Andreas Gruenbacher235628c2017-11-14 16:53:12 +01001930 if (offset + len > gfs2_max_stuffed_size(ip))
Bob Peterson461cb412010-06-24 19:21:20 -04001931 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001932 return 0;
1933 }
1934
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001935 shift = sdp->sd_sb.sb_bsize_shift;
Steven Whitehouse7ed122e2008-12-10 10:28:10 +00001936 BUG_ON(gfs2_is_dir(ip));
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001937 end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
Steven Whitehouse7ed122e2008-12-10 10:28:10 +00001938 lblock = offset >> shift;
1939 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
1940 if (lblock_stop > end_of_file)
Bob Peterson461cb412010-06-24 19:21:20 -04001941 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001942
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001943 size = (lblock_stop - lblock) << shift;
1944 do {
1945 bh.b_state = 0;
1946 bh.b_size = size;
1947 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
1948 if (!buffer_mapped(&bh))
Bob Peterson461cb412010-06-24 19:21:20 -04001949 return 1;
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001950 size -= bh.b_size;
1951 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1952 } while(size > 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001953
1954 return 0;
1955}
1956
Andreas Gruenbacher4e56a642017-12-14 17:11:03 +01001957static int stuffed_zero_range(struct inode *inode, loff_t offset, loff_t length)
1958{
1959 struct gfs2_inode *ip = GFS2_I(inode);
1960 struct buffer_head *dibh;
1961 int error;
1962
1963 if (offset >= inode->i_size)
1964 return 0;
1965 if (offset + length > inode->i_size)
1966 length = inode->i_size - offset;
1967
1968 error = gfs2_meta_inode_buffer(ip, &dibh);
1969 if (error)
1970 return error;
1971 gfs2_trans_add_meta(ip->i_gl, dibh);
1972 memset(dibh->b_data + sizeof(struct gfs2_dinode) + offset, 0,
1973 length);
1974 brelse(dibh);
1975 return 0;
1976}
1977
1978static int gfs2_journaled_truncate_range(struct inode *inode, loff_t offset,
1979 loff_t length)
1980{
1981 struct gfs2_sbd *sdp = GFS2_SB(inode);
1982 loff_t max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
1983 int error;
1984
1985 while (length) {
1986 struct gfs2_trans *tr;
1987 loff_t chunk;
1988 unsigned int offs;
1989
1990 chunk = length;
1991 if (chunk > max_chunk)
1992 chunk = max_chunk;
1993
1994 offs = offset & ~PAGE_MASK;
1995 if (offs && chunk > PAGE_SIZE)
1996 chunk = offs + ((chunk - offs) & PAGE_MASK);
1997
1998 truncate_pagecache_range(inode, offset, chunk);
1999 offset += chunk;
2000 length -= chunk;
2001
2002 tr = current->journal_info;
2003 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
2004 continue;
2005
2006 gfs2_trans_end(sdp);
2007 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
2008 if (error)
2009 return error;
2010 }
2011 return 0;
2012}
2013
2014int __gfs2_punch_hole(struct file *file, loff_t offset, loff_t length)
2015{
2016 struct inode *inode = file_inode(file);
2017 struct gfs2_inode *ip = GFS2_I(inode);
2018 struct gfs2_sbd *sdp = GFS2_SB(inode);
2019 int error;
2020
2021 if (gfs2_is_jdata(ip))
2022 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA,
2023 GFS2_JTRUNC_REVOKES);
2024 else
2025 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
2026 if (error)
2027 return error;
2028
2029 if (gfs2_is_stuffed(ip)) {
2030 error = stuffed_zero_range(inode, offset, length);
2031 if (error)
2032 goto out;
2033 } else {
2034 unsigned int start_off, end_off, blocksize;
2035
2036 blocksize = i_blocksize(inode);
2037 start_off = offset & (blocksize - 1);
2038 end_off = (offset + length) & (blocksize - 1);
2039 if (start_off) {
2040 unsigned int len = length;
2041 if (length > blocksize - start_off)
2042 len = blocksize - start_off;
2043 error = gfs2_block_zero_range(inode, offset, len);
2044 if (error)
2045 goto out;
2046 if (start_off + length < blocksize)
2047 end_off = 0;
2048 }
2049 if (end_off) {
2050 error = gfs2_block_zero_range(inode,
2051 offset + length - end_off, end_off);
2052 if (error)
2053 goto out;
2054 }
2055 }
2056
2057 if (gfs2_is_jdata(ip)) {
2058 BUG_ON(!current->journal_info);
2059 gfs2_journaled_truncate_range(inode, offset, length);
2060 } else
2061 truncate_pagecache_range(inode, offset, offset + length - 1);
2062
2063 file_update_time(file);
2064 mark_inode_dirty(inode);
2065
2066 if (current->journal_info)
2067 gfs2_trans_end(sdp);
2068
2069 if (!gfs2_is_stuffed(ip))
2070 error = punch_hole(ip, offset, length);
2071
2072out:
2073 if (current->journal_info)
2074 gfs2_trans_end(sdp);
2075 return error;
2076}