blob: 8b5876e19ecf793b25addc9022708e675ef6441e [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"
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +010031#include "aops.h"
Steven Whitehouse63997772009-06-12 08:49:20 +010032#include "trace_gfs2.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000033
34/* This doesn't need to be that large as max 64 bit pointers in a 4k
35 * block is 512, so __u16 is fine for that. It saves stack space to
36 * keep it small.
37 */
38struct metapath {
Steven Whitehousedbac6712008-01-29 09:12:55 +000039 struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
David Teiglandb3b94fa2006-01-16 16:50:04 +000040 __u16 mp_list[GFS2_MAX_META_HEIGHT];
Bob Peterson5f8bd442016-10-28 14:29:29 -050041 int mp_fheight; /* find_metapath height */
42 int mp_aheight; /* actual height (lookup height) */
David Teiglandb3b94fa2006-01-16 16:50:04 +000043};
44
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +010045static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length);
46
David Teiglandb3b94fa2006-01-16 16:50:04 +000047/**
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040048 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
49 * @ip: the inode
50 * @dibh: the dinode buffer
51 * @block: the block number that was allocated
Steven Whitehouseff8f33c2010-08-11 09:37:53 +010052 * @page: The (optional) page. This is looked up if @page is NULL
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040053 *
54 * Returns: errno
55 */
56
57static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
Steven Whitehousecd915492006-09-04 12:49:07 -040058 u64 block, struct page *page)
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040059{
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040060 struct inode *inode = &ip->i_inode;
61 struct buffer_head *bh;
62 int release = 0;
63
64 if (!page || page->index) {
Bob Peterson220cca22012-03-19 15:25:50 -040065 page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040066 if (!page)
67 return -ENOMEM;
68 release = 1;
69 }
70
71 if (!PageUptodate(page)) {
72 void *kaddr = kmap(page);
Steven Whitehouse602c89d2010-03-25 14:32:43 +000073 u64 dsize = i_size_read(inode);
74
Andreas Gruenbacher235628c2017-11-14 16:53:12 +010075 if (dsize > gfs2_max_stuffed_size(ip))
76 dsize = gfs2_max_stuffed_size(ip);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040077
Steven Whitehouse602c89d2010-03-25 14:32:43 +000078 memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030079 memset(kaddr + dsize, 0, PAGE_SIZE - dsize);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040080 kunmap(page);
81
82 SetPageUptodate(page);
83 }
84
85 if (!page_has_buffers(page))
Fabian Frederick47a9a522016-08-02 12:05:27 -050086 create_empty_buffers(page, BIT(inode->i_blkbits),
87 BIT(BH_Uptodate));
Steven Whitehousef25ef0c2006-07-26 10:51:20 -040088
89 bh = page_buffers(page);
90
91 if (!buffer_mapped(bh))
92 map_bh(bh, inode->i_sb, block);
93
94 set_buffer_uptodate(bh);
Andreas Gruenbacher845802b2018-06-04 07:50:16 -050095 if (gfs2_is_jdata(ip))
Steven Whitehouse350a9b02012-12-14 12:36:02 +000096 gfs2_trans_add_data(ip->i_gl, bh);
Andreas Gruenbacher845802b2018-06-04 07:50:16 -050097 else {
98 mark_buffer_dirty(bh);
99 gfs2_ordered_add_inode(ip);
100 }
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400101
102 if (release) {
103 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300104 put_page(page);
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400105 }
106
107 return 0;
108}
109
110/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000111 * gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
112 * @ip: The GFS2 inode to unstuff
Steven Whitehouseff8f33c2010-08-11 09:37:53 +0100113 * @page: The (optional) page. This is looked up if the @page is NULL
David Teiglandb3b94fa2006-01-16 16:50:04 +0000114 *
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
Steven Whitehousea2e0f792010-08-11 09:53:11 +0100135 if (i_size_read(&ip->i_inode)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000136 /* 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;
Bob Peterson6e87ed02011-11-18 10:58:32 -0500140 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
Steven Whitehouse09010972009-05-20 10:48:47 +0100141 if (error)
142 goto out_brelse;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000143 if (isdir) {
Steven Whitehouse5731be52008-02-01 13:16:55 +0000144 gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
Steven Whitehouse61e085a2006-04-24 10:07:13 -0400145 error = gfs2_dir_get_new_buffer(ip, block, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000146 if (error)
147 goto out_brelse;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400148 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000149 dibh, sizeof(struct gfs2_dinode));
150 brelse(bh);
151 } else {
Steven Whitehousef25ef0c2006-07-26 10:51:20 -0400152 error = gfs2_unstuffer_page(ip, dibh, block, page);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000153 if (error)
154 goto out_brelse;
155 }
156 }
157
158 /* Set up the pointer to the new block */
159
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000160 gfs2_trans_add_meta(ip->i_gl, dibh);
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400161 di = (struct gfs2_dinode *)dibh->b_data;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000162 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
163
Steven Whitehousea2e0f792010-08-11 09:53:11 +0100164 if (i_size_read(&ip->i_inode)) {
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400165 *(__be64 *)(di + 1) = cpu_to_be64(block);
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000166 gfs2_add_inode_blocks(&ip->i_inode, 1);
167 di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000168 }
169
Steven Whitehouseecc30c72008-01-28 10:37:35 +0000170 ip->i_height = 1;
Steven Whitehouse48516ce2006-10-02 12:39:19 -0400171 di->di_height = cpu_to_be16(1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000172
Steven Whitehousea91ea692006-09-04 12:04:26 -0400173out_brelse:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000174 brelse(dibh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400175out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000176 up_write(&ip->i_rw_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000177 return error;
178}
179
David Teiglandb3b94fa2006-01-16 16:50:04 +0000180
181/**
182 * find_metapath - Find path through the metadata tree
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000183 * @sdp: The superblock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000184 * @block: The disk block to look up
Andreas Gruenbacher07e23d62018-06-04 07:32:44 -0500185 * @mp: The metapath to return the result in
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000186 * @height: The pre-calculated height of the metadata tree
David Teiglandb3b94fa2006-01-16 16:50:04 +0000187 *
188 * This routine returns a struct metapath structure that defines a path
189 * through the metadata of inode "ip" to get to block "block".
190 *
191 * Example:
192 * Given: "ip" is a height 3 file, "offset" is 101342453, and this is a
193 * filesystem with a blocksize of 4096.
194 *
195 * find_metapath() would return a struct metapath structure set to:
Andreas Gruenbacher07e23d62018-06-04 07:32:44 -0500196 * mp_fheight = 3, mp_list[0] = 0, mp_list[1] = 48, and mp_list[2] = 165.
David Teiglandb3b94fa2006-01-16 16:50:04 +0000197 *
198 * That means that in order to get to the block containing the byte at
199 * offset 101342453, we would load the indirect block pointed to by pointer
200 * 0 in the dinode. We would then load the indirect block pointed to by
201 * pointer 48 in that indirect block. We would then load the data block
202 * pointed to by pointer 165 in that indirect block.
203 *
204 * ----------------------------------------
205 * | Dinode | |
206 * | | 4|
207 * | |0 1 2 3 4 5 9|
208 * | | 6|
209 * ----------------------------------------
210 * |
211 * |
212 * V
213 * ----------------------------------------
214 * | Indirect Block |
215 * | 5|
216 * | 4 4 4 4 4 5 5 1|
217 * |0 5 6 7 8 9 0 1 2|
218 * ----------------------------------------
219 * |
220 * |
221 * V
222 * ----------------------------------------
223 * | Indirect Block |
224 * | 1 1 1 1 1 5|
225 * | 6 6 6 6 6 1|
226 * |0 3 4 5 6 7 2|
227 * ----------------------------------------
228 * |
229 * |
230 * V
231 * ----------------------------------------
232 * | Data block containing offset |
233 * | 101342453 |
234 * | |
235 * | |
236 * ----------------------------------------
237 *
238 */
239
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000240static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
241 struct metapath *mp, unsigned int height)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000242{
David Teiglandb3b94fa2006-01-16 16:50:04 +0000243 unsigned int i;
244
Bob Peterson5f8bd442016-10-28 14:29:29 -0500245 mp->mp_fheight = height;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000246 for (i = height; i--;)
Bob Peterson7eabb772008-01-28 11:24:35 -0600247 mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000248}
249
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500250static inline unsigned int metapath_branch_start(const struct metapath *mp)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000251{
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500252 if (mp->mp_list[0] == 0)
253 return 2;
254 return 1;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000255}
256
David Teiglandb3b94fa2006-01-16 16:50:04 +0000257/**
Andreas Gruenbacher20cdc192017-09-22 07:39:54 -0500258 * metaptr1 - Return the first possible metadata pointer in a metapath buffer
Bob Petersond552a2b2017-02-06 08:28:32 -0500259 * @height: The metadata height (0 = dinode)
260 * @mp: The metapath
261 */
262static inline __be64 *metaptr1(unsigned int height, const struct metapath *mp)
263{
264 struct buffer_head *bh = mp->mp_bh[height];
265 if (height == 0)
266 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)));
267 return ((__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header)));
268}
269
270/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000271 * metapointer - Return pointer to start of metadata in a buffer
David Teiglandb3b94fa2006-01-16 16:50:04 +0000272 * @height: The metadata height (0 = dinode)
273 * @mp: The metapath
274 *
275 * Return a pointer to the block number of the next height of the metadata
276 * tree given a buffer containing the pointer to the current height of the
277 * metadata tree.
278 */
279
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000280static inline __be64 *metapointer(unsigned int height, const struct metapath *mp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000281{
Bob Petersond552a2b2017-02-06 08:28:32 -0500282 __be64 *p = metaptr1(height, mp);
283 return p + mp->mp_list[height];
David Teiglandb3b94fa2006-01-16 16:50:04 +0000284}
285
Andreas Gruenbacher7841b9f2018-06-04 07:39:23 -0500286static inline const __be64 *metaend(unsigned int height, const struct metapath *mp)
287{
288 const struct buffer_head *bh = mp->mp_bh[height];
289 return (const __be64 *)(bh->b_data + bh->b_size);
290}
291
292static void clone_metapath(struct metapath *clone, struct metapath *mp)
293{
294 unsigned int hgt;
295
296 *clone = *mp;
297 for (hgt = 0; hgt < mp->mp_aheight; hgt++)
298 get_bh(clone->mp_bh[hgt]);
299}
300
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +0100301static void gfs2_metapath_ra(struct gfs2_glock *gl, __be64 *start, __be64 *end)
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100302{
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100303 const __be64 *t;
304
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +0100305 for (t = start; t < end; t++) {
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100306 struct buffer_head *rabh;
307
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100308 if (!*t)
309 continue;
310
311 rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);
312 if (trylock_buffer(rabh)) {
313 if (!buffer_uptodate(rabh)) {
314 rabh->b_end_io = end_buffer_read_sync;
Coly Lie477b242017-07-21 07:48:22 -0500315 submit_bh(REQ_OP_READ,
316 REQ_RAHEAD | REQ_META | REQ_PRIO,
317 rabh);
Steven Whitehouseb99b98d2011-09-21 11:05:16 +0100318 continue;
319 }
320 unlock_buffer(rabh);
321 }
322 brelse(rabh);
323 }
324}
325
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100326static int __fillup_metapath(struct gfs2_inode *ip, struct metapath *mp,
327 unsigned int x, unsigned int h)
Bob Petersond552a2b2017-02-06 08:28:32 -0500328{
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100329 for (; x < h; x++) {
330 __be64 *ptr = metapointer(x, mp);
331 u64 dblock = be64_to_cpu(*ptr);
332 int ret;
Bob Petersond552a2b2017-02-06 08:28:32 -0500333
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100334 if (!dblock)
335 break;
336 ret = gfs2_meta_indirect_buffer(ip, x + 1, dblock, &mp->mp_bh[x + 1]);
337 if (ret)
338 return ret;
339 }
340 mp->mp_aheight = x + 1;
341 return 0;
Bob Petersond552a2b2017-02-06 08:28:32 -0500342}
343
344/**
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000345 * lookup_metapath - Walk the metadata tree to a specific point
346 * @ip: The inode
David Teiglandb3b94fa2006-01-16 16:50:04 +0000347 * @mp: The metapath
David Teiglandb3b94fa2006-01-16 16:50:04 +0000348 *
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000349 * Assumes that the inode's buffer has already been looked up and
350 * hooked onto mp->mp_bh[0] and that the metapath has been initialised
351 * by find_metapath().
David Teiglandb3b94fa2006-01-16 16:50:04 +0000352 *
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000353 * If this function encounters part of the tree which has not been
354 * allocated, it returns the current height of the tree at the point
355 * at which it found the unallocated block. Blocks which are found are
356 * added to the mp->mp_bh[] list.
357 *
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100358 * Returns: error
David Teiglandb3b94fa2006-01-16 16:50:04 +0000359 */
360
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000361static int lookup_metapath(struct gfs2_inode *ip, struct metapath *mp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000362{
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100363 return __fillup_metapath(ip, mp, 0, ip->i_height - 1);
Steven Whitehousedbac6712008-01-29 09:12:55 +0000364}
365
Bob Petersond552a2b2017-02-06 08:28:32 -0500366/**
367 * fillup_metapath - fill up buffers for the metadata path to a specific height
368 * @ip: The inode
369 * @mp: The metapath
370 * @h: The height to which it should be mapped
371 *
372 * Similar to lookup_metapath, but does lookups for a range of heights
373 *
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100374 * Returns: error or the number of buffers filled
Bob Petersond552a2b2017-02-06 08:28:32 -0500375 */
376
377static int fillup_metapath(struct gfs2_inode *ip, struct metapath *mp, int h)
378{
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100379 unsigned int x = 0;
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100380 int ret;
Bob Petersond552a2b2017-02-06 08:28:32 -0500381
382 if (h) {
383 /* find the first buffer we need to look up. */
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100384 for (x = h - 1; x > 0; x--) {
385 if (mp->mp_bh[x])
386 break;
Bob Petersond552a2b2017-02-06 08:28:32 -0500387 }
388 }
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +0100389 ret = __fillup_metapath(ip, mp, x, h);
390 if (ret)
391 return ret;
392 return mp->mp_aheight - x - 1;
Bob Petersond552a2b2017-02-06 08:28:32 -0500393}
394
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100395static void release_metapath(struct metapath *mp)
Steven Whitehousedbac6712008-01-29 09:12:55 +0000396{
397 int i;
398
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000399 for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
400 if (mp->mp_bh[i] == NULL)
401 break;
402 brelse(mp->mp_bh[i]);
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100403 mp->mp_bh[i] = NULL;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000404 }
Steven Whitehouse11707ea2008-01-28 15:10:29 +0000405}
406
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000407/**
408 * gfs2_extent_length - Returns length of an extent of blocks
Andreas Gruenbacherbcfe9412018-05-11 17:44:19 +0100409 * @bh: The metadata block
410 * @ptr: Current position in @bh
411 * @limit: Max extent length to return
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000412 * @eob: Set to 1 if we hit "end of block"
413 *
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000414 * Returns: The length of the extent (minimum of one block)
415 */
416
Andreas Gruenbacherbcfe9412018-05-11 17:44:19 +0100417static inline unsigned int gfs2_extent_length(struct buffer_head *bh, __be64 *ptr, size_t limit, int *eob)
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000418{
Andreas Gruenbacherbcfe9412018-05-11 17:44:19 +0100419 const __be64 *end = (__be64 *)(bh->b_data + bh->b_size);
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000420 const __be64 *first = ptr;
421 u64 d = be64_to_cpu(*ptr);
422
423 *eob = 0;
424 do {
425 ptr++;
426 if (ptr >= end)
427 break;
Andreas Gruenbacherbcfe9412018-05-11 17:44:19 +0100428 d++;
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000429 } while(be64_to_cpu(*ptr) == d);
430 if (ptr >= end)
431 *eob = 1;
Andreas Gruenbacherbcfe9412018-05-11 17:44:19 +0100432 return ptr - first;
Steven Whitehouse30cbf182008-02-08 13:18:11 +0000433}
434
Andreas Gruenbacher7841b9f2018-06-04 07:39:23 -0500435typedef const __be64 *(*gfs2_metadata_walker)(
436 struct metapath *mp,
437 const __be64 *start, const __be64 *end,
438 u64 factor, void *data);
439
440#define WALK_STOP ((__be64 *)0)
441#define WALK_NEXT ((__be64 *)1)
442
443static int gfs2_walk_metadata(struct inode *inode, sector_t lblock,
444 u64 len, struct metapath *mp, gfs2_metadata_walker walker,
445 void *data)
446{
447 struct metapath clone;
448 struct gfs2_inode *ip = GFS2_I(inode);
449 struct gfs2_sbd *sdp = GFS2_SB(inode);
450 const __be64 *start, *end, *ptr;
451 u64 factor = 1;
452 unsigned int hgt;
453 int ret = 0;
454
455 for (hgt = ip->i_height - 1; hgt >= mp->mp_aheight; hgt--)
456 factor *= sdp->sd_inptrs;
457
458 for (;;) {
459 u64 step;
460
461 /* Walk indirect block. */
462 start = metapointer(hgt, mp);
463 end = metaend(hgt, mp);
464
465 step = (end - start) * factor;
466 if (step > len)
467 end = start + DIV_ROUND_UP_ULL(len, factor);
468
469 ptr = walker(mp, start, end, factor, data);
470 if (ptr == WALK_STOP)
471 break;
472 if (step >= len)
473 break;
474 len -= step;
475 if (ptr != WALK_NEXT) {
476 BUG_ON(!*ptr);
477 mp->mp_list[hgt] += ptr - start;
478 goto fill_up_metapath;
479 }
480
481lower_metapath:
482 /* Decrease height of metapath. */
483 if (mp != &clone) {
484 clone_metapath(&clone, mp);
485 mp = &clone;
486 }
487 brelse(mp->mp_bh[hgt]);
488 mp->mp_bh[hgt] = NULL;
489 if (!hgt)
490 break;
491 hgt--;
492 factor *= sdp->sd_inptrs;
493
494 /* Advance in metadata tree. */
495 (mp->mp_list[hgt])++;
496 start = metapointer(hgt, mp);
497 end = metaend(hgt, mp);
498 if (start >= end) {
499 mp->mp_list[hgt] = 0;
500 if (!hgt)
501 break;
502 goto lower_metapath;
503 }
504
505fill_up_metapath:
506 /* Increase height of metapath. */
507 if (mp != &clone) {
508 clone_metapath(&clone, mp);
509 mp = &clone;
510 }
511 ret = fillup_metapath(ip, mp, ip->i_height - 1);
512 if (ret < 0)
513 break;
514 hgt += ret;
515 for (; ret; ret--)
516 do_div(factor, sdp->sd_inptrs);
517 mp->mp_aheight = hgt + 1;
518 }
519 if (mp == &clone)
520 release_metapath(mp);
521 return ret;
522}
523
524struct gfs2_hole_walker_args {
525 u64 blocks;
526};
527
528static const __be64 *gfs2_hole_walker(struct metapath *mp,
529 const __be64 *start, const __be64 *end,
530 u64 factor, void *data)
531{
532 struct gfs2_hole_walker_args *args = data;
533 const __be64 *ptr;
534
535 for (ptr = start; ptr < end; ptr++) {
536 if (*ptr) {
537 args->blocks += (ptr - start) * factor;
538 if (mp->mp_aheight == mp->mp_fheight)
539 return WALK_STOP;
540 return ptr; /* increase height */
541 }
542 }
543 args->blocks += (end - start) * factor;
544 return WALK_NEXT;
545}
546
547/**
548 * gfs2_hole_size - figure out the size of a hole
549 * @inode: The inode
550 * @lblock: The logical starting block number
551 * @len: How far to look (in blocks)
552 * @mp: The metapath at lblock
553 * @iomap: The iomap to store the hole size in
554 *
555 * This function modifies @mp.
556 *
557 * Returns: errno on error
558 */
559static int gfs2_hole_size(struct inode *inode, sector_t lblock, u64 len,
560 struct metapath *mp, struct iomap *iomap)
561{
562 struct gfs2_hole_walker_args args = { };
563 int ret = 0;
564
565 ret = gfs2_walk_metadata(inode, lblock, len, mp, gfs2_hole_walker, &args);
566 if (!ret)
567 iomap->length = args.blocks << inode->i_blkbits;
568 return ret;
569}
570
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000571static inline __be64 *gfs2_indirect_init(struct metapath *mp,
572 struct gfs2_glock *gl, unsigned int i,
573 unsigned offset, u64 bn)
574{
575 __be64 *ptr = (__be64 *)(mp->mp_bh[i - 1]->b_data +
576 ((i > 1) ? sizeof(struct gfs2_meta_header) :
577 sizeof(struct gfs2_dinode)));
578 BUG_ON(i < 1);
579 BUG_ON(mp->mp_bh[i] != NULL);
580 mp->mp_bh[i] = gfs2_meta_new(gl, bn);
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000581 gfs2_trans_add_meta(gl, mp->mp_bh[i]);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000582 gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
583 gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
584 ptr += offset;
585 *ptr = cpu_to_be64(bn);
586 return ptr;
587}
588
589enum alloc_state {
590 ALLOC_DATA = 0,
591 ALLOC_GROW_DEPTH = 1,
592 ALLOC_GROW_HEIGHT = 2,
593 /* ALLOC_UNSTUFF = 3, TBD and rather complicated */
594};
595
596/**
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500597 * gfs2_iomap_alloc - Build a metadata tree of the requested height
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000598 * @inode: The GFS2 inode
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500599 * @iomap: The iomap structure
600 * @flags: iomap flags
Bob Peterson5f8bd442016-10-28 14:29:29 -0500601 * @mp: The metapath, with proper height information calculated
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000602 *
603 * In this routine we may have to alloc:
604 * i) Indirect blocks to grow the metadata tree height
605 * ii) Indirect blocks to fill in lower part of the metadata tree
606 * iii) Data blocks
607 *
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100608 * This function is called after gfs2_iomap_get, which works out the
609 * total number of blocks which we need via gfs2_alloc_size.
610 *
611 * We then do the actual allocation asking for an extent at a time (if
612 * enough contiguous free blocks are available, there will only be one
613 * allocation request per call) and uses the state machine to initialise
614 * the blocks in order.
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000615 *
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500616 * Right now, this function will allocate at most one indirect block
617 * worth of data -- with a default block size of 4K, that's slightly
618 * less than 2M. If this limitation is ever removed to allow huge
619 * allocations, we would probably still want to limit the iomap size we
620 * return to avoid stalling other tasks during huge writes; the next
621 * iomap iteration would then find the blocks already allocated.
622 *
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000623 * Returns: errno on error
624 */
625
Bob Peterson39743202017-02-16 10:27:16 -0500626static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,
627 unsigned flags, struct metapath *mp)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000628{
629 struct gfs2_inode *ip = GFS2_I(inode);
630 struct gfs2_sbd *sdp = GFS2_SB(inode);
631 struct buffer_head *dibh = mp->mp_bh[0];
Bob Peterson5f8bd442016-10-28 14:29:29 -0500632 u64 bn;
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500633 unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100634 size_t dblks = iomap->length >> inode->i_blkbits;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500635 const unsigned end_of_metadata = mp->mp_fheight - 1;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500636 int ret;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000637 enum alloc_state state;
638 __be64 *ptr;
639 __be64 zero_bn = 0;
640
Bob Peterson5f8bd442016-10-28 14:29:29 -0500641 BUG_ON(mp->mp_aheight < 1);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000642 BUG_ON(dibh == NULL);
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100643 BUG_ON(dblks < 1);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000644
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000645 gfs2_trans_add_meta(ip->i_gl, dibh);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000646
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500647 down_write(&ip->i_rw_mutex);
648
Bob Peterson5f8bd442016-10-28 14:29:29 -0500649 if (mp->mp_fheight == mp->mp_aheight) {
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100650 /* Bottom indirect block exists */
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000651 state = ALLOC_DATA;
652 } else {
653 /* Need to allocate indirect blocks */
Bob Peterson5f8bd442016-10-28 14:29:29 -0500654 if (mp->mp_fheight == ip->i_height) {
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000655 /* Writing into existing tree, extend tree down */
Bob Peterson5f8bd442016-10-28 14:29:29 -0500656 iblks = mp->mp_fheight - mp->mp_aheight;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000657 state = ALLOC_GROW_DEPTH;
658 } else {
659 /* Building up tree height */
660 state = ALLOC_GROW_HEIGHT;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500661 iblks = mp->mp_fheight - ip->i_height;
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500662 branch_start = metapath_branch_start(mp);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500663 iblks += (mp->mp_fheight - branch_start);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000664 }
665 }
666
667 /* start of the second part of the function (state machine) */
668
Bob Peterson39743202017-02-16 10:27:16 -0500669 blks = dblks + iblks;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500670 i = mp->mp_aheight;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000671 do {
672 n = blks - alloced;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500673 ret = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
674 if (ret)
675 goto out;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000676 alloced += n;
677 if (state != ALLOC_DATA || gfs2_is_jdata(ip))
678 gfs2_trans_add_unrevoke(sdp, bn, n);
679 switch (state) {
680 /* Growing height of tree */
681 case ALLOC_GROW_HEIGHT:
682 if (i == 1) {
683 ptr = (__be64 *)(dibh->b_data +
684 sizeof(struct gfs2_dinode));
685 zero_bn = *ptr;
686 }
Bob Peterson5f8bd442016-10-28 14:29:29 -0500687 for (; i - 1 < mp->mp_fheight - ip->i_height && n > 0;
688 i++, n--)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000689 gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500690 if (i - 1 == mp->mp_fheight - ip->i_height) {
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000691 i--;
692 gfs2_buffer_copy_tail(mp->mp_bh[i],
693 sizeof(struct gfs2_meta_header),
694 dibh, sizeof(struct gfs2_dinode));
695 gfs2_buffer_clear_tail(dibh,
696 sizeof(struct gfs2_dinode) +
697 sizeof(__be64));
698 ptr = (__be64 *)(mp->mp_bh[i]->b_data +
699 sizeof(struct gfs2_meta_header));
700 *ptr = zero_bn;
701 state = ALLOC_GROW_DEPTH;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500702 for(i = branch_start; i < mp->mp_fheight; i++) {
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000703 if (mp->mp_bh[i] == NULL)
704 break;
705 brelse(mp->mp_bh[i]);
706 mp->mp_bh[i] = NULL;
707 }
Benjamin Marzinski5af4e7a2008-06-24 12:53:38 -0500708 i = branch_start;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000709 }
710 if (n == 0)
711 break;
712 /* Branching from existing tree */
713 case ALLOC_GROW_DEPTH:
Bob Peterson5f8bd442016-10-28 14:29:29 -0500714 if (i > 1 && i < mp->mp_fheight)
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000715 gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[i-1]);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500716 for (; i < mp->mp_fheight && n > 0; i++, n--)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000717 gfs2_indirect_init(mp, ip->i_gl, i,
718 mp->mp_list[i-1], bn++);
Bob Peterson5f8bd442016-10-28 14:29:29 -0500719 if (i == mp->mp_fheight)
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000720 state = ALLOC_DATA;
721 if (n == 0)
722 break;
723 /* Tree complete, adding data blocks */
724 case ALLOC_DATA:
Bob Peterson39743202017-02-16 10:27:16 -0500725 BUG_ON(n > dblks);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000726 BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000727 gfs2_trans_add_meta(ip->i_gl, mp->mp_bh[end_of_metadata]);
Bob Peterson39743202017-02-16 10:27:16 -0500728 dblks = n;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000729 ptr = metapointer(end_of_metadata, mp);
Bob Peterson39743202017-02-16 10:27:16 -0500730 iomap->addr = bn << inode->i_blkbits;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500731 iomap->flags |= IOMAP_F_MERGED | IOMAP_F_NEW;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000732 while (n-- > 0)
733 *ptr++ = cpu_to_be64(bn++);
734 break;
735 }
Bob Peterson39743202017-02-16 10:27:16 -0500736 } while (iomap->addr == IOMAP_NULL_ADDR);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000737
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100738 iomap->type = IOMAP_MAPPED;
Bob Peterson39743202017-02-16 10:27:16 -0500739 iomap->length = (u64)dblks << inode->i_blkbits;
Bob Peterson5f8bd442016-10-28 14:29:29 -0500740 ip->i_height = mp->mp_fheight;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000741 gfs2_add_inode_blocks(&ip->i_inode, alloced);
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500742 gfs2_dinode_out(ip, dibh->b_data);
743out:
744 up_write(&ip->i_rw_mutex);
745 return ret;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +0000746}
747
Christoph Hellwig7ee66c02018-06-01 09:03:07 -0700748#define IOMAP_F_GFS2_BOUNDARY IOMAP_F_PRIVATE
749
Bob Peterson39743202017-02-16 10:27:16 -0500750/**
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100751 * gfs2_alloc_size - Compute the maximum allocation size
752 * @inode: The inode
753 * @mp: The metapath
754 * @size: Requested size in blocks
755 *
756 * Compute the maximum size of the next allocation at @mp.
757 *
758 * Returns: size in blocks
759 */
760static u64 gfs2_alloc_size(struct inode *inode, struct metapath *mp, u64 size)
761{
762 struct gfs2_inode *ip = GFS2_I(inode);
763 struct gfs2_sbd *sdp = GFS2_SB(inode);
764 const __be64 *first, *ptr, *end;
765
766 /*
767 * For writes to stuffed files, this function is called twice via
768 * gfs2_iomap_get, before and after unstuffing. The size we return the
769 * first time needs to be large enough to get the reservation and
770 * allocation sizes right. The size we return the second time must
771 * be exact or else gfs2_iomap_alloc won't do the right thing.
772 */
773
774 if (gfs2_is_stuffed(ip) || mp->mp_fheight != mp->mp_aheight) {
775 unsigned int maxsize = mp->mp_fheight > 1 ?
776 sdp->sd_inptrs : sdp->sd_diptrs;
777 maxsize -= mp->mp_list[mp->mp_fheight - 1];
778 if (size > maxsize)
779 size = maxsize;
780 return size;
781 }
782
783 first = metapointer(ip->i_height - 1, mp);
784 end = metaend(ip->i_height - 1, mp);
785 if (end - first > size)
786 end = first + size;
787 for (ptr = first; ptr < end; ptr++) {
788 if (*ptr)
789 break;
790 }
791 return ptr - first;
792}
793
794/**
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500795 * gfs2_iomap_get - Map blocks from an inode to disk blocks
Bob Peterson39743202017-02-16 10:27:16 -0500796 * @inode: The inode
797 * @pos: Starting position in bytes
798 * @length: Length to map, in bytes
799 * @flags: iomap flags
800 * @iomap: The iomap structure
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500801 * @mp: The metapath
Bob Peterson39743202017-02-16 10:27:16 -0500802 *
803 * Returns: errno
804 */
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500805static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length,
806 unsigned flags, struct iomap *iomap,
807 struct metapath *mp)
Bob Peterson39743202017-02-16 10:27:16 -0500808{
809 struct gfs2_inode *ip = GFS2_I(inode);
810 struct gfs2_sbd *sdp = GFS2_SB(inode);
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100811 loff_t size = i_size_read(inode);
Bob Peterson39743202017-02-16 10:27:16 -0500812 __be64 *ptr;
813 sector_t lblock;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500814 sector_t lblock_stop;
815 int ret;
Bob Peterson39743202017-02-16 10:27:16 -0500816 int eob;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500817 u64 len;
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100818 struct buffer_head *dibh = NULL, *bh;
Bob Peterson39743202017-02-16 10:27:16 -0500819 u8 height;
820
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500821 if (!length)
822 return -EINVAL;
Bob Peterson39743202017-02-16 10:27:16 -0500823
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100824 down_read(&ip->i_rw_mutex);
825
826 ret = gfs2_meta_inode_buffer(ip, &dibh);
827 if (ret)
828 goto unlock;
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100829 iomap->private = dibh;
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100830
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700831 if (gfs2_is_stuffed(ip)) {
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100832 if (flags & IOMAP_WRITE) {
833 loff_t max_size = gfs2_max_stuffed_size(ip);
834
835 if (pos + length > max_size)
836 goto unstuff;
837 iomap->length = max_size;
838 } else {
839 if (pos >= size) {
840 if (flags & IOMAP_REPORT) {
841 ret = -ENOENT;
842 goto unlock;
843 } else {
844 /* report a hole */
845 iomap->offset = pos;
846 iomap->length = length;
847 goto do_alloc;
848 }
849 }
850 iomap->length = size;
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700851 }
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100852 iomap->addr = (ip->i_no_addr << inode->i_blkbits) +
853 sizeof(struct gfs2_dinode);
854 iomap->type = IOMAP_INLINE;
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100855 iomap->inline_data = dibh->b_data + sizeof(struct gfs2_dinode);
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100856 goto out;
Bob Peterson39743202017-02-16 10:27:16 -0500857 }
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100858
859unstuff:
Bob Peterson39743202017-02-16 10:27:16 -0500860 lblock = pos >> inode->i_blkbits;
Bob Peterson39743202017-02-16 10:27:16 -0500861 iomap->offset = lblock << inode->i_blkbits;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500862 lblock_stop = (pos + length - 1) >> inode->i_blkbits;
863 len = lblock_stop - lblock + 1;
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100864 iomap->length = len << inode->i_blkbits;
Bob Peterson39743202017-02-16 10:27:16 -0500865
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100866 get_bh(dibh);
867 mp->mp_bh[0] = dibh;
Bob Peterson39743202017-02-16 10:27:16 -0500868
869 height = ip->i_height;
Andreas Gruenbacher9a386622018-04-16 09:25:21 -0700870 while ((lblock + 1) * sdp->sd_sb.sb_bsize > sdp->sd_heightsize[height])
Bob Peterson39743202017-02-16 10:27:16 -0500871 height++;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500872 find_metapath(sdp, lblock, mp, height);
Bob Peterson39743202017-02-16 10:27:16 -0500873 if (height > ip->i_height || gfs2_is_stuffed(ip))
874 goto do_alloc;
875
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500876 ret = lookup_metapath(ip, mp);
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +0100877 if (ret)
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500878 goto unlock;
Bob Peterson39743202017-02-16 10:27:16 -0500879
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500880 if (mp->mp_aheight != ip->i_height)
Bob Peterson39743202017-02-16 10:27:16 -0500881 goto do_alloc;
882
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500883 ptr = metapointer(ip->i_height - 1, mp);
Bob Peterson39743202017-02-16 10:27:16 -0500884 if (*ptr == 0)
885 goto do_alloc;
886
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500887 bh = mp->mp_bh[ip->i_height - 1];
Andreas Gruenbacherbcfe9412018-05-11 17:44:19 +0100888 len = gfs2_extent_length(bh, ptr, len, &eob);
Bob Peterson39743202017-02-16 10:27:16 -0500889
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500890 iomap->addr = be64_to_cpu(*ptr) << inode->i_blkbits;
891 iomap->length = len << inode->i_blkbits;
892 iomap->type = IOMAP_MAPPED;
893 iomap->flags = IOMAP_F_MERGED;
Bob Peterson39743202017-02-16 10:27:16 -0500894 if (eob)
Christoph Hellwig7ee66c02018-06-01 09:03:07 -0700895 iomap->flags |= IOMAP_F_GFS2_BOUNDARY;
Bob Peterson39743202017-02-16 10:27:16 -0500896
Bob Peterson39743202017-02-16 10:27:16 -0500897out:
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500898 iomap->bdev = inode->i_sb->s_bdev;
899unlock:
900 up_read(&ip->i_rw_mutex);
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100901 if (ret && dibh)
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100902 brelse(dibh);
Bob Peterson39743202017-02-16 10:27:16 -0500903 return ret;
904
905do_alloc:
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500906 iomap->addr = IOMAP_NULL_ADDR;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500907 iomap->type = IOMAP_HOLE;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500908 if (flags & IOMAP_REPORT) {
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700909 if (pos >= size)
Bob Peterson39743202017-02-16 10:27:16 -0500910 ret = -ENOENT;
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500911 else if (height == ip->i_height)
912 ret = gfs2_hole_size(inode, lblock, len, mp, iomap);
Andreas Gruenbacher49edd5bf2018-02-06 07:20:55 -0700913 else
914 iomap->length = size - pos;
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100915 } else if (flags & IOMAP_WRITE) {
916 u64 alloc_size;
917
918 len = gfs2_alloc_size(inode, mp, len);
919 alloc_size = len << inode->i_blkbits;
920 if (alloc_size < iomap->length)
921 iomap->length = alloc_size;
922 } else {
Andreas Gruenbacherd505a96a2018-06-24 10:43:49 +0100923 if (pos < size && height == ip->i_height)
924 ret = gfs2_hole_size(inode, lblock, len, mp, iomap);
Bob Peterson39743202017-02-16 10:27:16 -0500925 }
Andreas Gruenbacher628e3662018-06-04 07:56:51 -0500926 goto out;
Bob Peterson39743202017-02-16 10:27:16 -0500927}
928
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +0100929static int gfs2_write_lock(struct inode *inode)
930{
931 struct gfs2_inode *ip = GFS2_I(inode);
932 struct gfs2_sbd *sdp = GFS2_SB(inode);
933 int error;
934
935 gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
936 error = gfs2_glock_nq(&ip->i_gh);
937 if (error)
938 goto out_uninit;
939 if (&ip->i_inode == sdp->sd_rindex) {
940 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
941
942 error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
943 GL_NOCACHE, &m_ip->i_gh);
944 if (error)
945 goto out_unlock;
946 }
947 return 0;
948
949out_unlock:
950 gfs2_glock_dq(&ip->i_gh);
951out_uninit:
952 gfs2_holder_uninit(&ip->i_gh);
953 return error;
954}
955
956static void gfs2_write_unlock(struct inode *inode)
957{
958 struct gfs2_inode *ip = GFS2_I(inode);
959 struct gfs2_sbd *sdp = GFS2_SB(inode);
960
961 if (&ip->i_inode == sdp->sd_rindex) {
962 struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
963
964 gfs2_glock_dq_uninit(&m_ip->i_gh);
965 }
966 gfs2_glock_dq_uninit(&ip->i_gh);
967}
968
969static void gfs2_iomap_journaled_page_done(struct inode *inode, loff_t pos,
970 unsigned copied, struct page *page,
971 struct iomap *iomap)
972{
973 struct gfs2_inode *ip = GFS2_I(inode);
974
975 gfs2_page_add_databufs(ip, page, offset_in_page(pos), copied);
976}
977
978static int gfs2_iomap_begin_write(struct inode *inode, loff_t pos,
979 loff_t length, unsigned flags,
980 struct iomap *iomap)
981{
982 struct metapath mp = { .mp_aheight = 1, };
983 struct gfs2_inode *ip = GFS2_I(inode);
984 struct gfs2_sbd *sdp = GFS2_SB(inode);
985 unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
986 bool unstuff, alloc_required;
987 int ret;
988
989 ret = gfs2_write_lock(inode);
990 if (ret)
991 return ret;
992
993 unstuff = gfs2_is_stuffed(ip) &&
994 pos + length > gfs2_max_stuffed_size(ip);
995
996 ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
997 if (ret)
998 goto out_release;
999
1000 alloc_required = unstuff || iomap->type == IOMAP_HOLE;
1001
1002 if (alloc_required || gfs2_is_jdata(ip))
1003 gfs2_write_calc_reserv(ip, iomap->length, &data_blocks,
1004 &ind_blocks);
1005
1006 if (alloc_required) {
1007 struct gfs2_alloc_parms ap = {
1008 .target = data_blocks + ind_blocks
1009 };
1010
1011 ret = gfs2_quota_lock_check(ip, &ap);
1012 if (ret)
1013 goto out_release;
1014
1015 ret = gfs2_inplace_reserve(ip, &ap);
1016 if (ret)
1017 goto out_qunlock;
1018 }
1019
1020 rblocks = RES_DINODE + ind_blocks;
1021 if (gfs2_is_jdata(ip))
1022 rblocks += data_blocks;
1023 if (ind_blocks || data_blocks)
1024 rblocks += RES_STATFS + RES_QUOTA;
1025 if (inode == sdp->sd_rindex)
1026 rblocks += 2 * RES_STATFS;
1027 if (alloc_required)
1028 rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
1029
1030 ret = gfs2_trans_begin(sdp, rblocks, iomap->length >> inode->i_blkbits);
1031 if (ret)
1032 goto out_trans_fail;
1033
1034 if (unstuff) {
1035 ret = gfs2_unstuff_dinode(ip, NULL);
1036 if (ret)
1037 goto out_trans_end;
1038 release_metapath(&mp);
1039 brelse(iomap->private);
1040 iomap->private = NULL;
1041 ret = gfs2_iomap_get(inode, iomap->offset, iomap->length,
1042 flags, iomap, &mp);
1043 if (ret)
1044 goto out_trans_end;
1045 }
1046
1047 if (iomap->type == IOMAP_HOLE) {
1048 ret = gfs2_iomap_alloc(inode, iomap, flags, &mp);
1049 if (ret) {
1050 gfs2_trans_end(sdp);
1051 gfs2_inplace_release(ip);
1052 punch_hole(ip, iomap->offset, iomap->length);
1053 goto out_qunlock;
1054 }
1055 }
1056 release_metapath(&mp);
1057 if (gfs2_is_jdata(ip))
1058 iomap->page_done = gfs2_iomap_journaled_page_done;
1059 return 0;
1060
1061out_trans_end:
1062 gfs2_trans_end(sdp);
1063out_trans_fail:
1064 if (alloc_required)
1065 gfs2_inplace_release(ip);
1066out_qunlock:
1067 if (alloc_required)
1068 gfs2_quota_unlock(ip);
1069out_release:
1070 if (iomap->private)
1071 brelse(iomap->private);
1072 release_metapath(&mp);
1073 gfs2_write_unlock(inode);
1074 return ret;
1075}
1076
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001077static int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,
1078 unsigned flags, struct iomap *iomap)
1079{
1080 struct gfs2_inode *ip = GFS2_I(inode);
1081 struct metapath mp = { .mp_aheight = 1, };
1082 int ret;
1083
1084 trace_gfs2_iomap_start(ip, pos, length, flags);
1085 if (flags & IOMAP_WRITE) {
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +01001086 ret = gfs2_iomap_begin_write(inode, pos, length, flags, iomap);
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001087 } else {
1088 ret = gfs2_iomap_get(inode, pos, length, flags, iomap, &mp);
1089 release_metapath(&mp);
1090 }
1091 trace_gfs2_iomap_end(ip, iomap, ret);
1092 return ret;
1093}
1094
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +01001095static int gfs2_iomap_end(struct inode *inode, loff_t pos, loff_t length,
1096 ssize_t written, unsigned flags, struct iomap *iomap)
1097{
1098 struct gfs2_inode *ip = GFS2_I(inode);
1099 struct gfs2_sbd *sdp = GFS2_SB(inode);
1100 struct gfs2_trans *tr = current->journal_info;
1101 struct buffer_head *dibh = iomap->private;
1102
1103 if (!(flags & IOMAP_WRITE))
1104 goto out;
1105
1106 if (iomap->type != IOMAP_INLINE) {
1107 gfs2_ordered_add_inode(ip);
1108
1109 if (tr->tr_num_buf_new)
1110 __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
1111 else
1112 gfs2_trans_add_meta(ip->i_gl, dibh);
1113 }
1114
1115 if (inode == sdp->sd_rindex) {
1116 adjust_fs_space(inode);
1117 sdp->sd_rindex_uptodate = 0;
1118 }
1119
1120 gfs2_trans_end(sdp);
1121 gfs2_inplace_release(ip);
1122
1123 if (length != written && (iomap->flags & IOMAP_F_NEW)) {
1124 /* Deallocate blocks that were just allocated. */
1125 loff_t blockmask = i_blocksize(inode) - 1;
1126 loff_t end = (pos + length) & ~blockmask;
1127
1128 pos = (pos + written + blockmask) & ~blockmask;
1129 if (pos < end) {
1130 truncate_pagecache_range(inode, pos, end - 1);
1131 punch_hole(ip, pos, end - pos);
1132 }
1133 }
1134
1135 if (ip->i_qadata && ip->i_qadata->qa_qd_num)
1136 gfs2_quota_unlock(ip);
1137 gfs2_write_unlock(inode);
1138
1139out:
1140 if (dibh)
1141 brelse(dibh);
1142 return 0;
1143}
1144
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001145const struct iomap_ops gfs2_iomap_ops = {
1146 .iomap_begin = gfs2_iomap_begin,
Andreas Gruenbacher64bc06b2018-06-24 15:04:04 +01001147 .iomap_end = gfs2_iomap_end,
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001148};
1149
Bob Peterson39743202017-02-16 10:27:16 -05001150/**
Andreas Gruenbacherd39d18e2018-03-05 06:24:28 -07001151 * gfs2_block_map - Map one or more blocks of an inode to a disk block
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -05001152 * @inode: The inode
1153 * @lblock: The logical block number
1154 * @bh_map: The bh to be mapped
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +00001155 * @create: True if its ok to alloc blocks to satify the request
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -05001156 *
Andreas Gruenbacherd39d18e2018-03-05 06:24:28 -07001157 * The size of the requested mapping is defined in bh_map->b_size.
1158 *
1159 * Clears buffer_mapped(bh_map) and leaves bh_map->b_size unchanged
1160 * when @lblock is not mapped. Sets buffer_mapped(bh_map) and
1161 * bh_map->b_size to indicate the size of the mapping when @lblock and
1162 * successive blocks are mapped, up to the requested size.
1163 *
1164 * Sets buffer_boundary() if a read of metadata will be required
1165 * before the next block can be mapped. Sets buffer_new() if new
1166 * blocks were allocated.
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -05001167 *
1168 * Returns: errno
1169 */
1170
Bob Petersone9e1ef22007-12-10 14:13:27 -06001171int gfs2_block_map(struct inode *inode, sector_t lblock,
1172 struct buffer_head *bh_map, int create)
Steven Whitehousefd88de562006-05-05 16:59:11 -04001173{
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -05001174 struct gfs2_inode *ip = GFS2_I(inode);
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001175 loff_t pos = (loff_t)lblock << inode->i_blkbits;
1176 loff_t length = bh_map->b_size;
1177 struct metapath mp = { .mp_aheight = 1, };
1178 struct iomap iomap = { };
1179 int ret;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +00001180
Steven Whitehouse4cf1ed82006-11-15 15:21:06 -05001181 clear_buffer_mapped(bh_map);
1182 clear_buffer_new(bh_map);
1183 clear_buffer_boundary(bh_map);
Steven Whitehouse63997772009-06-12 08:49:20 +01001184 trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
Andreas Gruenbacher20cdc192017-09-22 07:39:54 -05001185
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001186 if (create) {
1187 ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, &iomap, &mp);
1188 if (!ret && iomap.type == IOMAP_HOLE)
1189 ret = gfs2_iomap_alloc(inode, &iomap, IOMAP_WRITE, &mp);
1190 release_metapath(&mp);
1191 } else {
1192 ret = gfs2_iomap_get(inode, pos, length, 0, &iomap, &mp);
1193 release_metapath(&mp);
Bob Peterson5f8bd442016-10-28 14:29:29 -05001194 }
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001195 if (ret)
1196 goto out;
Bob Peterson39743202017-02-16 10:27:16 -05001197
1198 if (iomap.length > bh_map->b_size) {
1199 iomap.length = bh_map->b_size;
Christoph Hellwig7ee66c02018-06-01 09:03:07 -07001200 iomap.flags &= ~IOMAP_F_GFS2_BOUNDARY;
Bob Peterson39743202017-02-16 10:27:16 -05001201 }
1202 if (iomap.addr != IOMAP_NULL_ADDR)
1203 map_bh(bh_map, inode->i_sb, iomap.addr >> inode->i_blkbits);
1204 bh_map->b_size = iomap.length;
Christoph Hellwig7ee66c02018-06-01 09:03:07 -07001205 if (iomap.flags & IOMAP_F_GFS2_BOUNDARY)
Bob Peterson39743202017-02-16 10:27:16 -05001206 set_buffer_boundary(bh_map);
1207 if (iomap.flags & IOMAP_F_NEW)
1208 set_buffer_new(bh_map);
1209
1210out:
1211 trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
1212 return ret;
Steven Whitehousefd88de562006-05-05 16:59:11 -04001213}
1214
Steven Whitehouse941e6d72008-01-28 08:47:38 +00001215/*
1216 * Deprecated: do not use in new code
1217 */
Steven Whitehousefd88de562006-05-05 16:59:11 -04001218int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
1219{
Steven Whitehouse23591252006-10-13 17:25:45 -04001220 struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -04001221 int ret;
Steven Whitehousefd88de562006-05-05 16:59:11 -04001222 int create = *new;
1223
1224 BUG_ON(!extlen);
1225 BUG_ON(!dblock);
1226 BUG_ON(!new);
1227
Fabian Frederick47a9a522016-08-02 12:05:27 -05001228 bh.b_size = BIT(inode->i_blkbits + (create ? 0 : 5));
Bob Petersone9e1ef22007-12-10 14:13:27 -06001229 ret = gfs2_block_map(inode, lblock, &bh, create);
Steven Whitehouse7a6bbac2006-09-18 17:18:23 -04001230 *extlen = bh.b_size >> inode->i_blkbits;
1231 *dblock = bh.b_blocknr;
1232 if (buffer_new(&bh))
1233 *new = 1;
1234 else
1235 *new = 0;
1236 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001237}
1238
1239/**
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +01001240 * gfs2_block_zero_range - Deal with zeroing out data
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001241 *
1242 * This is partly borrowed from ext3.
1243 */
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +01001244static int gfs2_block_zero_range(struct inode *inode, loff_t from,
1245 unsigned int length)
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001246{
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +01001247 struct address_space *mapping = inode->i_mapping;
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001248 struct gfs2_inode *ip = GFS2_I(inode);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001249 unsigned long index = from >> PAGE_SHIFT;
1250 unsigned offset = from & (PAGE_SIZE-1);
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +01001251 unsigned blocksize, iblock, pos;
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001252 struct buffer_head *bh;
1253 struct page *page;
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001254 int err;
1255
Bob Peterson220cca22012-03-19 15:25:50 -04001256 page = find_or_create_page(mapping, index, GFP_NOFS);
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001257 if (!page)
1258 return 0;
1259
1260 blocksize = inode->i_sb->s_blocksize;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001261 iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001262
1263 if (!page_has_buffers(page))
1264 create_empty_buffers(page, blocksize, 0);
1265
1266 /* Find the buffer that contains "offset" */
1267 bh = page_buffers(page);
1268 pos = blocksize;
1269 while (offset >= pos) {
1270 bh = bh->b_this_page;
1271 iblock++;
1272 pos += blocksize;
1273 }
1274
1275 err = 0;
1276
1277 if (!buffer_mapped(bh)) {
Bob Petersone9e1ef22007-12-10 14:13:27 -06001278 gfs2_block_map(inode, iblock, bh, 0);
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001279 /* unmapped? It's a hole - nothing to do */
1280 if (!buffer_mapped(bh))
1281 goto unlock;
1282 }
1283
1284 /* Ok, it's mapped. Make sure it's up-to-date */
1285 if (PageUptodate(page))
1286 set_buffer_uptodate(bh);
1287
1288 if (!buffer_uptodate(bh)) {
1289 err = -EIO;
Mike Christiedfec8a12016-06-05 14:31:44 -05001290 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001291 wait_on_buffer(bh);
1292 /* Uhhuh. Read error. Complain and punt. */
1293 if (!buffer_uptodate(bh))
1294 goto unlock;
S. Wendy Cheng1875f2f2007-06-25 21:14:31 -04001295 err = 0;
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001296 }
1297
Andreas Gruenbacher845802b2018-06-04 07:50:16 -05001298 if (gfs2_is_jdata(ip))
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001299 gfs2_trans_add_data(ip->i_gl, bh);
Andreas Gruenbacher845802b2018-06-04 07:50:16 -05001300 else
1301 gfs2_ordered_add_inode(ip);
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001302
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001303 zero_user(page, offset, length);
Steven Whitehouse40bc9a22009-06-10 09:09:40 +01001304 mark_buffer_dirty(bh);
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001305unlock:
1306 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001307 put_page(page);
Steven Whitehouseba7f7292006-07-26 11:27:10 -04001308 return err;
1309}
1310
Fabian Frederickc62baf62014-05-14 18:32:31 +02001311#define GFS2_JTRUNC_REVOKES 8192
1312
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001313/**
1314 * gfs2_journaled_truncate - Wrapper for truncate_pagecache for jdata files
1315 * @inode: The inode being truncated
1316 * @oldsize: The original (larger) size
1317 * @newsize: The new smaller size
1318 *
1319 * With jdata files, we have to journal a revoke for each block which is
1320 * truncated. As a result, we need to split this into separate transactions
1321 * if the number of pages being truncated gets too large.
1322 */
1323
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001324static int gfs2_journaled_truncate(struct inode *inode, u64 oldsize, u64 newsize)
1325{
1326 struct gfs2_sbd *sdp = GFS2_SB(inode);
1327 u64 max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
1328 u64 chunk;
1329 int error;
1330
1331 while (oldsize != newsize) {
Andreas Gruenbachere7fdf002017-12-12 16:47:20 +01001332 struct gfs2_trans *tr;
1333 unsigned int offs;
1334
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001335 chunk = oldsize - newsize;
1336 if (chunk > max_chunk)
1337 chunk = max_chunk;
Andreas Gruenbachere7fdf002017-12-12 16:47:20 +01001338
1339 offs = oldsize & ~PAGE_MASK;
1340 if (offs && chunk > PAGE_SIZE)
1341 chunk = offs + ((chunk - offs) & PAGE_MASK);
1342
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07001343 truncate_pagecache(inode, oldsize - chunk);
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001344 oldsize -= chunk;
Andreas Gruenbachere7fdf002017-12-12 16:47:20 +01001345
1346 tr = current->journal_info;
1347 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
1348 continue;
1349
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001350 gfs2_trans_end(sdp);
1351 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
1352 if (error)
1353 return error;
1354 }
1355
1356 return 0;
1357}
1358
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001359static int trunc_start(struct inode *inode, u64 newsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001360{
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001361 struct gfs2_inode *ip = GFS2_I(inode);
1362 struct gfs2_sbd *sdp = GFS2_SB(inode);
Andreas Gruenbacher80990f402017-12-12 16:42:01 +01001363 struct buffer_head *dibh = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001364 int journaled = gfs2_is_jdata(ip);
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01001365 u64 oldsize = inode->i_size;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001366 int error;
1367
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001368 if (journaled)
1369 error = gfs2_trans_begin(sdp, RES_DINODE + RES_JDATA, GFS2_JTRUNC_REVOKES);
1370 else
1371 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001372 if (error)
1373 return error;
1374
1375 error = gfs2_meta_inode_buffer(ip, &dibh);
1376 if (error)
1377 goto out;
1378
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001379 gfs2_trans_add_meta(ip->i_gl, dibh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001380
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001381 if (gfs2_is_stuffed(ip)) {
1382 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1383 } else {
Andreas Gruenbacherbdba0d52017-12-13 20:10:38 +01001384 unsigned int blocksize = i_blocksize(inode);
1385 unsigned int offs = newsize & (blocksize - 1);
1386 if (offs) {
1387 error = gfs2_block_zero_range(inode, newsize,
1388 blocksize - offs);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001389 if (error)
Andreas Gruenbacher80990f402017-12-12 16:42:01 +01001390 goto out;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001391 }
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001392 ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001393 }
1394
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001395 i_size_write(inode, newsize);
Deepa Dinamani078cd822016-09-14 07:48:04 -07001396 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001397 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001398
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001399 if (journaled)
1400 error = gfs2_journaled_truncate(inode, oldsize, newsize);
1401 else
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07001402 truncate_pagecache(inode, newsize);
Steven Whitehousefa731fc2012-11-13 09:50:28 +00001403
Steven Whitehousea91ea692006-09-04 12:04:26 -04001404out:
Andreas Gruenbacher80990f402017-12-12 16:42:01 +01001405 brelse(dibh);
1406 if (current->journal_info)
1407 gfs2_trans_end(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001408 return error;
1409}
1410
Andreas Gruenbacher628e3662018-06-04 07:56:51 -05001411int gfs2_iomap_get_alloc(struct inode *inode, loff_t pos, loff_t length,
1412 struct iomap *iomap)
1413{
1414 struct metapath mp = { .mp_aheight = 1, };
1415 int ret;
1416
1417 ret = gfs2_iomap_get(inode, pos, length, IOMAP_WRITE, iomap, &mp);
1418 if (!ret && iomap->type == IOMAP_HOLE)
1419 ret = gfs2_iomap_alloc(inode, iomap, IOMAP_WRITE, &mp);
1420 release_metapath(&mp);
1421 return ret;
1422}
1423
Bob Petersond552a2b2017-02-06 08:28:32 -05001424/**
1425 * sweep_bh_for_rgrps - find an rgrp in a meta buffer and free blocks therein
1426 * @ip: inode
1427 * @rg_gh: holder of resource group glock
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001428 * @bh: buffer head to sweep
1429 * @start: starting point in bh
1430 * @end: end point in bh
1431 * @meta: true if bh points to metadata (rather than data)
Bob Petersond552a2b2017-02-06 08:28:32 -05001432 * @btotal: place to keep count of total blocks freed
Bob Petersond552a2b2017-02-06 08:28:32 -05001433 *
1434 * We sweep a metadata buffer (provided by the metapath) for blocks we need to
1435 * free, and free them all. However, we do it one rgrp at a time. If this
1436 * block has references to multiple rgrps, we break it into individual
1437 * transactions. This allows other processes to use the rgrps while we're
1438 * focused on a single one, for better concurrency / performance.
1439 * At every transaction boundary, we rewrite the inode into the journal.
1440 * That way the bitmaps are kept consistent with the inode and we can recover
1441 * if we're interrupted by power-outages.
1442 *
1443 * Returns: 0, or return code if an error occurred.
1444 * *btotal has the total number of blocks freed
1445 */
1446static int sweep_bh_for_rgrps(struct gfs2_inode *ip, struct gfs2_holder *rd_gh,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001447 struct buffer_head *bh, __be64 *start, __be64 *end,
1448 bool meta, u32 *btotal)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001449{
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +00001450 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Bob Petersond552a2b2017-02-06 08:28:32 -05001451 struct gfs2_rgrpd *rgd;
1452 struct gfs2_trans *tr;
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001453 __be64 *p;
Bob Petersond552a2b2017-02-06 08:28:32 -05001454 int blks_outside_rgrp;
1455 u64 bn, bstart, isize_blks;
1456 s64 blen; /* needs to be s64 or gfs2_add_inode_blocks breaks */
Bob Petersond552a2b2017-02-06 08:28:32 -05001457 int ret = 0;
1458 bool buf_in_tr = false; /* buffer was added to transaction */
David Teiglandb3b94fa2006-01-16 16:50:04 +00001459
Bob Petersond552a2b2017-02-06 08:28:32 -05001460more_rgrps:
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001461 rgd = NULL;
1462 if (gfs2_holder_initialized(rd_gh)) {
1463 rgd = gfs2_glock2rgrp(rd_gh->gh_gl);
1464 gfs2_assert_withdraw(sdp,
1465 gfs2_glock_is_locked_by_me(rd_gh->gh_gl));
1466 }
Bob Petersond552a2b2017-02-06 08:28:32 -05001467 blks_outside_rgrp = 0;
1468 bstart = 0;
1469 blen = 0;
Bob Petersond552a2b2017-02-06 08:28:32 -05001470
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001471 for (p = start; p < end; p++) {
Bob Petersond552a2b2017-02-06 08:28:32 -05001472 if (!*p)
1473 continue;
1474 bn = be64_to_cpu(*p);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001475
1476 if (rgd) {
1477 if (!rgrp_contains_block(rgd, bn)) {
1478 blks_outside_rgrp++;
1479 continue;
1480 }
Bob Petersond552a2b2017-02-06 08:28:32 -05001481 } else {
Steven Whitehouse90bcab92017-12-22 13:13:07 +01001482 rgd = gfs2_blk2rgrpd(sdp, bn, true);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001483 if (unlikely(!rgd)) {
1484 ret = -EIO;
1485 goto out;
1486 }
Bob Petersond552a2b2017-02-06 08:28:32 -05001487 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1488 0, rd_gh);
1489 if (ret)
1490 goto out;
1491
1492 /* Must be done with the rgrp glock held: */
1493 if (gfs2_rs_active(&ip->i_res) &&
1494 rgd == ip->i_res.rs_rbm.rgd)
1495 gfs2_rs_deltree(&ip->i_res);
1496 }
1497
Bob Petersond552a2b2017-02-06 08:28:32 -05001498 /* The size of our transactions will be unknown until we
1499 actually process all the metadata blocks that relate to
1500 the rgrp. So we estimate. We know it can't be more than
1501 the dinode's i_blocks and we don't want to exceed the
1502 journal flush threshold, sd_log_thresh2. */
1503 if (current->journal_info == NULL) {
1504 unsigned int jblocks_rqsted, revokes;
1505
1506 jblocks_rqsted = rgd->rd_length + RES_DINODE +
1507 RES_INDIRECT;
1508 isize_blks = gfs2_get_inode_blocks(&ip->i_inode);
1509 if (isize_blks > atomic_read(&sdp->sd_log_thresh2))
1510 jblocks_rqsted +=
1511 atomic_read(&sdp->sd_log_thresh2);
1512 else
1513 jblocks_rqsted += isize_blks;
1514 revokes = jblocks_rqsted;
1515 if (meta)
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001516 revokes += end - start;
Bob Petersond552a2b2017-02-06 08:28:32 -05001517 else if (ip->i_depth)
1518 revokes += sdp->sd_inptrs;
1519 ret = gfs2_trans_begin(sdp, jblocks_rqsted, revokes);
1520 if (ret)
1521 goto out_unlock;
1522 down_write(&ip->i_rw_mutex);
1523 }
1524 /* check if we will exceed the transaction blocks requested */
1525 tr = current->journal_info;
1526 if (tr->tr_num_buf_new + RES_STATFS +
1527 RES_QUOTA >= atomic_read(&sdp->sd_log_thresh2)) {
1528 /* We set blks_outside_rgrp to ensure the loop will
1529 be repeated for the same rgrp, but with a new
1530 transaction. */
1531 blks_outside_rgrp++;
1532 /* This next part is tricky. If the buffer was added
1533 to the transaction, we've already set some block
1534 pointers to 0, so we better follow through and free
1535 them, or we will introduce corruption (so break).
1536 This may be impossible, or at least rare, but I
1537 decided to cover the case regardless.
1538
1539 If the buffer was not added to the transaction
1540 (this call), doing so would exceed our transaction
1541 size, so we need to end the transaction and start a
1542 new one (so goto). */
1543
1544 if (buf_in_tr)
1545 break;
1546 goto out_unlock;
1547 }
1548
1549 gfs2_trans_add_meta(ip->i_gl, bh);
1550 buf_in_tr = true;
1551 *p = 0;
1552 if (bstart + blen == bn) {
1553 blen++;
1554 continue;
1555 }
1556 if (bstart) {
1557 __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1558 (*btotal) += blen;
1559 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1560 }
1561 bstart = bn;
1562 blen = 1;
1563 }
1564 if (bstart) {
1565 __gfs2_free_blocks(ip, bstart, (u32)blen, meta);
1566 (*btotal) += blen;
1567 gfs2_add_inode_blocks(&ip->i_inode, -blen);
1568 }
1569out_unlock:
1570 if (!ret && blks_outside_rgrp) { /* If buffer still has non-zero blocks
1571 outside the rgrp we just processed,
1572 do it all over again. */
1573 if (current->journal_info) {
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001574 struct buffer_head *dibh;
1575
1576 ret = gfs2_meta_inode_buffer(ip, &dibh);
1577 if (ret)
1578 goto out;
Bob Petersond552a2b2017-02-06 08:28:32 -05001579
1580 /* Every transaction boundary, we rewrite the dinode
1581 to keep its di_blocks current in case of failure. */
1582 ip->i_inode.i_mtime = ip->i_inode.i_ctime =
Stephen Rothwellb32c8c72017-05-08 15:59:34 -07001583 current_time(&ip->i_inode);
Bob Petersond552a2b2017-02-06 08:28:32 -05001584 gfs2_trans_add_meta(ip->i_gl, dibh);
1585 gfs2_dinode_out(ip, dibh->b_data);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001586 brelse(dibh);
Bob Petersond552a2b2017-02-06 08:28:32 -05001587 up_write(&ip->i_rw_mutex);
1588 gfs2_trans_end(sdp);
1589 }
1590 gfs2_glock_dq_uninit(rd_gh);
1591 cond_resched();
1592 goto more_rgrps;
1593 }
1594out:
1595 return ret;
1596}
1597
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001598static bool mp_eq_to_hgt(struct metapath *mp, __u16 *list, unsigned int h)
1599{
1600 if (memcmp(mp->mp_list, list, h * sizeof(mp->mp_list[0])))
1601 return false;
1602 return true;
1603}
1604
Bob Petersond552a2b2017-02-06 08:28:32 -05001605/**
1606 * find_nonnull_ptr - find a non-null pointer given a metapath and height
Bob Petersond552a2b2017-02-06 08:28:32 -05001607 * @mp: starting metapath
1608 * @h: desired height to search
1609 *
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001610 * Assumes the metapath is valid (with buffers) out to height h.
Bob Petersond552a2b2017-02-06 08:28:32 -05001611 * Returns: true if a non-null pointer was found in the metapath buffer
1612 * false if all remaining pointers are NULL in the buffer
1613 */
1614static bool find_nonnull_ptr(struct gfs2_sbd *sdp, struct metapath *mp,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001615 unsigned int h,
1616 __u16 *end_list, unsigned int end_aligned)
Bob Petersond552a2b2017-02-06 08:28:32 -05001617{
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001618 struct buffer_head *bh = mp->mp_bh[h];
1619 __be64 *first, *ptr, *end;
Bob Petersond552a2b2017-02-06 08:28:32 -05001620
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001621 first = metaptr1(h, mp);
1622 ptr = first + mp->mp_list[h];
1623 end = (__be64 *)(bh->b_data + bh->b_size);
1624 if (end_list && mp_eq_to_hgt(mp, end_list, h)) {
1625 bool keep_end = h < end_aligned;
1626 end = first + end_list[h] + keep_end;
1627 }
1628
1629 while (ptr < end) {
Bob Petersonc4a9d182017-08-30 09:26:09 -05001630 if (*ptr) { /* if we have a non-null pointer */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001631 mp->mp_list[h] = ptr - first;
Bob Petersonc4a9d182017-08-30 09:26:09 -05001632 h++;
1633 if (h < GFS2_MAX_META_HEIGHT)
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001634 mp->mp_list[h] = 0;
Bob Petersond552a2b2017-02-06 08:28:32 -05001635 return true;
Bob Petersonc4a9d182017-08-30 09:26:09 -05001636 }
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001637 ptr++;
Bob Petersond552a2b2017-02-06 08:28:32 -05001638 }
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001639 return false;
Bob Petersond552a2b2017-02-06 08:28:32 -05001640}
1641
1642enum dealloc_states {
1643 DEALLOC_MP_FULL = 0, /* Strip a metapath with all buffers read in */
1644 DEALLOC_MP_LOWER = 1, /* lower the metapath strip height */
1645 DEALLOC_FILL_MP = 2, /* Fill in the metapath to the given height. */
1646 DEALLOC_DONE = 3, /* process complete */
1647};
1648
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001649static inline void
1650metapointer_range(struct metapath *mp, int height,
1651 __u16 *start_list, unsigned int start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001652 __u16 *end_list, unsigned int end_aligned,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001653 __be64 **start, __be64 **end)
1654{
1655 struct buffer_head *bh = mp->mp_bh[height];
1656 __be64 *first;
1657
1658 first = metaptr1(height, mp);
1659 *start = first;
1660 if (mp_eq_to_hgt(mp, start_list, height)) {
1661 bool keep_start = height < start_aligned;
1662 *start = first + start_list[height] + keep_start;
1663 }
1664 *end = (__be64 *)(bh->b_data + bh->b_size);
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001665 if (end_list && mp_eq_to_hgt(mp, end_list, height)) {
1666 bool keep_end = height < end_aligned;
1667 *end = first + end_list[height] + keep_end;
1668 }
1669}
1670
1671static inline bool walk_done(struct gfs2_sbd *sdp,
1672 struct metapath *mp, int height,
1673 __u16 *end_list, unsigned int end_aligned)
1674{
1675 __u16 end;
1676
1677 if (end_list) {
1678 bool keep_end = height < end_aligned;
1679 if (!mp_eq_to_hgt(mp, end_list, height))
1680 return false;
1681 end = end_list[height] + keep_end;
1682 } else
1683 end = (height > 0) ? sdp->sd_inptrs : sdp->sd_diptrs;
1684 return mp->mp_list[height] >= end;
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001685}
1686
Bob Petersond552a2b2017-02-06 08:28:32 -05001687/**
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001688 * punch_hole - deallocate blocks in a file
Bob Petersond552a2b2017-02-06 08:28:32 -05001689 * @ip: inode to truncate
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001690 * @offset: the start of the hole
1691 * @length: the size of the hole (or 0 for truncate)
Bob Petersond552a2b2017-02-06 08:28:32 -05001692 *
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001693 * Punch a hole into a file or truncate a file at a given position. This
1694 * function operates in whole blocks (@offset and @length are rounded
1695 * accordingly); partially filled blocks must be cleared otherwise.
1696 *
1697 * This function works from the bottom up, and from the right to the left. In
1698 * other words, it strips off the highest layer (data) before stripping any of
1699 * the metadata. Doing it this way is best in case the operation is interrupted
1700 * by power failure, etc. The dinode is rewritten in every transaction to
1701 * guarantee integrity.
Bob Petersond552a2b2017-02-06 08:28:32 -05001702 */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001703static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length)
Bob Petersond552a2b2017-02-06 08:28:32 -05001704{
1705 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Andreas Gruenbacherbb491ce2018-03-23 07:33:25 -07001706 u64 maxsize = sdp->sd_heightsize[ip->i_height];
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001707 struct metapath mp = {};
Bob Petersond552a2b2017-02-06 08:28:32 -05001708 struct buffer_head *dibh, *bh;
1709 struct gfs2_holder rd_gh;
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001710 unsigned int bsize_shift = sdp->sd_sb.sb_bsize_shift;
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001711 u64 lblock = (offset + (1 << bsize_shift) - 1) >> bsize_shift;
1712 __u16 start_list[GFS2_MAX_META_HEIGHT];
1713 __u16 __end_list[GFS2_MAX_META_HEIGHT], *end_list = NULL;
Andreas Gruenbacher4e56a642017-12-14 17:11:03 +01001714 unsigned int start_aligned, uninitialized_var(end_aligned);
Bob Petersond552a2b2017-02-06 08:28:32 -05001715 unsigned int strip_h = ip->i_height - 1;
1716 u32 btotal = 0;
1717 int ret, state;
1718 int mp_h; /* metapath buffers are read in to this height */
Bob Petersond552a2b2017-02-06 08:28:32 -05001719 u64 prev_bnr = 0;
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001720 __be64 *start, *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001721
Andreas Gruenbacherbb491ce2018-03-23 07:33:25 -07001722 if (offset >= maxsize) {
1723 /*
1724 * The starting point lies beyond the allocated meta-data;
1725 * there are no blocks do deallocate.
1726 */
1727 return 0;
1728 }
1729
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001730 /*
1731 * The start position of the hole is defined by lblock, start_list, and
1732 * start_aligned. The end position of the hole is defined by lend,
1733 * end_list, and end_aligned.
1734 *
1735 * start_aligned and end_aligned define down to which height the start
1736 * and end positions are aligned to the metadata tree (i.e., the
1737 * position is a multiple of the metadata granularity at the height
1738 * above). This determines at which heights additional meta pointers
1739 * needs to be preserved for the remaining data.
1740 */
David Teiglandb3b94fa2006-01-16 16:50:04 +00001741
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001742 if (length) {
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001743 u64 end_offset = offset + length;
1744 u64 lend;
1745
1746 /*
1747 * Clip the end at the maximum file size for the given height:
1748 * that's how far the metadata goes; files bigger than that
1749 * will have additional layers of indirection.
1750 */
1751 if (end_offset > maxsize)
1752 end_offset = maxsize;
1753 lend = end_offset >> bsize_shift;
1754
1755 if (lblock >= lend)
1756 return 0;
1757
1758 find_metapath(sdp, lend, &mp, ip->i_height);
1759 end_list = __end_list;
1760 memcpy(end_list, mp.mp_list, sizeof(mp.mp_list));
1761
1762 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1763 if (end_list[mp_h])
1764 break;
1765 }
1766 end_aligned = mp_h;
1767 }
1768
1769 find_metapath(sdp, lblock, &mp, ip->i_height);
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001770 memcpy(start_list, mp.mp_list, sizeof(start_list));
1771
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001772 for (mp_h = ip->i_height - 1; mp_h > 0; mp_h--) {
1773 if (start_list[mp_h])
1774 break;
1775 }
1776 start_aligned = mp_h;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001777
Bob Petersond552a2b2017-02-06 08:28:32 -05001778 ret = gfs2_meta_inode_buffer(ip, &dibh);
1779 if (ret)
1780 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001781
Bob Petersond552a2b2017-02-06 08:28:32 -05001782 mp.mp_bh[0] = dibh;
1783 ret = lookup_metapath(ip, &mp);
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001784 if (ret)
1785 goto out_metapath;
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001786
1787 /* issue read-ahead on metadata */
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001788 for (mp_h = 0; mp_h < mp.mp_aheight - 1; mp_h++) {
1789 metapointer_range(&mp, mp_h, start_list, start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001790 end_list, end_aligned, &start, &end);
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001791 gfs2_metapath_ra(ip->i_gl, start, end);
1792 }
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001793
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001794 if (mp.mp_aheight == ip->i_height)
Bob Petersond552a2b2017-02-06 08:28:32 -05001795 state = DEALLOC_MP_FULL; /* We have a complete metapath */
1796 else
1797 state = DEALLOC_FILL_MP; /* deal with partial metapath */
1798
1799 ret = gfs2_rindex_update(sdp);
1800 if (ret)
1801 goto out_metapath;
1802
1803 ret = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1804 if (ret)
1805 goto out_metapath;
1806 gfs2_holder_mark_uninitialized(&rd_gh);
1807
1808 mp_h = strip_h;
1809
1810 while (state != DEALLOC_DONE) {
1811 switch (state) {
1812 /* Truncate a full metapath at the given strip height.
1813 * Note that strip_h == mp_h in order to be in this state. */
1814 case DEALLOC_MP_FULL:
Bob Petersond552a2b2017-02-06 08:28:32 -05001815 bh = mp.mp_bh[mp_h];
1816 gfs2_assert_withdraw(sdp, bh);
1817 if (gfs2_assert_withdraw(sdp,
1818 prev_bnr != bh->b_blocknr)) {
1819 printk(KERN_EMERG "GFS2: fsid=%s:inode %llu, "
1820 "block:%llu, i_h:%u, s_h:%u, mp_h:%u\n",
1821 sdp->sd_fsname,
1822 (unsigned long long)ip->i_no_addr,
1823 prev_bnr, ip->i_height, strip_h, mp_h);
1824 }
1825 prev_bnr = bh->b_blocknr;
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001826
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001827 if (gfs2_metatype_check(sdp, bh,
1828 (mp_h ? GFS2_METATYPE_IN :
1829 GFS2_METATYPE_DI))) {
1830 ret = -EIO;
1831 goto out;
1832 }
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001833
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001834 /*
1835 * Below, passing end_aligned as 0 gives us the
1836 * metapointer range excluding the end point: the end
1837 * point is the first metapath we must not deallocate!
1838 */
1839
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001840 metapointer_range(&mp, mp_h, start_list, start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001841 end_list, 0 /* end_aligned */,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001842 &start, &end);
1843 ret = sweep_bh_for_rgrps(ip, &rd_gh, mp.mp_bh[mp_h],
1844 start, end,
1845 mp_h != ip->i_height - 1,
1846 &btotal);
1847
Bob Petersond552a2b2017-02-06 08:28:32 -05001848 /* If we hit an error or just swept dinode buffer,
1849 just exit. */
1850 if (ret || !mp_h) {
1851 state = DEALLOC_DONE;
1852 break;
1853 }
1854 state = DEALLOC_MP_LOWER;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001855 break;
Bob Petersond552a2b2017-02-06 08:28:32 -05001856
1857 /* lower the metapath strip height */
1858 case DEALLOC_MP_LOWER:
1859 /* We're done with the current buffer, so release it,
1860 unless it's the dinode buffer. Then back up to the
1861 previous pointer. */
1862 if (mp_h) {
1863 brelse(mp.mp_bh[mp_h]);
1864 mp.mp_bh[mp_h] = NULL;
1865 }
1866 /* If we can't get any lower in height, we've stripped
1867 off all we can. Next step is to back up and start
1868 stripping the previous level of metadata. */
1869 if (mp_h == 0) {
1870 strip_h--;
Andreas Gruenbachercb7f09032017-12-04 16:06:17 +01001871 memcpy(mp.mp_list, start_list, sizeof(start_list));
Bob Petersond552a2b2017-02-06 08:28:32 -05001872 mp_h = strip_h;
1873 state = DEALLOC_FILL_MP;
1874 break;
1875 }
1876 mp.mp_list[mp_h] = 0;
1877 mp_h--; /* search one metadata height down */
Bob Petersond552a2b2017-02-06 08:28:32 -05001878 mp.mp_list[mp_h]++;
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001879 if (walk_done(sdp, &mp, mp_h, end_list, end_aligned))
1880 break;
Bob Petersond552a2b2017-02-06 08:28:32 -05001881 /* Here we've found a part of the metapath that is not
1882 * allocated. We need to search at that height for the
1883 * next non-null pointer. */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001884 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned)) {
Bob Petersond552a2b2017-02-06 08:28:32 -05001885 state = DEALLOC_FILL_MP;
1886 mp_h++;
1887 }
1888 /* No more non-null pointers at this height. Back up
1889 to the previous height and try again. */
1890 break; /* loop around in the same state */
1891
1892 /* Fill the metapath with buffers to the given height. */
1893 case DEALLOC_FILL_MP:
1894 /* Fill the buffers out to the current height. */
1895 ret = fillup_metapath(ip, &mp, mp_h);
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001896 if (ret < 0)
Bob Petersond552a2b2017-02-06 08:28:32 -05001897 goto out;
1898
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001899 /* issue read-ahead on metadata */
1900 if (mp.mp_aheight > 1) {
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001901 for (; ret > 1; ret--) {
1902 metapointer_range(&mp, mp.mp_aheight - ret,
1903 start_list, start_aligned,
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001904 end_list, end_aligned,
Andreas Gruenbacher5cf26b1e2017-12-11 12:49:55 +01001905 &start, &end);
1906 gfs2_metapath_ra(ip->i_gl, start, end);
1907 }
Andreas Gruenbacherc3ce5aa2017-12-08 21:11:39 +01001908 }
1909
Bob Petersond552a2b2017-02-06 08:28:32 -05001910 /* If buffers found for the entire strip height */
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001911 if (mp.mp_aheight - 1 == strip_h) {
Bob Petersond552a2b2017-02-06 08:28:32 -05001912 state = DEALLOC_MP_FULL;
1913 break;
1914 }
Andreas Gruenbachere8b43fe2017-12-08 17:01:57 +01001915 if (mp.mp_aheight < ip->i_height) /* We have a partial height */
1916 mp_h = mp.mp_aheight - 1;
Bob Petersond552a2b2017-02-06 08:28:32 -05001917
1918 /* If we find a non-null block pointer, crawl a bit
1919 higher up in the metapath and try again, otherwise
1920 we need to look lower for a new starting point. */
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01001921 if (find_nonnull_ptr(sdp, &mp, mp_h, end_list, end_aligned))
Bob Petersond552a2b2017-02-06 08:28:32 -05001922 mp_h++;
1923 else
1924 state = DEALLOC_MP_LOWER;
1925 break;
1926 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001927 }
1928
Bob Petersond552a2b2017-02-06 08:28:32 -05001929 if (btotal) {
1930 if (current->journal_info == NULL) {
1931 ret = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS +
1932 RES_QUOTA, 0);
1933 if (ret)
1934 goto out;
1935 down_write(&ip->i_rw_mutex);
1936 }
1937 gfs2_statfs_change(sdp, 0, +btotal, 0);
1938 gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
1939 ip->i_inode.i_gid);
Stephen Rothwellb32c8c72017-05-08 15:59:34 -07001940 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Bob Petersond552a2b2017-02-06 08:28:32 -05001941 gfs2_trans_add_meta(ip->i_gl, dibh);
1942 gfs2_dinode_out(ip, dibh->b_data);
1943 up_write(&ip->i_rw_mutex);
1944 gfs2_trans_end(sdp);
1945 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001946
Bob Petersond552a2b2017-02-06 08:28:32 -05001947out:
1948 if (gfs2_holder_initialized(&rd_gh))
1949 gfs2_glock_dq_uninit(&rd_gh);
1950 if (current->journal_info) {
1951 up_write(&ip->i_rw_mutex);
1952 gfs2_trans_end(sdp);
1953 cond_resched();
1954 }
1955 gfs2_quota_unhold(ip);
1956out_metapath:
1957 release_metapath(&mp);
1958 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001959}
1960
1961static int trunc_end(struct gfs2_inode *ip)
1962{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001963 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001964 struct buffer_head *dibh;
1965 int error;
1966
1967 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1968 if (error)
1969 return error;
1970
1971 down_write(&ip->i_rw_mutex);
1972
1973 error = gfs2_meta_inode_buffer(ip, &dibh);
1974 if (error)
1975 goto out;
1976
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001977 if (!i_size_read(&ip->i_inode)) {
Steven Whitehouseecc30c72008-01-28 10:37:35 +00001978 ip->i_height = 0;
Steven Whitehousece276b02008-02-06 09:25:45 +00001979 ip->i_goal = ip->i_no_addr;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001980 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
Steven Whitehouse45138992013-01-28 09:30:07 +00001981 gfs2_ordered_del_inode(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001982 }
Deepa Dinamani078cd822016-09-14 07:48:04 -07001983 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001984 ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001985
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001986 gfs2_trans_add_meta(ip->i_gl, dibh);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001987 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001988 brelse(dibh);
1989
Steven Whitehousea91ea692006-09-04 12:04:26 -04001990out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001991 up_write(&ip->i_rw_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001992 gfs2_trans_end(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001993 return error;
1994}
1995
1996/**
1997 * do_shrink - make a file smaller
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001998 * @inode: the inode
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01001999 * @newsize: the size to make the file
David Teiglandb3b94fa2006-01-16 16:50:04 +00002000 *
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002001 * Called with an exclusive lock on @inode. The @size must
2002 * be equal to or smaller than the current inode size.
David Teiglandb3b94fa2006-01-16 16:50:04 +00002003 *
2004 * Returns: errno
2005 */
2006
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01002007static int do_shrink(struct inode *inode, u64 newsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002008{
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002009 struct gfs2_inode *ip = GFS2_I(inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002010 int error;
2011
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01002012 error = trunc_start(inode, newsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002013 if (error < 0)
2014 return error;
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002015 if (gfs2_is_stuffed(ip))
David Teiglandb3b94fa2006-01-16 16:50:04 +00002016 return 0;
2017
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01002018 error = punch_hole(ip, newsize, 0);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002019 if (error == 0)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002020 error = trunc_end(ip);
2021
2022 return error;
2023}
2024
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002025void gfs2_trim_blocks(struct inode *inode)
Wendy Chenga13b8c52007-08-20 09:29:53 -04002026{
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002027 int ret;
2028
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01002029 ret = do_shrink(inode, inode->i_size);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002030 WARN_ON(ret != 0);
2031}
2032
2033/**
2034 * do_grow - Touch and update inode size
2035 * @inode: The inode
2036 * @size: The new size
2037 *
2038 * This function updates the timestamps on the inode and
2039 * may also increase the size of the inode. This function
2040 * must not be called with @size any smaller than the current
2041 * inode size.
2042 *
2043 * Although it is not strictly required to unstuff files here,
2044 * earlier versions of GFS2 have a bug in the stuffed file reading
2045 * code which will result in a buffer overrun if the size is larger
2046 * than the max stuffed file size. In order to prevent this from
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002047 * occurring, such files are unstuffed, but in other cases we can
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002048 * just update the inode size directly.
2049 *
2050 * Returns: 0 on success, or -ve on error
2051 */
2052
2053static int do_grow(struct inode *inode, u64 size)
2054{
2055 struct gfs2_inode *ip = GFS2_I(inode);
2056 struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01002057 struct gfs2_alloc_parms ap = { .target = 1, };
Wendy Chenga13b8c52007-08-20 09:29:53 -04002058 struct buffer_head *dibh;
2059 int error;
Bob Peterson2f7ee352012-04-12 09:19:30 -04002060 int unstuff = 0;
Wendy Chenga13b8c52007-08-20 09:29:53 -04002061
Andreas Gruenbacher235628c2017-11-14 16:53:12 +01002062 if (gfs2_is_stuffed(ip) && size > gfs2_max_stuffed_size(ip)) {
Abhi Dasb8fbf472015-03-18 12:03:41 -05002063 error = gfs2_quota_lock_check(ip, &ap);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002064 if (error)
Bob Peterson5407e242012-05-18 09:28:23 -04002065 return error;
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002066
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01002067 error = gfs2_inplace_reserve(ip, &ap);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002068 if (error)
2069 goto do_grow_qunlock;
Bob Peterson2f7ee352012-04-12 09:19:30 -04002070 unstuff = 1;
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002071 }
2072
Bob Petersona01aedf2013-06-27 12:47:51 -04002073 error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT +
2074 (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ?
2075 0 : RES_QUOTA), 0);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002076 if (error)
2077 goto do_grow_release;
2078
Bob Peterson2f7ee352012-04-12 09:19:30 -04002079 if (unstuff) {
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002080 error = gfs2_unstuff_dinode(ip, NULL);
2081 if (error)
2082 goto do_end_trans;
2083 }
Wendy Chenga13b8c52007-08-20 09:29:53 -04002084
2085 error = gfs2_meta_inode_buffer(ip, &dibh);
2086 if (error)
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002087 goto do_end_trans;
Wendy Chenga13b8c52007-08-20 09:29:53 -04002088
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002089 i_size_write(inode, size);
Deepa Dinamani078cd822016-09-14 07:48:04 -07002090 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002091 gfs2_trans_add_meta(ip->i_gl, dibh);
Wendy Chenga13b8c52007-08-20 09:29:53 -04002092 gfs2_dinode_out(ip, dibh->b_data);
2093 brelse(dibh);
2094
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002095do_end_trans:
Wendy Chenga13b8c52007-08-20 09:29:53 -04002096 gfs2_trans_end(sdp);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002097do_grow_release:
Bob Peterson2f7ee352012-04-12 09:19:30 -04002098 if (unstuff) {
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002099 gfs2_inplace_release(ip);
2100do_grow_qunlock:
2101 gfs2_quota_unlock(ip);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002102 }
Wendy Chenga13b8c52007-08-20 09:29:53 -04002103 return error;
2104}
2105
David Teiglandb3b94fa2006-01-16 16:50:04 +00002106/**
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002107 * gfs2_setattr_size - make a file a given size
2108 * @inode: the inode
2109 * @newsize: the size to make the file
David Teiglandb3b94fa2006-01-16 16:50:04 +00002110 *
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002111 * The file size can grow, shrink, or stay the same size. This
Bob Peterson3e7aafc2018-04-06 13:07:45 -07002112 * is called holding i_rwsem and an exclusive glock on the inode
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002113 * in question.
David Teiglandb3b94fa2006-01-16 16:50:04 +00002114 *
2115 * Returns: errno
2116 */
2117
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002118int gfs2_setattr_size(struct inode *inode, u64 newsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002119{
Steven Whitehouseaf5c2692013-09-27 12:49:33 +01002120 struct gfs2_inode *ip = GFS2_I(inode);
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002121 int ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002122
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002123 BUG_ON(!S_ISREG(inode->i_mode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00002124
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002125 ret = inode_newsize_ok(inode, newsize);
2126 if (ret)
2127 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002128
Christoph Hellwig562c72aa52011-06-24 14:29:45 -04002129 inode_dio_wait(inode);
2130
Bob Petersonb54e9a02015-10-26 10:40:28 -05002131 ret = gfs2_rsqa_alloc(ip);
Bob Petersond2b47cf2013-02-01 12:03:02 -05002132 if (ret)
Bob Peterson2b3dcf32013-05-28 10:04:44 -04002133 goto out;
Bob Petersond2b47cf2013-02-01 12:03:02 -05002134
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01002135 if (newsize >= inode->i_size) {
Bob Peterson2b3dcf32013-05-28 10:04:44 -04002136 ret = do_grow(inode, newsize);
2137 goto out;
2138 }
Steven Whitehouseff8f33c2010-08-11 09:37:53 +01002139
Andreas Gruenbacher8b5860a2017-12-12 20:49:05 +01002140 ret = do_shrink(inode, newsize);
Bob Peterson2b3dcf32013-05-28 10:04:44 -04002141out:
Bob Petersona097dc7e2015-07-16 08:28:04 -05002142 gfs2_rsqa_delete(ip, NULL);
Bob Peterson2b3dcf32013-05-28 10:04:44 -04002143 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002144}
2145
2146int gfs2_truncatei_resume(struct gfs2_inode *ip)
2147{
2148 int error;
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01002149 error = punch_hole(ip, i_size_read(&ip->i_inode), 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002150 if (!error)
2151 error = trunc_end(ip);
2152 return error;
2153}
2154
2155int gfs2_file_dealloc(struct gfs2_inode *ip)
2156{
Andreas Gruenbacher10d2cf92017-12-19 00:06:44 +01002157 return punch_hole(ip, 0, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002158}
2159
2160/**
Steven Whitehouseb50f2272014-03-03 13:35:57 +00002161 * gfs2_free_journal_extents - Free cached journal bmap info
2162 * @jd: The journal
2163 *
2164 */
2165
2166void gfs2_free_journal_extents(struct gfs2_jdesc *jd)
2167{
2168 struct gfs2_journal_extent *jext;
2169
2170 while(!list_empty(&jd->extent_list)) {
2171 jext = list_entry(jd->extent_list.next, struct gfs2_journal_extent, list);
2172 list_del(&jext->list);
2173 kfree(jext);
2174 }
2175}
2176
2177/**
2178 * gfs2_add_jextent - Add or merge a new extent to extent cache
2179 * @jd: The journal descriptor
2180 * @lblock: The logical block at start of new extent
Fabian Frederickc62baf62014-05-14 18:32:31 +02002181 * @dblock: The physical block at start of new extent
Steven Whitehouseb50f2272014-03-03 13:35:57 +00002182 * @blocks: Size of extent in fs blocks
2183 *
2184 * Returns: 0 on success or -ENOMEM
2185 */
2186
2187static int gfs2_add_jextent(struct gfs2_jdesc *jd, u64 lblock, u64 dblock, u64 blocks)
2188{
2189 struct gfs2_journal_extent *jext;
2190
2191 if (!list_empty(&jd->extent_list)) {
2192 jext = list_entry(jd->extent_list.prev, struct gfs2_journal_extent, list);
2193 if ((jext->dblock + jext->blocks) == dblock) {
2194 jext->blocks += blocks;
2195 return 0;
2196 }
2197 }
2198
2199 jext = kzalloc(sizeof(struct gfs2_journal_extent), GFP_NOFS);
2200 if (jext == NULL)
2201 return -ENOMEM;
2202 jext->dblock = dblock;
2203 jext->lblock = lblock;
2204 jext->blocks = blocks;
2205 list_add_tail(&jext->list, &jd->extent_list);
2206 jd->nr_extents++;
2207 return 0;
2208}
2209
2210/**
2211 * gfs2_map_journal_extents - Cache journal bmap info
2212 * @sdp: The super block
2213 * @jd: The journal to map
2214 *
2215 * Create a reusable "extent" mapping from all logical
2216 * blocks to all physical blocks for the given journal. This will save
2217 * us time when writing journal blocks. Most journals will have only one
2218 * extent that maps all their logical blocks. That's because gfs2.mkfs
2219 * arranges the journal blocks sequentially to maximize performance.
2220 * So the extent would map the first block for the entire file length.
2221 * However, gfs2_jadd can happen while file activity is happening, so
2222 * those journals may not be sequential. Less likely is the case where
2223 * the users created their own journals by mounting the metafs and
2224 * laying it out. But it's still possible. These journals might have
2225 * several extents.
2226 *
2227 * Returns: 0 on success, or error on failure
2228 */
2229
2230int gfs2_map_journal_extents(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
2231{
2232 u64 lblock = 0;
2233 u64 lblock_stop;
2234 struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
2235 struct buffer_head bh;
2236 unsigned int shift = sdp->sd_sb.sb_bsize_shift;
2237 u64 size;
2238 int rc;
2239
2240 lblock_stop = i_size_read(jd->jd_inode) >> shift;
2241 size = (lblock_stop - lblock) << shift;
2242 jd->nr_extents = 0;
2243 WARN_ON(!list_empty(&jd->extent_list));
2244
2245 do {
2246 bh.b_state = 0;
2247 bh.b_blocknr = 0;
2248 bh.b_size = size;
2249 rc = gfs2_block_map(jd->jd_inode, lblock, &bh, 0);
2250 if (rc || !buffer_mapped(&bh))
2251 goto fail;
2252 rc = gfs2_add_jextent(jd, lblock, bh.b_blocknr, bh.b_size >> shift);
2253 if (rc)
2254 goto fail;
2255 size -= bh.b_size;
2256 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
2257 } while(size > 0);
2258
2259 fs_info(sdp, "journal %d mapped with %u extents\n", jd->jd_jid,
2260 jd->nr_extents);
2261 return 0;
2262
2263fail:
2264 fs_warn(sdp, "error %d mapping journal %u at offset %llu (extent %u)\n",
2265 rc, jd->jd_jid,
2266 (unsigned long long)(i_size_read(jd->jd_inode) - size),
2267 jd->nr_extents);
2268 fs_warn(sdp, "bmap=%d lblock=%llu block=%llu, state=0x%08lx, size=%llu\n",
2269 rc, (unsigned long long)lblock, (unsigned long long)bh.b_blocknr,
2270 bh.b_state, (unsigned long long)bh.b_size);
2271 gfs2_free_journal_extents(jd);
2272 return rc;
2273}
2274
2275/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00002276 * gfs2_write_alloc_required - figure out if a write will require an allocation
2277 * @ip: the file being written to
2278 * @offset: the offset to write to
2279 * @len: the number of bytes being written
David Teiglandb3b94fa2006-01-16 16:50:04 +00002280 *
Bob Peterson461cb412010-06-24 19:21:20 -04002281 * Returns: 1 if an alloc is required, 0 otherwise
David Teiglandb3b94fa2006-01-16 16:50:04 +00002282 */
2283
Steven Whitehousecd915492006-09-04 12:49:07 -04002284int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
Bob Peterson461cb412010-06-24 19:21:20 -04002285 unsigned int len)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002286{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002287 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse941e6d72008-01-28 08:47:38 +00002288 struct buffer_head bh;
2289 unsigned int shift;
2290 u64 lblock, lblock_stop, size;
Steven Whitehouse7ed122e2008-12-10 10:28:10 +00002291 u64 end_of_file;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002292
David Teiglandb3b94fa2006-01-16 16:50:04 +00002293 if (!len)
2294 return 0;
2295
2296 if (gfs2_is_stuffed(ip)) {
Andreas Gruenbacher235628c2017-11-14 16:53:12 +01002297 if (offset + len > gfs2_max_stuffed_size(ip))
Bob Peterson461cb412010-06-24 19:21:20 -04002298 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002299 return 0;
2300 }
2301
Steven Whitehouse941e6d72008-01-28 08:47:38 +00002302 shift = sdp->sd_sb.sb_bsize_shift;
Steven Whitehouse7ed122e2008-12-10 10:28:10 +00002303 BUG_ON(gfs2_is_dir(ip));
Steven Whitehousea2e0f792010-08-11 09:53:11 +01002304 end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
Steven Whitehouse7ed122e2008-12-10 10:28:10 +00002305 lblock = offset >> shift;
2306 lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
2307 if (lblock_stop > end_of_file)
Bob Peterson461cb412010-06-24 19:21:20 -04002308 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002309
Steven Whitehouse941e6d72008-01-28 08:47:38 +00002310 size = (lblock_stop - lblock) << shift;
2311 do {
2312 bh.b_state = 0;
2313 bh.b_size = size;
2314 gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
2315 if (!buffer_mapped(&bh))
Bob Peterson461cb412010-06-24 19:21:20 -04002316 return 1;
Steven Whitehouse941e6d72008-01-28 08:47:38 +00002317 size -= bh.b_size;
2318 lblock += (bh.b_size >> ip->i_inode.i_blkbits);
2319 } while(size > 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002320
2321 return 0;
2322}
2323
Andreas Gruenbacher4e56a642017-12-14 17:11:03 +01002324static int stuffed_zero_range(struct inode *inode, loff_t offset, loff_t length)
2325{
2326 struct gfs2_inode *ip = GFS2_I(inode);
2327 struct buffer_head *dibh;
2328 int error;
2329
2330 if (offset >= inode->i_size)
2331 return 0;
2332 if (offset + length > inode->i_size)
2333 length = inode->i_size - offset;
2334
2335 error = gfs2_meta_inode_buffer(ip, &dibh);
2336 if (error)
2337 return error;
2338 gfs2_trans_add_meta(ip->i_gl, dibh);
2339 memset(dibh->b_data + sizeof(struct gfs2_dinode) + offset, 0,
2340 length);
2341 brelse(dibh);
2342 return 0;
2343}
2344
2345static int gfs2_journaled_truncate_range(struct inode *inode, loff_t offset,
2346 loff_t length)
2347{
2348 struct gfs2_sbd *sdp = GFS2_SB(inode);
2349 loff_t max_chunk = GFS2_JTRUNC_REVOKES * sdp->sd_vfs->s_blocksize;
2350 int error;
2351
2352 while (length) {
2353 struct gfs2_trans *tr;
2354 loff_t chunk;
2355 unsigned int offs;
2356
2357 chunk = length;
2358 if (chunk > max_chunk)
2359 chunk = max_chunk;
2360
2361 offs = offset & ~PAGE_MASK;
2362 if (offs && chunk > PAGE_SIZE)
2363 chunk = offs + ((chunk - offs) & PAGE_MASK);
2364
2365 truncate_pagecache_range(inode, offset, chunk);
2366 offset += chunk;
2367 length -= chunk;
2368
2369 tr = current->journal_info;
2370 if (!test_bit(TR_TOUCHED, &tr->tr_flags))
2371 continue;
2372
2373 gfs2_trans_end(sdp);
2374 error = gfs2_trans_begin(sdp, RES_DINODE, GFS2_JTRUNC_REVOKES);
2375 if (error)
2376 return error;
2377 }
2378 return 0;
2379}
2380
2381int __gfs2_punch_hole(struct file *file, loff_t offset, loff_t length)
2382{
2383 struct inode *inode = file_inode(file);
2384 struct gfs2_inode *ip = GFS2_I(inode);
2385 struct gfs2_sbd *sdp = GFS2_SB(inode);
2386 int error;
2387
2388 if (gfs2_is_jdata(ip))
2389 error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_JDATA,
2390 GFS2_JTRUNC_REVOKES);
2391 else
2392 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
2393 if (error)
2394 return error;
2395
2396 if (gfs2_is_stuffed(ip)) {
2397 error = stuffed_zero_range(inode, offset, length);
2398 if (error)
2399 goto out;
2400 } else {
2401 unsigned int start_off, end_off, blocksize;
2402
2403 blocksize = i_blocksize(inode);
2404 start_off = offset & (blocksize - 1);
2405 end_off = (offset + length) & (blocksize - 1);
2406 if (start_off) {
2407 unsigned int len = length;
2408 if (length > blocksize - start_off)
2409 len = blocksize - start_off;
2410 error = gfs2_block_zero_range(inode, offset, len);
2411 if (error)
2412 goto out;
2413 if (start_off + length < blocksize)
2414 end_off = 0;
2415 }
2416 if (end_off) {
2417 error = gfs2_block_zero_range(inode,
2418 offset + length - end_off, end_off);
2419 if (error)
2420 goto out;
2421 }
2422 }
2423
2424 if (gfs2_is_jdata(ip)) {
2425 BUG_ON(!current->journal_info);
2426 gfs2_journaled_truncate_range(inode, offset, length);
2427 } else
2428 truncate_pagecache_range(inode, offset, offset + length - 1);
2429
2430 file_update_time(file);
2431 mark_inode_dirty(inode);
2432
2433 if (current->journal_info)
2434 gfs2_trans_end(sdp);
2435
2436 if (!gfs2_is_stuffed(ip))
2437 error = punch_hole(ip, offset, length);
2438
2439out:
2440 if (current->journal_info)
2441 gfs2_trans_end(sdp);
2442 return error;
2443}