blob: 7a34a1ae655246e6e07fb0b71fabb3bac4c1b6c2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scottf07c2252006-09-28 10:52:15 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Vlad Apostolov93c189c2006-11-11 18:03:49 +110018#include "xfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/stddef.h>
20#include <linux/errno.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/gfp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/pagemap.h>
23#include <linux/init.h>
24#include <linux/vmalloc.h>
25#include <linux/bio.h>
26#include <linux/sysctl.h>
27#include <linux/proc_fs.h>
28#include <linux/workqueue.h>
29#include <linux/percpu.h>
30#include <linux/blkdev.h>
31#include <linux/hash.h>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100032#include <linux/kthread.h>
Christoph Lameterb20a3502006-03-22 00:09:12 -080033#include <linux/migrate.h>
Andrew Morton3fcfab12006-10-19 23:28:16 -070034#include <linux/backing-dev.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080035#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Dave Chinner239880e2013-10-23 10:50:10 +110037#include "xfs_log_format.h"
Dave Chinner7fd36c42013-08-12 20:49:32 +100038#include "xfs_trans_resv.h"
Dave Chinner239880e2013-10-23 10:50:10 +110039#include "xfs_sb.h"
Christoph Hellwigb7963132009-03-03 14:48:37 -050040#include "xfs_ag.h"
Christoph Hellwigb7963132009-03-03 14:48:37 -050041#include "xfs_mount.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000042#include "xfs_trace.h"
Dave Chinner239880e2013-10-23 10:50:10 +110043#include "xfs_log.h"
Christoph Hellwigb7963132009-03-03 14:48:37 -050044
David Chinner7989cb82007-02-10 18:34:56 +110045static kmem_zone_t *xfs_buf_zone;
Christoph Hellwig23ea4032005-06-21 15:14:01 +100046
David Chinner7989cb82007-02-10 18:34:56 +110047static struct workqueue_struct *xfslogd_workqueue;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Nathan Scottce8e9222006-01-11 15:39:08 +110049#ifdef XFS_BUF_LOCK_TRACKING
50# define XB_SET_OWNER(bp) ((bp)->b_last_holder = current->pid)
51# define XB_CLEAR_OWNER(bp) ((bp)->b_last_holder = -1)
52# define XB_GET_OWNER(bp) ((bp)->b_last_holder)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#else
Nathan Scottce8e9222006-01-11 15:39:08 +110054# define XB_SET_OWNER(bp) do { } while (0)
55# define XB_CLEAR_OWNER(bp) do { } while (0)
56# define XB_GET_OWNER(bp) do { } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#endif
58
Nathan Scottce8e9222006-01-11 15:39:08 +110059#define xb_to_gfp(flags) \
Dave Chinneraa5c1582012-04-23 15:58:56 +100060 ((((flags) & XBF_READ_AHEAD) ? __GFP_NORETRY : GFP_NOFS) | __GFP_NOWARN)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
James Bottomley73c77e22010-01-25 11:42:24 -060063static inline int
64xfs_buf_is_vmapped(
65 struct xfs_buf *bp)
66{
67 /*
68 * Return true if the buffer is vmapped.
69 *
Dave Chinner611c9942012-04-23 15:59:07 +100070 * b_addr is null if the buffer is not mapped, but the code is clever
71 * enough to know it doesn't have to map a single page, so the check has
72 * to be both for b_addr and bp->b_page_count > 1.
James Bottomley73c77e22010-01-25 11:42:24 -060073 */
Dave Chinner611c9942012-04-23 15:59:07 +100074 return bp->b_addr && bp->b_page_count > 1;
James Bottomley73c77e22010-01-25 11:42:24 -060075}
76
77static inline int
78xfs_buf_vmap_len(
79 struct xfs_buf *bp)
80{
81 return (bp->b_page_count * PAGE_SIZE) - bp->b_offset;
82}
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084/*
Dave Chinner430cbeb2010-12-02 16:30:55 +110085 * When we mark a buffer stale, we remove the buffer from the LRU and clear the
86 * b_lru_ref count so that the buffer is freed immediately when the buffer
87 * reference count falls to zero. If the buffer is already on the LRU, we need
88 * to remove the reference that LRU holds on the buffer.
89 *
90 * This prevents build-up of stale buffers on the LRU.
91 */
92void
93xfs_buf_stale(
94 struct xfs_buf *bp)
95{
Christoph Hellwig43ff2122012-04-23 15:58:39 +100096 ASSERT(xfs_buf_islocked(bp));
97
Dave Chinner430cbeb2010-12-02 16:30:55 +110098 bp->b_flags |= XBF_STALE;
Christoph Hellwig43ff2122012-04-23 15:58:39 +100099
100 /*
101 * Clear the delwri status so that a delwri queue walker will not
102 * flush this buffer to disk now that it is stale. The delwri queue has
103 * a reference to the buffer, so this is safe to do.
104 */
105 bp->b_flags &= ~_XBF_DELWRI_Q;
106
Dave Chinnera4082352013-08-28 10:18:06 +1000107 spin_lock(&bp->b_lock);
108 atomic_set(&bp->b_lru_ref, 0);
109 if (!(bp->b_state & XFS_BSTATE_DISPOSE) &&
Dave Chinnere80dfa12013-08-28 10:18:05 +1000110 (list_lru_del(&bp->b_target->bt_lru, &bp->b_lru)))
111 atomic_dec(&bp->b_hold);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100112
Dave Chinner430cbeb2010-12-02 16:30:55 +1100113 ASSERT(atomic_read(&bp->b_hold) >= 1);
Dave Chinnera4082352013-08-28 10:18:06 +1000114 spin_unlock(&bp->b_lock);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100115}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
Dave Chinner3e85c862012-06-22 18:50:09 +1000117static int
118xfs_buf_get_maps(
119 struct xfs_buf *bp,
120 int map_count)
121{
122 ASSERT(bp->b_maps == NULL);
123 bp->b_map_count = map_count;
124
125 if (map_count == 1) {
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600126 bp->b_maps = &bp->__b_map;
Dave Chinner3e85c862012-06-22 18:50:09 +1000127 return 0;
128 }
129
130 bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
131 KM_NOFS);
132 if (!bp->b_maps)
133 return ENOMEM;
134 return 0;
135}
136
137/*
138 * Frees b_pages if it was allocated.
139 */
140static void
141xfs_buf_free_maps(
142 struct xfs_buf *bp)
143{
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600144 if (bp->b_maps != &bp->__b_map) {
Dave Chinner3e85c862012-06-22 18:50:09 +1000145 kmem_free(bp->b_maps);
146 bp->b_maps = NULL;
147 }
148}
149
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000150struct xfs_buf *
Dave Chinner3e85c862012-06-22 18:50:09 +1000151_xfs_buf_alloc(
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000152 struct xfs_buftarg *target,
Dave Chinner3e85c862012-06-22 18:50:09 +1000153 struct xfs_buf_map *map,
154 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100155 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156{
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000157 struct xfs_buf *bp;
Dave Chinner3e85c862012-06-22 18:50:09 +1000158 int error;
159 int i;
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000160
Dave Chinneraa5c1582012-04-23 15:58:56 +1000161 bp = kmem_zone_zalloc(xfs_buf_zone, KM_NOFS);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000162 if (unlikely(!bp))
163 return NULL;
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 /*
Dave Chinner12bcb3f2012-04-23 15:59:05 +1000166 * We don't want certain flags to appear in b_flags unless they are
167 * specifically set by later operations on the buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 */
Dave Chinner611c9942012-04-23 15:59:07 +1000169 flags &= ~(XBF_UNMAPPED | XBF_TRYLOCK | XBF_ASYNC | XBF_READ_AHEAD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Nathan Scottce8e9222006-01-11 15:39:08 +1100171 atomic_set(&bp->b_hold, 1);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100172 atomic_set(&bp->b_lru_ref, 1);
David Chinnerb4dd3302008-08-13 16:36:11 +1000173 init_completion(&bp->b_iowait);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100174 INIT_LIST_HEAD(&bp->b_lru);
Nathan Scottce8e9222006-01-11 15:39:08 +1100175 INIT_LIST_HEAD(&bp->b_list);
Dave Chinner74f75a02010-09-24 19:59:04 +1000176 RB_CLEAR_NODE(&bp->b_rbnode);
Thomas Gleixnera731cd12010-09-07 14:33:15 +0000177 sema_init(&bp->b_sema, 0); /* held, no waiters */
Dave Chinnera4082352013-08-28 10:18:06 +1000178 spin_lock_init(&bp->b_lock);
Nathan Scottce8e9222006-01-11 15:39:08 +1100179 XB_SET_OWNER(bp);
180 bp->b_target = target;
Dave Chinner3e85c862012-06-22 18:50:09 +1000181 bp->b_flags = flags;
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000182
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 /*
Dave Chinneraa0e8832012-04-23 15:58:52 +1000184 * Set length and io_length to the same value initially.
185 * I/O routines should use io_length, which will be the same in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 * most cases but may be reset (e.g. XFS recovery).
187 */
Dave Chinner3e85c862012-06-22 18:50:09 +1000188 error = xfs_buf_get_maps(bp, nmaps);
189 if (error) {
190 kmem_zone_free(xfs_buf_zone, bp);
191 return NULL;
192 }
193
194 bp->b_bn = map[0].bm_bn;
195 bp->b_length = 0;
196 for (i = 0; i < nmaps; i++) {
197 bp->b_maps[i].bm_bn = map[i].bm_bn;
198 bp->b_maps[i].bm_len = map[i].bm_len;
199 bp->b_length += map[i].bm_len;
200 }
201 bp->b_io_length = bp->b_length;
202
Nathan Scottce8e9222006-01-11 15:39:08 +1100203 atomic_set(&bp->b_pin_count, 0);
204 init_waitqueue_head(&bp->b_waiters);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Nathan Scottce8e9222006-01-11 15:39:08 +1100206 XFS_STATS_INC(xb_create);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000207 trace_xfs_buf_init(bp, _RET_IP_);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000208
209 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
211
212/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100213 * Allocate a page array capable of holding a specified number
214 * of pages, and point the page buf at it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 */
216STATIC int
Nathan Scottce8e9222006-01-11 15:39:08 +1100217_xfs_buf_get_pages(
218 xfs_buf_t *bp,
Eric Sandeen87937bf2014-04-14 19:01:20 +1000219 int page_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220{
221 /* Make sure that we have a page list */
Nathan Scottce8e9222006-01-11 15:39:08 +1100222 if (bp->b_pages == NULL) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100223 bp->b_page_count = page_count;
224 if (page_count <= XB_PAGES) {
225 bp->b_pages = bp->b_page_array;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 } else {
Nathan Scottce8e9222006-01-11 15:39:08 +1100227 bp->b_pages = kmem_alloc(sizeof(struct page *) *
Dave Chinneraa5c1582012-04-23 15:58:56 +1000228 page_count, KM_NOFS);
Nathan Scottce8e9222006-01-11 15:39:08 +1100229 if (bp->b_pages == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return -ENOMEM;
231 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100232 memset(bp->b_pages, 0, sizeof(struct page *) * page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 }
234 return 0;
235}
236
237/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100238 * Frees b_pages if it was allocated.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 */
240STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +1100241_xfs_buf_free_pages(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 xfs_buf_t *bp)
243{
Nathan Scottce8e9222006-01-11 15:39:08 +1100244 if (bp->b_pages != bp->b_page_array) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000245 kmem_free(bp->b_pages);
Dave Chinner3fc98b12009-12-14 23:11:57 +0000246 bp->b_pages = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 }
248}
249
250/*
251 * Releases the specified buffer.
252 *
253 * The modification state of any associated pages is left unchanged.
Zhi Yong Wub46fe822013-08-07 10:10:59 +0000254 * The buffer must not be on any hash - use xfs_buf_rele instead for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 * hashed and refcounted buffers
256 */
257void
Nathan Scottce8e9222006-01-11 15:39:08 +1100258xfs_buf_free(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 xfs_buf_t *bp)
260{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000261 trace_xfs_buf_free(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Dave Chinner430cbeb2010-12-02 16:30:55 +1100263 ASSERT(list_empty(&bp->b_lru));
264
Dave Chinner0e6e8472011-03-26 09:16:45 +1100265 if (bp->b_flags & _XBF_PAGES) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 uint i;
267
James Bottomley73c77e22010-01-25 11:42:24 -0600268 if (xfs_buf_is_vmapped(bp))
Alex Elder8a262e52010-03-16 18:55:56 +0000269 vm_unmap_ram(bp->b_addr - bp->b_offset,
270 bp->b_page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Nathan Scott948ecdb2006-09-28 11:03:13 +1000272 for (i = 0; i < bp->b_page_count; i++) {
273 struct page *page = bp->b_pages[i];
274
Dave Chinner0e6e8472011-03-26 09:16:45 +1100275 __free_page(page);
Nathan Scott948ecdb2006-09-28 11:03:13 +1000276 }
Dave Chinner0e6e8472011-03-26 09:16:45 +1100277 } else if (bp->b_flags & _XBF_KMEM)
278 kmem_free(bp->b_addr);
Dave Chinner3fc98b12009-12-14 23:11:57 +0000279 _xfs_buf_free_pages(bp);
Dave Chinner3e85c862012-06-22 18:50:09 +1000280 xfs_buf_free_maps(bp);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000281 kmem_zone_free(xfs_buf_zone, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282}
283
284/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100285 * Allocates all the pages for buffer in question and builds it's page list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 */
287STATIC int
Dave Chinner0e6e8472011-03-26 09:16:45 +1100288xfs_buf_allocate_memory(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 xfs_buf_t *bp,
290 uint flags)
291{
Dave Chinneraa0e8832012-04-23 15:58:52 +1000292 size_t size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 size_t nbytes, offset;
Nathan Scottce8e9222006-01-11 15:39:08 +1100294 gfp_t gfp_mask = xb_to_gfp(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 unsigned short page_count, i;
Dave Chinner795cac72012-04-23 15:58:53 +1000296 xfs_off_t start, end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 int error;
298
Dave Chinner0e6e8472011-03-26 09:16:45 +1100299 /*
300 * for buffers that are contained within a single page, just allocate
301 * the memory from the heap - there's no need for the complexity of
302 * page arrays to keep allocation down to order 0.
303 */
Dave Chinner795cac72012-04-23 15:58:53 +1000304 size = BBTOB(bp->b_length);
305 if (size < PAGE_SIZE) {
Dave Chinneraa5c1582012-04-23 15:58:56 +1000306 bp->b_addr = kmem_alloc(size, KM_NOFS);
Dave Chinner0e6e8472011-03-26 09:16:45 +1100307 if (!bp->b_addr) {
308 /* low memory - use alloc_page loop instead */
309 goto use_alloc_page;
310 }
311
Dave Chinner795cac72012-04-23 15:58:53 +1000312 if (((unsigned long)(bp->b_addr + size - 1) & PAGE_MASK) !=
Dave Chinner0e6e8472011-03-26 09:16:45 +1100313 ((unsigned long)bp->b_addr & PAGE_MASK)) {
314 /* b_addr spans two pages - use alloc_page instead */
315 kmem_free(bp->b_addr);
316 bp->b_addr = NULL;
317 goto use_alloc_page;
318 }
319 bp->b_offset = offset_in_page(bp->b_addr);
320 bp->b_pages = bp->b_page_array;
321 bp->b_pages[0] = virt_to_page(bp->b_addr);
322 bp->b_page_count = 1;
Dave Chinner611c9942012-04-23 15:59:07 +1000323 bp->b_flags |= _XBF_KMEM;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100324 return 0;
325 }
326
327use_alloc_page:
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600328 start = BBTOB(bp->b_maps[0].bm_bn) >> PAGE_SHIFT;
329 end = (BBTOB(bp->b_maps[0].bm_bn + bp->b_length) + PAGE_SIZE - 1)
Dave Chinnercbb7baab2012-06-22 18:50:08 +1000330 >> PAGE_SHIFT;
Dave Chinner795cac72012-04-23 15:58:53 +1000331 page_count = end - start;
Eric Sandeen87937bf2014-04-14 19:01:20 +1000332 error = _xfs_buf_get_pages(bp, page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 if (unlikely(error))
334 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
Nathan Scottce8e9222006-01-11 15:39:08 +1100336 offset = bp->b_offset;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100337 bp->b_flags |= _XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Nathan Scottce8e9222006-01-11 15:39:08 +1100339 for (i = 0; i < bp->b_page_count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 struct page *page;
341 uint retries = 0;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100342retry:
343 page = alloc_page(gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (unlikely(page == NULL)) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100345 if (flags & XBF_READ_AHEAD) {
346 bp->b_page_count = i;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100347 error = ENOMEM;
348 goto out_free_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 }
350
351 /*
352 * This could deadlock.
353 *
354 * But until all the XFS lowlevel code is revamped to
355 * handle buffer allocation failures we can't do much.
356 */
357 if (!(++retries % 100))
Dave Chinner4f107002011-03-07 10:00:35 +1100358 xfs_err(NULL,
359 "possible memory allocation deadlock in %s (mode:0x%x)",
Harvey Harrison34a622b2008-04-10 12:19:21 +1000360 __func__, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Nathan Scottce8e9222006-01-11 15:39:08 +1100362 XFS_STATS_INC(xb_page_retries);
Jens Axboe8aa7e842009-07-09 14:52:32 +0200363 congestion_wait(BLK_RW_ASYNC, HZ/50);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 goto retry;
365 }
366
Nathan Scottce8e9222006-01-11 15:39:08 +1100367 XFS_STATS_INC(xb_page_found);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Dave Chinner0e6e8472011-03-26 09:16:45 +1100369 nbytes = min_t(size_t, size, PAGE_SIZE - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 size -= nbytes;
Nathan Scottce8e9222006-01-11 15:39:08 +1100371 bp->b_pages[i] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 offset = 0;
373 }
Dave Chinner0e6e8472011-03-26 09:16:45 +1100374 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Dave Chinner0e6e8472011-03-26 09:16:45 +1100376out_free_pages:
377 for (i = 0; i < bp->b_page_count; i++)
378 __free_page(bp->b_pages[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 return error;
380}
381
382/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300383 * Map buffer into kernel address-space if necessary.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 */
385STATIC int
Nathan Scottce8e9222006-01-11 15:39:08 +1100386_xfs_buf_map_pages(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 xfs_buf_t *bp,
388 uint flags)
389{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100390 ASSERT(bp->b_flags & _XBF_PAGES);
Nathan Scottce8e9222006-01-11 15:39:08 +1100391 if (bp->b_page_count == 1) {
Dave Chinner0e6e8472011-03-26 09:16:45 +1100392 /* A single page buffer is always mappable */
Nathan Scottce8e9222006-01-11 15:39:08 +1100393 bp->b_addr = page_address(bp->b_pages[0]) + bp->b_offset;
Dave Chinner611c9942012-04-23 15:59:07 +1000394 } else if (flags & XBF_UNMAPPED) {
395 bp->b_addr = NULL;
396 } else {
Dave Chinnera19fb382011-03-26 09:13:42 +1100397 int retried = 0;
Dave Chinnerae687e52014-03-07 16:19:14 +1100398 unsigned noio_flag;
Dave Chinnera19fb382011-03-26 09:13:42 +1100399
Dave Chinnerae687e52014-03-07 16:19:14 +1100400 /*
401 * vm_map_ram() will allocate auxillary structures (e.g.
402 * pagetables) with GFP_KERNEL, yet we are likely to be under
403 * GFP_NOFS context here. Hence we need to tell memory reclaim
404 * that we are in such a context via PF_MEMALLOC_NOIO to prevent
405 * memory reclaim re-entering the filesystem here and
406 * potentially deadlocking.
407 */
408 noio_flag = memalloc_noio_save();
Dave Chinnera19fb382011-03-26 09:13:42 +1100409 do {
410 bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
411 -1, PAGE_KERNEL);
412 if (bp->b_addr)
413 break;
414 vm_unmap_aliases();
415 } while (retried++ <= 1);
Dave Chinnerae687e52014-03-07 16:19:14 +1100416 memalloc_noio_restore(noio_flag);
Dave Chinnera19fb382011-03-26 09:13:42 +1100417
418 if (!bp->b_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 return -ENOMEM;
Nathan Scottce8e9222006-01-11 15:39:08 +1100420 bp->b_addr += bp->b_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
422
423 return 0;
424}
425
426/*
427 * Finding and Reading Buffers
428 */
429
430/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100431 * Look up, and creates if absent, a lockable buffer for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 * a given range of an inode. The buffer is returned
Chandra Seetharamaneabbaf12011-09-08 20:18:50 +0000433 * locked. No I/O is implied by this call.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 */
435xfs_buf_t *
Nathan Scottce8e9222006-01-11 15:39:08 +1100436_xfs_buf_find(
Dave Chinnere70b73f2012-04-23 15:58:49 +1000437 struct xfs_buftarg *btp,
Dave Chinner3e85c862012-06-22 18:50:09 +1000438 struct xfs_buf_map *map,
439 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100440 xfs_buf_flags_t flags,
441 xfs_buf_t *new_bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
Dave Chinnere70b73f2012-04-23 15:58:49 +1000443 size_t numbytes;
Dave Chinner74f75a02010-09-24 19:59:04 +1000444 struct xfs_perag *pag;
445 struct rb_node **rbp;
446 struct rb_node *parent;
447 xfs_buf_t *bp;
Dave Chinner3e85c862012-06-22 18:50:09 +1000448 xfs_daddr_t blkno = map[0].bm_bn;
Dave Chinner10616b82013-01-21 23:53:52 +1100449 xfs_daddr_t eofs;
Dave Chinner3e85c862012-06-22 18:50:09 +1000450 int numblks = 0;
451 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Dave Chinner3e85c862012-06-22 18:50:09 +1000453 for (i = 0; i < nmaps; i++)
454 numblks += map[i].bm_len;
Dave Chinnere70b73f2012-04-23 15:58:49 +1000455 numbytes = BBTOB(numblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457 /* Check for IOs smaller than the sector size / not sector aligned */
Eric Sandeen6da54172014-01-21 16:45:52 -0600458 ASSERT(!(numbytes < btp->bt_meta_sectorsize));
459 ASSERT(!(BBTOB(blkno) & (xfs_off_t)btp->bt_meta_sectormask));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Dave Chinner10616b82013-01-21 23:53:52 +1100461 /*
462 * Corrupted block numbers can get through to here, unfortunately, so we
463 * have to check that the buffer falls within the filesystem bounds.
464 */
465 eofs = XFS_FSB_TO_BB(btp->bt_mount, btp->bt_mount->m_sb.sb_dblocks);
466 if (blkno >= eofs) {
467 /*
468 * XXX (dgc): we should really be returning EFSCORRUPTED here,
469 * but none of the higher level infrastructure supports
470 * returning a specific error on buffer lookup failures.
471 */
472 xfs_alert(btp->bt_mount,
473 "%s: Block out of range: block 0x%llx, EOFS 0x%llx ",
474 __func__, blkno, eofs);
Dave Chinner7bc0dc22013-05-21 18:02:08 +1000475 WARN_ON(1);
Dave Chinner10616b82013-01-21 23:53:52 +1100476 return NULL;
477 }
478
Dave Chinner74f75a02010-09-24 19:59:04 +1000479 /* get tree root */
480 pag = xfs_perag_get(btp->bt_mount,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000481 xfs_daddr_to_agno(btp->bt_mount, blkno));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Dave Chinner74f75a02010-09-24 19:59:04 +1000483 /* walk tree */
484 spin_lock(&pag->pag_buf_lock);
485 rbp = &pag->pag_buf_tree.rb_node;
486 parent = NULL;
487 bp = NULL;
488 while (*rbp) {
489 parent = *rbp;
490 bp = rb_entry(parent, struct xfs_buf, b_rbnode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000492 if (blkno < bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000493 rbp = &(*rbp)->rb_left;
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000494 else if (blkno > bp->b_bn)
Dave Chinner74f75a02010-09-24 19:59:04 +1000495 rbp = &(*rbp)->rb_right;
496 else {
497 /*
Dave Chinnerde1cbee2012-04-23 15:58:50 +1000498 * found a block number match. If the range doesn't
Dave Chinner74f75a02010-09-24 19:59:04 +1000499 * match, the only way this is allowed is if the buffer
500 * in the cache is stale and the transaction that made
501 * it stale has not yet committed. i.e. we are
502 * reallocating a busy extent. Skip this buffer and
503 * continue searching to the right for an exact match.
504 */
Dave Chinner4e94b712012-04-23 15:58:51 +1000505 if (bp->b_length != numblks) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000506 ASSERT(bp->b_flags & XBF_STALE);
507 rbp = &(*rbp)->rb_right;
508 continue;
509 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100510 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 goto found;
512 }
513 }
514
515 /* No match found */
Nathan Scottce8e9222006-01-11 15:39:08 +1100516 if (new_bp) {
Dave Chinner74f75a02010-09-24 19:59:04 +1000517 rb_link_node(&new_bp->b_rbnode, parent, rbp);
518 rb_insert_color(&new_bp->b_rbnode, &pag->pag_buf_tree);
519 /* the buffer keeps the perag reference until it is freed */
520 new_bp->b_pag = pag;
521 spin_unlock(&pag->pag_buf_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 } else {
Nathan Scottce8e9222006-01-11 15:39:08 +1100523 XFS_STATS_INC(xb_miss_locked);
Dave Chinner74f75a02010-09-24 19:59:04 +1000524 spin_unlock(&pag->pag_buf_lock);
525 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100527 return new_bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529found:
Dave Chinner74f75a02010-09-24 19:59:04 +1000530 spin_unlock(&pag->pag_buf_lock);
531 xfs_perag_put(pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200533 if (!xfs_buf_trylock(bp)) {
534 if (flags & XBF_TRYLOCK) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100535 xfs_buf_rele(bp);
536 XFS_STATS_INC(xb_busy_locked);
537 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 }
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200539 xfs_buf_lock(bp);
540 XFS_STATS_INC(xb_get_locked_waited);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 }
542
Dave Chinner0e6e8472011-03-26 09:16:45 +1100543 /*
544 * if the buffer is stale, clear all the external state associated with
545 * it. We need to keep flags such as how we allocated the buffer memory
546 * intact here.
547 */
Nathan Scottce8e9222006-01-11 15:39:08 +1100548 if (bp->b_flags & XBF_STALE) {
549 ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
Dave Chinnercfb02852012-11-12 22:54:19 +1100550 ASSERT(bp->b_iodone == NULL);
Dave Chinner611c9942012-04-23 15:59:07 +1000551 bp->b_flags &= _XBF_KMEM | _XBF_PAGES;
Dave Chinner1813dd62012-11-14 17:54:40 +1100552 bp->b_ops = NULL;
David Chinner2f926582005-09-05 08:33:35 +1000553 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000554
555 trace_xfs_buf_find(bp, flags, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100556 XFS_STATS_INC(xb_get_locked);
557 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
559
560/*
Dave Chinner38158322011-09-30 04:45:02 +0000561 * Assembles a buffer covering the specified range. The code is optimised for
562 * cache hits, as metadata intensive workloads will see 3 orders of magnitude
563 * more hits than misses.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 */
Dave Chinner38158322011-09-30 04:45:02 +0000565struct xfs_buf *
Dave Chinner6dde2702012-06-22 18:50:10 +1000566xfs_buf_get_map(
567 struct xfs_buftarg *target,
568 struct xfs_buf_map *map,
569 int nmaps,
Nathan Scottce8e9222006-01-11 15:39:08 +1100570 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571{
Dave Chinner38158322011-09-30 04:45:02 +0000572 struct xfs_buf *bp;
573 struct xfs_buf *new_bp;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100574 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Dave Chinner6dde2702012-06-22 18:50:10 +1000576 bp = _xfs_buf_find(target, map, nmaps, flags, NULL);
Dave Chinner38158322011-09-30 04:45:02 +0000577 if (likely(bp))
578 goto found;
579
Dave Chinner6dde2702012-06-22 18:50:10 +1000580 new_bp = _xfs_buf_alloc(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100581 if (unlikely(!new_bp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return NULL;
583
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000584 error = xfs_buf_allocate_memory(new_bp, flags);
585 if (error) {
Dave Chinner3e85c862012-06-22 18:50:09 +1000586 xfs_buf_free(new_bp);
Dave Chinner38158322011-09-30 04:45:02 +0000587 return NULL;
588 }
589
Dave Chinner6dde2702012-06-22 18:50:10 +1000590 bp = _xfs_buf_find(target, map, nmaps, flags, new_bp);
Dave Chinnerfe2429b2012-04-23 15:58:45 +1000591 if (!bp) {
592 xfs_buf_free(new_bp);
593 return NULL;
594 }
595
596 if (bp != new_bp)
597 xfs_buf_free(new_bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
Dave Chinner38158322011-09-30 04:45:02 +0000599found:
Dave Chinner611c9942012-04-23 15:59:07 +1000600 if (!bp->b_addr) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100601 error = _xfs_buf_map_pages(bp, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100603 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500604 "%s: failed to map pagesn", __func__);
Dave Chinnera8acad72012-04-23 15:58:54 +1000605 xfs_buf_relse(bp);
606 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 }
608 }
609
Nathan Scottce8e9222006-01-11 15:39:08 +1100610 XFS_STATS_INC(xb_get);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000611 trace_xfs_buf_get(bp, flags, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100612 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613}
614
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100615STATIC int
616_xfs_buf_read(
617 xfs_buf_t *bp,
618 xfs_buf_flags_t flags)
619{
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000620 ASSERT(!(flags & XBF_WRITE));
Mark Tinguelyf4b42422012-12-04 17:18:02 -0600621 ASSERT(bp->b_maps[0].bm_bn != XFS_BUF_DADDR_NULL);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100622
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000623 bp->b_flags &= ~(XBF_WRITE | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig1d5ae5d2011-07-08 14:36:32 +0200624 bp->b_flags |= flags & (XBF_READ | XBF_ASYNC | XBF_READ_AHEAD);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100625
Dave Chinner0e95f192012-04-23 15:58:46 +1000626 xfs_buf_iorequest(bp);
627 if (flags & XBF_ASYNC)
628 return 0;
Dave Chinnerec53d1d2010-07-20 17:52:59 +1000629 return xfs_buf_iowait(bp);
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100630}
631
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632xfs_buf_t *
Dave Chinner6dde2702012-06-22 18:50:10 +1000633xfs_buf_read_map(
634 struct xfs_buftarg *target,
635 struct xfs_buf_map *map,
636 int nmaps,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100637 xfs_buf_flags_t flags,
Dave Chinner1813dd62012-11-14 17:54:40 +1100638 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639{
Dave Chinner6dde2702012-06-22 18:50:10 +1000640 struct xfs_buf *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
Nathan Scottce8e9222006-01-11 15:39:08 +1100642 flags |= XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Dave Chinner6dde2702012-06-22 18:50:10 +1000644 bp = xfs_buf_get_map(target, map, nmaps, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100645 if (bp) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000646 trace_xfs_buf_read(bp, flags, _RET_IP_);
647
Nathan Scottce8e9222006-01-11 15:39:08 +1100648 if (!XFS_BUF_ISDONE(bp)) {
Nathan Scottce8e9222006-01-11 15:39:08 +1100649 XFS_STATS_INC(xb_get_read);
Dave Chinner1813dd62012-11-14 17:54:40 +1100650 bp->b_ops = ops;
Christoph Hellwig5d765b92008-12-03 12:20:26 +0100651 _xfs_buf_read(bp, flags);
Nathan Scottce8e9222006-01-11 15:39:08 +1100652 } else if (flags & XBF_ASYNC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 /*
654 * Read ahead call which is already satisfied,
655 * drop the buffer
656 */
Dave Chinnera8acad72012-04-23 15:58:54 +1000657 xfs_buf_relse(bp);
658 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 /* We do not want read in the flags */
Nathan Scottce8e9222006-01-11 15:39:08 +1100661 bp->b_flags &= ~XBF_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 }
663 }
664
Nathan Scottce8e9222006-01-11 15:39:08 +1100665 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
667
668/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100669 * If we are not low on memory then do the readahead in a deadlock
670 * safe manner.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 */
672void
Dave Chinner6dde2702012-06-22 18:50:10 +1000673xfs_buf_readahead_map(
674 struct xfs_buftarg *target,
675 struct xfs_buf_map *map,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100676 int nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100677 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678{
Dave Chinner0e6e8472011-03-26 09:16:45 +1100679 if (bdi_read_congested(target->bt_bdi))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return;
681
Dave Chinner6dde2702012-06-22 18:50:10 +1000682 xfs_buf_read_map(target, map, nmaps,
Dave Chinner1813dd62012-11-14 17:54:40 +1100683 XBF_TRYLOCK|XBF_ASYNC|XBF_READ_AHEAD, ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684}
685
Dave Chinner5adc94c2010-09-24 21:58:31 +1000686/*
687 * Read an uncached buffer from disk. Allocates and returns a locked
688 * buffer containing the disk contents or nothing.
689 */
690struct xfs_buf *
691xfs_buf_read_uncached(
Dave Chinner5adc94c2010-09-24 21:58:31 +1000692 struct xfs_buftarg *target,
693 xfs_daddr_t daddr,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000694 size_t numblks,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100695 int flags,
Dave Chinner1813dd62012-11-14 17:54:40 +1100696 const struct xfs_buf_ops *ops)
Dave Chinner5adc94c2010-09-24 21:58:31 +1000697{
Dave Chinnereab4e632012-11-12 22:54:02 +1100698 struct xfs_buf *bp;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000699
Dave Chinnere70b73f2012-04-23 15:58:49 +1000700 bp = xfs_buf_get_uncached(target, numblks, flags);
Dave Chinner5adc94c2010-09-24 21:58:31 +1000701 if (!bp)
702 return NULL;
703
704 /* set up the buffer for a read IO */
Dave Chinner3e85c862012-06-22 18:50:09 +1000705 ASSERT(bp->b_map_count == 1);
706 bp->b_bn = daddr;
707 bp->b_maps[0].bm_bn = daddr;
Dave Chinnercbb7baab2012-06-22 18:50:08 +1000708 bp->b_flags |= XBF_READ;
Dave Chinner1813dd62012-11-14 17:54:40 +1100709 bp->b_ops = ops;
Dave Chinner5adc94c2010-09-24 21:58:31 +1000710
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800711 if (XFS_FORCED_SHUTDOWN(target->bt_mount)) {
712 xfs_buf_relse(bp);
713 return NULL;
714 }
715 xfs_buf_iorequest(bp);
Dave Chinnereab4e632012-11-12 22:54:02 +1100716 xfs_buf_iowait(bp);
Dave Chinner5adc94c2010-09-24 21:58:31 +1000717 return bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
Dave Chinner44396472011-04-21 09:34:27 +0000720/*
721 * Return a buffer allocated as an empty buffer and associated to external
722 * memory via xfs_buf_associate_memory() back to it's empty state.
723 */
724void
725xfs_buf_set_empty(
726 struct xfs_buf *bp,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000727 size_t numblks)
Dave Chinner44396472011-04-21 09:34:27 +0000728{
729 if (bp->b_pages)
730 _xfs_buf_free_pages(bp);
731
732 bp->b_pages = NULL;
733 bp->b_page_count = 0;
734 bp->b_addr = NULL;
Dave Chinner4e94b712012-04-23 15:58:51 +1000735 bp->b_length = numblks;
Dave Chinneraa0e8832012-04-23 15:58:52 +1000736 bp->b_io_length = numblks;
Dave Chinner3e85c862012-06-22 18:50:09 +1000737
738 ASSERT(bp->b_map_count == 1);
Dave Chinner44396472011-04-21 09:34:27 +0000739 bp->b_bn = XFS_BUF_DADDR_NULL;
Dave Chinner3e85c862012-06-22 18:50:09 +1000740 bp->b_maps[0].bm_bn = XFS_BUF_DADDR_NULL;
741 bp->b_maps[0].bm_len = bp->b_length;
Dave Chinner44396472011-04-21 09:34:27 +0000742}
743
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744static inline struct page *
745mem_to_page(
746 void *addr)
747{
Christoph Lameter9e2779f2008-02-04 22:28:34 -0800748 if ((!is_vmalloc_addr(addr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 return virt_to_page(addr);
750 } else {
751 return vmalloc_to_page(addr);
752 }
753}
754
755int
Nathan Scottce8e9222006-01-11 15:39:08 +1100756xfs_buf_associate_memory(
757 xfs_buf_t *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 void *mem,
759 size_t len)
760{
761 int rval;
762 int i = 0;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100763 unsigned long pageaddr;
764 unsigned long offset;
765 size_t buflen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 int page_count;
767
Dave Chinner0e6e8472011-03-26 09:16:45 +1100768 pageaddr = (unsigned long)mem & PAGE_MASK;
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100769 offset = (unsigned long)mem - pageaddr;
Dave Chinner0e6e8472011-03-26 09:16:45 +1100770 buflen = PAGE_ALIGN(len + offset);
771 page_count = buflen >> PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
773 /* Free any previous set of page pointers */
Nathan Scottce8e9222006-01-11 15:39:08 +1100774 if (bp->b_pages)
775 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Nathan Scottce8e9222006-01-11 15:39:08 +1100777 bp->b_pages = NULL;
778 bp->b_addr = mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Eric Sandeen87937bf2014-04-14 19:01:20 +1000780 rval = _xfs_buf_get_pages(bp, page_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (rval)
782 return rval;
783
Nathan Scottce8e9222006-01-11 15:39:08 +1100784 bp->b_offset = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Lachlan McIlroyd1afb672007-11-27 17:01:24 +1100786 for (i = 0; i < bp->b_page_count; i++) {
787 bp->b_pages[i] = mem_to_page((void *)pageaddr);
Dave Chinner0e6e8472011-03-26 09:16:45 +1100788 pageaddr += PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Dave Chinneraa0e8832012-04-23 15:58:52 +1000791 bp->b_io_length = BTOBB(len);
Dave Chinner4e94b712012-04-23 15:58:51 +1000792 bp->b_length = BTOBB(buflen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
794 return 0;
795}
796
797xfs_buf_t *
Dave Chinner686865f2010-09-24 20:07:47 +1000798xfs_buf_get_uncached(
799 struct xfs_buftarg *target,
Dave Chinnere70b73f2012-04-23 15:58:49 +1000800 size_t numblks,
Dave Chinner686865f2010-09-24 20:07:47 +1000801 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
Dave Chinnere70b73f2012-04-23 15:58:49 +1000803 unsigned long page_count;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000804 int error, i;
Dave Chinner3e85c862012-06-22 18:50:09 +1000805 struct xfs_buf *bp;
806 DEFINE_SINGLE_BUF_MAP(map, XFS_BUF_DADDR_NULL, numblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
Dave Chinner3e85c862012-06-22 18:50:09 +1000808 bp = _xfs_buf_alloc(target, &map, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 if (unlikely(bp == NULL))
810 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
Dave Chinnere70b73f2012-04-23 15:58:49 +1000812 page_count = PAGE_ALIGN(numblks << BBSHIFT) >> PAGE_SHIFT;
Eric Sandeen87937bf2014-04-14 19:01:20 +1000813 error = _xfs_buf_get_pages(bp, page_count);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000814 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 goto fail_free_buf;
816
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000817 for (i = 0; i < page_count; i++) {
Dave Chinner686865f2010-09-24 20:07:47 +1000818 bp->b_pages[i] = alloc_page(xb_to_gfp(flags));
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000819 if (!bp->b_pages[i])
820 goto fail_free_mem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 }
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000822 bp->b_flags |= _XBF_PAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Dave Chinner611c9942012-04-23 15:59:07 +1000824 error = _xfs_buf_map_pages(bp, 0);
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000825 if (unlikely(error)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100826 xfs_warn(target->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -0500827 "%s: failed to map pages", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 goto fail_free_mem;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000829 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
Dave Chinner686865f2010-09-24 20:07:47 +1000831 trace_xfs_buf_get_uncached(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 return bp;
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000833
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 fail_free_mem:
Christoph Hellwig1fa40b02007-05-14 18:23:50 +1000835 while (--i >= 0)
836 __free_page(bp->b_pages[i]);
Christoph Hellwigca165b82007-05-24 15:21:11 +1000837 _xfs_buf_free_pages(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 fail_free_buf:
Dave Chinner3e85c862012-06-22 18:50:09 +1000839 xfs_buf_free_maps(bp);
Christoph Hellwig4347b9d2011-10-10 16:52:48 +0000840 kmem_zone_free(xfs_buf_zone, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 fail:
842 return NULL;
843}
844
845/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 * Increment reference count on buffer, to hold the buffer concurrently
847 * with another thread which may release (free) the buffer asynchronously.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 * Must hold the buffer already to call this function.
849 */
850void
Nathan Scottce8e9222006-01-11 15:39:08 +1100851xfs_buf_hold(
852 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000854 trace_xfs_buf_hold(bp, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +1100855 atomic_inc(&bp->b_hold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856}
857
858/*
Nathan Scottce8e9222006-01-11 15:39:08 +1100859 * Releases a hold on the specified buffer. If the
860 * the hold count is 1, calls xfs_buf_free.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 */
862void
Nathan Scottce8e9222006-01-11 15:39:08 +1100863xfs_buf_rele(
864 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865{
Dave Chinner74f75a02010-09-24 19:59:04 +1000866 struct xfs_perag *pag = bp->b_pag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000868 trace_xfs_buf_rele(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
Dave Chinner74f75a02010-09-24 19:59:04 +1000870 if (!pag) {
Dave Chinner430cbeb2010-12-02 16:30:55 +1100871 ASSERT(list_empty(&bp->b_lru));
Dave Chinner74f75a02010-09-24 19:59:04 +1000872 ASSERT(RB_EMPTY_NODE(&bp->b_rbnode));
Nathan Scottfad3aa12006-02-01 12:14:52 +1100873 if (atomic_dec_and_test(&bp->b_hold))
874 xfs_buf_free(bp);
875 return;
876 }
877
Dave Chinner74f75a02010-09-24 19:59:04 +1000878 ASSERT(!RB_EMPTY_NODE(&bp->b_rbnode));
Dave Chinner430cbeb2010-12-02 16:30:55 +1100879
Lachlan McIlroy37906892008-08-13 15:42:10 +1000880 ASSERT(atomic_read(&bp->b_hold) > 0);
Dave Chinner74f75a02010-09-24 19:59:04 +1000881 if (atomic_dec_and_lock(&bp->b_hold, &pag->pag_buf_lock)) {
Dave Chinnera4082352013-08-28 10:18:06 +1000882 spin_lock(&bp->b_lock);
883 if (!(bp->b_flags & XBF_STALE) && atomic_read(&bp->b_lru_ref)) {
884 /*
885 * If the buffer is added to the LRU take a new
886 * reference to the buffer for the LRU and clear the
887 * (now stale) dispose list state flag
888 */
889 if (list_lru_add(&bp->b_target->bt_lru, &bp->b_lru)) {
890 bp->b_state &= ~XFS_BSTATE_DISPOSE;
891 atomic_inc(&bp->b_hold);
892 }
893 spin_unlock(&bp->b_lock);
Dave Chinner430cbeb2010-12-02 16:30:55 +1100894 spin_unlock(&pag->pag_buf_lock);
Christoph Hellwig7f14d0a2005-11-02 15:09:35 +1100895 } else {
Dave Chinnera4082352013-08-28 10:18:06 +1000896 /*
897 * most of the time buffers will already be removed from
898 * the LRU, so optimise that case by checking for the
899 * XFS_BSTATE_DISPOSE flag indicating the last list the
900 * buffer was on was the disposal list
901 */
902 if (!(bp->b_state & XFS_BSTATE_DISPOSE)) {
903 list_lru_del(&bp->b_target->bt_lru, &bp->b_lru);
904 } else {
905 ASSERT(list_empty(&bp->b_lru));
906 }
907 spin_unlock(&bp->b_lock);
908
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000909 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
Dave Chinner74f75a02010-09-24 19:59:04 +1000910 rb_erase(&bp->b_rbnode, &pag->pag_buf_tree);
911 spin_unlock(&pag->pag_buf_lock);
912 xfs_perag_put(pag);
Nathan Scottce8e9222006-01-11 15:39:08 +1100913 xfs_buf_free(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 }
915 }
916}
917
918
919/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100920 * Lock a buffer object, if it is not already locked.
Dave Chinner90810b92010-11-30 15:16:16 +1100921 *
922 * If we come across a stale, pinned, locked buffer, we know that we are
923 * being asked to lock a buffer that has been reallocated. Because it is
924 * pinned, we know that the log has not been pushed to disk and hence it
925 * will still be locked. Rather than continuing to have trylock attempts
926 * fail until someone else pushes the log, push it ourselves before
927 * returning. This means that the xfsaild will not get stuck trying
928 * to push on stale inode buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 */
930int
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200931xfs_buf_trylock(
932 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933{
934 int locked;
935
Nathan Scottce8e9222006-01-11 15:39:08 +1100936 locked = down_trylock(&bp->b_sema) == 0;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000937 if (locked)
Nathan Scottce8e9222006-01-11 15:39:08 +1100938 XB_SET_OWNER(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000939
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200940 trace_xfs_buf_trylock(bp, _RET_IP_);
941 return locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944/*
Dave Chinner0e6e8472011-03-26 09:16:45 +1100945 * Lock a buffer object.
Dave Chinnered3b4d62010-05-21 12:07:08 +1000946 *
947 * If we come across a stale, pinned, locked buffer, we know that we
948 * are being asked to lock a buffer that has been reallocated. Because
949 * it is pinned, we know that the log has not been pushed to disk and
950 * hence it will still be locked. Rather than sleeping until someone
951 * else pushes the log, push it ourselves before trying to get the lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 */
Nathan Scottce8e9222006-01-11 15:39:08 +1100953void
954xfs_buf_lock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200955 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000957 trace_xfs_buf_lock(bp, _RET_IP_);
958
Dave Chinnered3b4d62010-05-21 12:07:08 +1000959 if (atomic_read(&bp->b_pin_count) && (bp->b_flags & XBF_STALE))
Dave Chinnerebad8612010-09-22 10:47:20 +1000960 xfs_log_force(bp->b_target->bt_mount, 0);
Nathan Scottce8e9222006-01-11 15:39:08 +1100961 down(&bp->b_sema);
962 XB_SET_OWNER(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000963
964 trace_xfs_buf_lock_done(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965}
966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967void
Nathan Scottce8e9222006-01-11 15:39:08 +1100968xfs_buf_unlock(
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200969 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970{
Nathan Scottce8e9222006-01-11 15:39:08 +1100971 XB_CLEAR_OWNER(bp);
972 up(&bp->b_sema);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000973
974 trace_xfs_buf_unlock(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975}
976
Nathan Scottce8e9222006-01-11 15:39:08 +1100977STATIC void
978xfs_buf_wait_unpin(
979 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980{
981 DECLARE_WAITQUEUE (wait, current);
982
Nathan Scottce8e9222006-01-11 15:39:08 +1100983 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 return;
985
Nathan Scottce8e9222006-01-11 15:39:08 +1100986 add_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 for (;;) {
988 set_current_state(TASK_UNINTERRUPTIBLE);
Nathan Scottce8e9222006-01-11 15:39:08 +1100989 if (atomic_read(&bp->b_pin_count) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 break;
Jens Axboe7eaceac2011-03-10 08:52:07 +0100991 io_schedule();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 }
Nathan Scottce8e9222006-01-11 15:39:08 +1100993 remove_wait_queue(&bp->b_waiters, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 set_current_state(TASK_RUNNING);
995}
996
997/*
998 * Buffer Utility Routines
999 */
1000
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +11001002xfs_buf_iodone_work(
David Howellsc4028952006-11-22 14:57:56 +00001003 struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004{
Dave Chinner1813dd62012-11-14 17:54:40 +11001005 struct xfs_buf *bp =
David Howellsc4028952006-11-22 14:57:56 +00001006 container_of(work, xfs_buf_t, b_iodone_work);
Dave Chinner1813dd62012-11-14 17:54:40 +11001007 bool read = !!(bp->b_flags & XBF_READ);
1008
1009 bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD);
Dave Chinnerd5929de2013-02-27 13:25:54 +11001010
1011 /* only validate buffers that were read without errors */
1012 if (read && bp->b_ops && !bp->b_error && (bp->b_flags & XBF_DONE))
Dave Chinner1813dd62012-11-14 17:54:40 +11001013 bp->b_ops->verify_read(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
Christoph Hellwig80f6c292010-08-18 05:29:11 -04001015 if (bp->b_iodone)
Nathan Scottce8e9222006-01-11 15:39:08 +11001016 (*(bp->b_iodone))(bp);
1017 else if (bp->b_flags & XBF_ASYNC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 xfs_buf_relse(bp);
Dave Chinner1813dd62012-11-14 17:54:40 +11001019 else {
1020 ASSERT(read && bp->b_ops);
1021 complete(&bp->b_iowait);
1022 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023}
1024
1025void
Nathan Scottce8e9222006-01-11 15:39:08 +11001026xfs_buf_ioend(
Dave Chinner1813dd62012-11-14 17:54:40 +11001027 struct xfs_buf *bp,
1028 int schedule)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029{
Dave Chinner1813dd62012-11-14 17:54:40 +11001030 bool read = !!(bp->b_flags & XBF_READ);
1031
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001032 trace_xfs_buf_iodone(bp, _RET_IP_);
1033
Nathan Scottce8e9222006-01-11 15:39:08 +11001034 if (bp->b_error == 0)
1035 bp->b_flags |= XBF_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036
Dave Chinner1813dd62012-11-14 17:54:40 +11001037 if (bp->b_iodone || (read && bp->b_ops) || (bp->b_flags & XBF_ASYNC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 if (schedule) {
David Howellsc4028952006-11-22 14:57:56 +00001039 INIT_WORK(&bp->b_iodone_work, xfs_buf_iodone_work);
Nathan Scottce8e9222006-01-11 15:39:08 +11001040 queue_work(xfslogd_workqueue, &bp->b_iodone_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 } else {
David Howellsc4028952006-11-22 14:57:56 +00001042 xfs_buf_iodone_work(&bp->b_iodone_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 }
1044 } else {
Dave Chinner1813dd62012-11-14 17:54:40 +11001045 bp->b_flags &= ~(XBF_READ | XBF_WRITE | XBF_READ_AHEAD);
David Chinnerb4dd3302008-08-13 16:36:11 +10001046 complete(&bp->b_iowait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
1048}
1049
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050void
Nathan Scottce8e9222006-01-11 15:39:08 +11001051xfs_buf_ioerror(
1052 xfs_buf_t *bp,
1053 int error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054{
1055 ASSERT(error >= 0 && error <= 0xffff);
Nathan Scottce8e9222006-01-11 15:39:08 +11001056 bp->b_error = (unsigned short)error;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001057 trace_xfs_buf_ioerror(bp, error, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058}
1059
Christoph Hellwig901796a2011-10-10 16:52:49 +00001060void
1061xfs_buf_ioerror_alert(
1062 struct xfs_buf *bp,
1063 const char *func)
1064{
1065 xfs_alert(bp->b_target->bt_mount,
Dave Chinneraa0e8832012-04-23 15:58:52 +10001066"metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
1067 (__uint64_t)XFS_BUF_ADDR(bp), func, bp->b_error, bp->b_length);
Christoph Hellwig901796a2011-10-10 16:52:49 +00001068}
1069
Christoph Hellwig4e234712010-01-13 22:17:56 +00001070/*
1071 * Called when we want to stop a buffer from getting written or read.
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +00001072 * We attach the EIO error, muck with its flags, and call xfs_buf_ioend
Christoph Hellwig4e234712010-01-13 22:17:56 +00001073 * so that the proper iodone callbacks get called.
1074 */
1075STATIC int
1076xfs_bioerror(
1077 xfs_buf_t *bp)
1078{
1079#ifdef XFSERRORDEBUG
1080 ASSERT(XFS_BUF_ISREAD(bp) || bp->b_iodone);
1081#endif
1082
1083 /*
1084 * No need to wait until the buffer is unpinned, we aren't flushing it.
1085 */
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00001086 xfs_buf_ioerror(bp, EIO);
Christoph Hellwig4e234712010-01-13 22:17:56 +00001087
1088 /*
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +00001089 * We're calling xfs_buf_ioend, so delete XBF_DONE flag.
Christoph Hellwig4e234712010-01-13 22:17:56 +00001090 */
1091 XFS_BUF_UNREAD(bp);
Christoph Hellwig4e234712010-01-13 22:17:56 +00001092 XFS_BUF_UNDONE(bp);
Christoph Hellwigc867cb62011-10-10 16:52:46 +00001093 xfs_buf_stale(bp);
Christoph Hellwig4e234712010-01-13 22:17:56 +00001094
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +00001095 xfs_buf_ioend(bp, 0);
Christoph Hellwig4e234712010-01-13 22:17:56 +00001096
1097 return EIO;
1098}
1099
1100/*
1101 * Same as xfs_bioerror, except that we are releasing the buffer
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +00001102 * here ourselves, and avoiding the xfs_buf_ioend call.
Christoph Hellwig4e234712010-01-13 22:17:56 +00001103 * This is meant for userdata errors; metadata bufs come with
1104 * iodone functions attached, so that we can track down errors.
1105 */
Christoph Hellwig83a0adc2013-12-17 00:03:52 -08001106int
Christoph Hellwig4e234712010-01-13 22:17:56 +00001107xfs_bioerror_relse(
1108 struct xfs_buf *bp)
1109{
Chandra Seetharamaned432332011-07-22 23:39:39 +00001110 int64_t fl = bp->b_flags;
Christoph Hellwig4e234712010-01-13 22:17:56 +00001111 /*
1112 * No need to wait until the buffer is unpinned.
1113 * We aren't flushing it.
1114 *
1115 * chunkhold expects B_DONE to be set, whether
1116 * we actually finish the I/O or not. We don't want to
1117 * change that interface.
1118 */
1119 XFS_BUF_UNREAD(bp);
Christoph Hellwig4e234712010-01-13 22:17:56 +00001120 XFS_BUF_DONE(bp);
Christoph Hellwigc867cb62011-10-10 16:52:46 +00001121 xfs_buf_stale(bp);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +02001122 bp->b_iodone = NULL;
Christoph Hellwig0cadda12010-01-19 09:56:44 +00001123 if (!(fl & XBF_ASYNC)) {
Christoph Hellwig4e234712010-01-13 22:17:56 +00001124 /*
1125 * Mark b_error and B_ERROR _both_.
1126 * Lot's of chunkcache code assumes that.
1127 * There's no reason to mark error for
1128 * ASYNC buffers.
1129 */
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +00001130 xfs_buf_ioerror(bp, EIO);
Christoph Hellwig5fde0322011-10-10 16:52:44 +00001131 complete(&bp->b_iowait);
Christoph Hellwig4e234712010-01-13 22:17:56 +00001132 } else {
1133 xfs_buf_relse(bp);
1134 }
1135
1136 return EIO;
1137}
1138
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001139STATIC int
Christoph Hellwig4e234712010-01-13 22:17:56 +00001140xfs_bdstrat_cb(
1141 struct xfs_buf *bp)
1142{
Dave Chinnerebad8612010-09-22 10:47:20 +10001143 if (XFS_FORCED_SHUTDOWN(bp->b_target->bt_mount)) {
Christoph Hellwig4e234712010-01-13 22:17:56 +00001144 trace_xfs_bdstrat_shut(bp, _RET_IP_);
1145 /*
1146 * Metadata write that didn't get logged but
1147 * written delayed anyway. These aren't associated
1148 * with a transaction, and can be ignored.
1149 */
1150 if (!bp->b_iodone && !XFS_BUF_ISREAD(bp))
1151 return xfs_bioerror_relse(bp);
1152 else
1153 return xfs_bioerror(bp);
1154 }
1155
1156 xfs_buf_iorequest(bp);
1157 return 0;
1158}
1159
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001160int
1161xfs_bwrite(
1162 struct xfs_buf *bp)
1163{
1164 int error;
1165
1166 ASSERT(xfs_buf_islocked(bp));
1167
1168 bp->b_flags |= XBF_WRITE;
Dave Chinnerac8809f2013-12-12 16:34:38 +11001169 bp->b_flags &= ~(XBF_ASYNC | XBF_READ | _XBF_DELWRI_Q | XBF_WRITE_FAIL);
Christoph Hellwiga2dcf5d2012-07-13 02:24:10 -04001170
1171 xfs_bdstrat_cb(bp);
1172
1173 error = xfs_buf_iowait(bp);
1174 if (error) {
1175 xfs_force_shutdown(bp->b_target->bt_mount,
1176 SHUTDOWN_META_IO_ERROR);
1177 }
1178 return error;
1179}
1180
Christoph Hellwigb8f82a42009-11-14 16:17:22 +00001181STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +11001182_xfs_buf_ioend(
1183 xfs_buf_t *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 int schedule)
1185{
Dave Chinner0e6e8472011-03-26 09:16:45 +11001186 if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
Nathan Scottce8e9222006-01-11 15:39:08 +11001187 xfs_buf_ioend(bp, schedule);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188}
1189
Al Viro782e3b32007-10-12 07:17:47 +01001190STATIC void
Nathan Scottce8e9222006-01-11 15:39:08 +11001191xfs_buf_bio_end_io(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 struct bio *bio,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 int error)
1194{
Nathan Scottce8e9222006-01-11 15:39:08 +11001195 xfs_buf_t *bp = (xfs_buf_t *)bio->bi_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
Dave Chinner37eb17e2012-11-12 22:09:46 +11001197 /*
1198 * don't overwrite existing errors - otherwise we can lose errors on
1199 * buffers that require multiple bios to complete.
1200 */
1201 if (!bp->b_error)
1202 xfs_buf_ioerror(bp, -error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203
Dave Chinner37eb17e2012-11-12 22:09:46 +11001204 if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
James Bottomley73c77e22010-01-25 11:42:24 -06001205 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
1206
Nathan Scottce8e9222006-01-11 15:39:08 +11001207 _xfs_buf_ioend(bp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209}
1210
Dave Chinner3e85c862012-06-22 18:50:09 +10001211static void
1212xfs_buf_ioapply_map(
1213 struct xfs_buf *bp,
1214 int map,
1215 int *buf_offset,
1216 int *count,
1217 int rw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218{
Dave Chinner3e85c862012-06-22 18:50:09 +10001219 int page_index;
1220 int total_nr_pages = bp->b_page_count;
1221 int nr_pages;
1222 struct bio *bio;
1223 sector_t sector = bp->b_maps[map].bm_bn;
1224 int size;
1225 int offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226
Nathan Scottce8e9222006-01-11 15:39:08 +11001227 total_nr_pages = bp->b_page_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
Dave Chinner3e85c862012-06-22 18:50:09 +10001229 /* skip the pages in the buffer before the start offset */
1230 page_index = 0;
1231 offset = *buf_offset;
1232 while (offset >= PAGE_SIZE) {
1233 page_index++;
1234 offset -= PAGE_SIZE;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +11001235 }
1236
Dave Chinner3e85c862012-06-22 18:50:09 +10001237 /*
1238 * Limit the IO size to the length of the current vector, and update the
1239 * remaining IO count for the next time around.
1240 */
1241 size = min_t(int, BBTOB(bp->b_maps[map].bm_len), *count);
1242 *count -= size;
1243 *buf_offset += size;
Christoph Hellwig34951f52011-07-26 15:06:44 +00001244
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245next_chunk:
Nathan Scottce8e9222006-01-11 15:39:08 +11001246 atomic_inc(&bp->b_io_remaining);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 nr_pages = BIO_MAX_SECTORS >> (PAGE_SHIFT - BBSHIFT);
1248 if (nr_pages > total_nr_pages)
1249 nr_pages = total_nr_pages;
1250
1251 bio = bio_alloc(GFP_NOIO, nr_pages);
Nathan Scottce8e9222006-01-11 15:39:08 +11001252 bio->bi_bdev = bp->b_target->bt_bdev;
Kent Overstreet4f024f32013-10-11 15:44:27 -07001253 bio->bi_iter.bi_sector = sector;
Nathan Scottce8e9222006-01-11 15:39:08 +11001254 bio->bi_end_io = xfs_buf_bio_end_io;
1255 bio->bi_private = bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
Dave Chinner0e6e8472011-03-26 09:16:45 +11001257
Dave Chinner3e85c862012-06-22 18:50:09 +10001258 for (; size && nr_pages; nr_pages--, page_index++) {
Dave Chinner0e6e8472011-03-26 09:16:45 +11001259 int rbytes, nbytes = PAGE_SIZE - offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 if (nbytes > size)
1262 nbytes = size;
1263
Dave Chinner3e85c862012-06-22 18:50:09 +10001264 rbytes = bio_add_page(bio, bp->b_pages[page_index], nbytes,
1265 offset);
Nathan Scottce8e9222006-01-11 15:39:08 +11001266 if (rbytes < nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 break;
1268
1269 offset = 0;
Dave Chinneraa0e8832012-04-23 15:58:52 +10001270 sector += BTOBB(nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 size -= nbytes;
1272 total_nr_pages--;
1273 }
1274
Kent Overstreet4f024f32013-10-11 15:44:27 -07001275 if (likely(bio->bi_iter.bi_size)) {
James Bottomley73c77e22010-01-25 11:42:24 -06001276 if (xfs_buf_is_vmapped(bp)) {
1277 flush_kernel_vmap_range(bp->b_addr,
1278 xfs_buf_vmap_len(bp));
1279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 submit_bio(rw, bio);
1281 if (size)
1282 goto next_chunk;
1283 } else {
Dave Chinner37eb17e2012-11-12 22:09:46 +11001284 /*
1285 * This is guaranteed not to be the last io reference count
1286 * because the caller (xfs_buf_iorequest) holds a count itself.
1287 */
1288 atomic_dec(&bp->b_io_remaining);
Nathan Scottce8e9222006-01-11 15:39:08 +11001289 xfs_buf_ioerror(bp, EIO);
Dave Chinnerec53d1d2010-07-20 17:52:59 +10001290 bio_put(bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001292
1293}
1294
1295STATIC void
1296_xfs_buf_ioapply(
1297 struct xfs_buf *bp)
1298{
1299 struct blk_plug plug;
1300 int rw;
1301 int offset;
1302 int size;
1303 int i;
1304
Dave Chinnerc163f9a2013-03-12 23:30:34 +11001305 /*
1306 * Make sure we capture only current IO errors rather than stale errors
1307 * left over from previous use of the buffer (e.g. failed readahead).
1308 */
1309 bp->b_error = 0;
1310
Dave Chinner3e85c862012-06-22 18:50:09 +10001311 if (bp->b_flags & XBF_WRITE) {
1312 if (bp->b_flags & XBF_SYNCIO)
1313 rw = WRITE_SYNC;
1314 else
1315 rw = WRITE;
1316 if (bp->b_flags & XBF_FUA)
1317 rw |= REQ_FUA;
1318 if (bp->b_flags & XBF_FLUSH)
1319 rw |= REQ_FLUSH;
Dave Chinner1813dd62012-11-14 17:54:40 +11001320
1321 /*
1322 * Run the write verifier callback function if it exists. If
1323 * this function fails it will mark the buffer with an error and
1324 * the IO should not be dispatched.
1325 */
1326 if (bp->b_ops) {
1327 bp->b_ops->verify_write(bp);
1328 if (bp->b_error) {
1329 xfs_force_shutdown(bp->b_target->bt_mount,
1330 SHUTDOWN_CORRUPT_INCORE);
1331 return;
1332 }
1333 }
Dave Chinner3e85c862012-06-22 18:50:09 +10001334 } else if (bp->b_flags & XBF_READ_AHEAD) {
1335 rw = READA;
1336 } else {
1337 rw = READ;
1338 }
1339
1340 /* we only use the buffer cache for meta-data */
1341 rw |= REQ_META;
1342
1343 /*
1344 * Walk all the vectors issuing IO on them. Set up the initial offset
1345 * into the buffer and the desired IO size before we start -
1346 * _xfs_buf_ioapply_vec() will modify them appropriately for each
1347 * subsequent call.
1348 */
1349 offset = bp->b_offset;
1350 size = BBTOB(bp->b_io_length);
1351 blk_start_plug(&plug);
1352 for (i = 0; i < bp->b_map_count; i++) {
1353 xfs_buf_ioapply_map(bp, i, &offset, &size, rw);
1354 if (bp->b_error)
1355 break;
1356 if (size <= 0)
1357 break; /* all done */
1358 }
1359 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360}
1361
Dave Chinner0e95f192012-04-23 15:58:46 +10001362void
Nathan Scottce8e9222006-01-11 15:39:08 +11001363xfs_buf_iorequest(
1364 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001366 trace_xfs_buf_iorequest(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001368 ASSERT(!(bp->b_flags & _XBF_DELWRI_Q));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
Christoph Hellwig375ec69d2011-08-23 08:28:03 +00001370 if (bp->b_flags & XBF_WRITE)
Nathan Scottce8e9222006-01-11 15:39:08 +11001371 xfs_buf_wait_unpin(bp);
Nathan Scottce8e9222006-01-11 15:39:08 +11001372 xfs_buf_hold(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001374 /*
1375 * Set the count to 1 initially, this will stop an I/O
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 * completion callout which happens before we have started
Nathan Scottce8e9222006-01-11 15:39:08 +11001377 * all the I/O from calling xfs_buf_ioend too early.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 */
Nathan Scottce8e9222006-01-11 15:39:08 +11001379 atomic_set(&bp->b_io_remaining, 1);
1380 _xfs_buf_ioapply(bp);
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001381 /*
1382 * If _xfs_buf_ioapply failed, we'll get back here with
1383 * only the reference we took above. _xfs_buf_ioend will
1384 * drop it to zero, so we'd better not queue it for later,
1385 * or we'll free it before it's done.
1386 */
1387 _xfs_buf_ioend(bp, bp->b_error ? 0 : 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
Nathan Scottce8e9222006-01-11 15:39:08 +11001389 xfs_buf_rele(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390}
1391
1392/*
Dave Chinner0e95f192012-04-23 15:58:46 +10001393 * Waits for I/O to complete on the buffer supplied. It returns immediately if
Eric Sandeen8d6c1212014-04-17 08:15:28 +10001394 * no I/O is pending or there is already a pending error on the buffer, in which
1395 * case nothing will ever complete. It returns the I/O error code, if any, or
1396 * 0 if there was no error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 */
1398int
Nathan Scottce8e9222006-01-11 15:39:08 +11001399xfs_buf_iowait(
1400 xfs_buf_t *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401{
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001402 trace_xfs_buf_iowait(bp, _RET_IP_);
1403
Dave Chinner0e95f192012-04-23 15:58:46 +10001404 if (!bp->b_error)
1405 wait_for_completion(&bp->b_iowait);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001406
1407 trace_xfs_buf_iowait_done(bp, _RET_IP_);
Nathan Scottce8e9222006-01-11 15:39:08 +11001408 return bp->b_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409}
1410
Nathan Scottce8e9222006-01-11 15:39:08 +11001411xfs_caddr_t
1412xfs_buf_offset(
1413 xfs_buf_t *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 size_t offset)
1415{
1416 struct page *page;
1417
Dave Chinner611c9942012-04-23 15:59:07 +10001418 if (bp->b_addr)
Chandra Seetharaman62926042011-07-22 23:40:15 +00001419 return bp->b_addr + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Nathan Scottce8e9222006-01-11 15:39:08 +11001421 offset += bp->b_offset;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001422 page = bp->b_pages[offset >> PAGE_SHIFT];
1423 return (xfs_caddr_t)page_address(page) + (offset & (PAGE_SIZE-1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424}
1425
1426/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 * Move data into or out of a buffer.
1428 */
1429void
Nathan Scottce8e9222006-01-11 15:39:08 +11001430xfs_buf_iomove(
1431 xfs_buf_t *bp, /* buffer to process */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 size_t boff, /* starting buffer offset */
1433 size_t bsize, /* length to copy */
Dave Chinnerb9c48642010-01-20 10:47:39 +11001434 void *data, /* data address */
Nathan Scottce8e9222006-01-11 15:39:08 +11001435 xfs_buf_rw_t mode) /* read/write/zero flag */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436{
Dave Chinner795cac72012-04-23 15:58:53 +10001437 size_t bend;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
1439 bend = boff + bsize;
1440 while (boff < bend) {
Dave Chinner795cac72012-04-23 15:58:53 +10001441 struct page *page;
1442 int page_index, page_offset, csize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443
Dave Chinner795cac72012-04-23 15:58:53 +10001444 page_index = (boff + bp->b_offset) >> PAGE_SHIFT;
1445 page_offset = (boff + bp->b_offset) & ~PAGE_MASK;
1446 page = bp->b_pages[page_index];
1447 csize = min_t(size_t, PAGE_SIZE - page_offset,
1448 BBTOB(bp->b_io_length) - boff);
1449
1450 ASSERT((csize + page_offset) <= PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
1452 switch (mode) {
Nathan Scottce8e9222006-01-11 15:39:08 +11001453 case XBRW_ZERO:
Dave Chinner795cac72012-04-23 15:58:53 +10001454 memset(page_address(page) + page_offset, 0, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001456 case XBRW_READ:
Dave Chinner795cac72012-04-23 15:58:53 +10001457 memcpy(data, page_address(page) + page_offset, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 break;
Nathan Scottce8e9222006-01-11 15:39:08 +11001459 case XBRW_WRITE:
Dave Chinner795cac72012-04-23 15:58:53 +10001460 memcpy(page_address(page) + page_offset, data, csize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 }
1462
1463 boff += csize;
1464 data += csize;
1465 }
1466}
1467
1468/*
Nathan Scottce8e9222006-01-11 15:39:08 +11001469 * Handling of buffer targets (buftargs).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 */
1471
1472/*
Dave Chinner430cbeb2010-12-02 16:30:55 +11001473 * Wait for any bufs with callbacks that have been submitted but have not yet
1474 * returned. These buffers will have an elevated hold count, so wait on those
1475 * while freeing all the buffers only held by the LRU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001477static enum lru_status
1478xfs_buftarg_wait_rele(
1479 struct list_head *item,
1480 spinlock_t *lru_lock,
1481 void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
Dave Chinnere80dfa12013-08-28 10:18:05 +10001483{
1484 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
Dave Chinnera4082352013-08-28 10:18:06 +10001485 struct list_head *dispose = arg;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001486
1487 if (atomic_read(&bp->b_hold) > 1) {
Dave Chinnera4082352013-08-28 10:18:06 +10001488 /* need to wait, so skip it this pass */
Dave Chinnere80dfa12013-08-28 10:18:05 +10001489 trace_xfs_buf_wait_buftarg(bp, _RET_IP_);
Dave Chinnera4082352013-08-28 10:18:06 +10001490 return LRU_SKIP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 }
Dave Chinnera4082352013-08-28 10:18:06 +10001492 if (!spin_trylock(&bp->b_lock))
1493 return LRU_SKIP;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001494
Dave Chinnera4082352013-08-28 10:18:06 +10001495 /*
1496 * clear the LRU reference count so the buffer doesn't get
1497 * ignored in xfs_buf_rele().
1498 */
1499 atomic_set(&bp->b_lru_ref, 0);
1500 bp->b_state |= XFS_BSTATE_DISPOSE;
1501 list_move(item, dispose);
1502 spin_unlock(&bp->b_lock);
1503 return LRU_REMOVED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504}
1505
Dave Chinnere80dfa12013-08-28 10:18:05 +10001506void
1507xfs_wait_buftarg(
1508 struct xfs_buftarg *btp)
1509{
Dave Chinnera4082352013-08-28 10:18:06 +10001510 LIST_HEAD(dispose);
1511 int loop = 0;
1512
1513 /* loop until there is nothing left on the lru list. */
1514 while (list_lru_count(&btp->bt_lru)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001515 list_lru_walk(&btp->bt_lru, xfs_buftarg_wait_rele,
Dave Chinnera4082352013-08-28 10:18:06 +10001516 &dispose, LONG_MAX);
1517
1518 while (!list_empty(&dispose)) {
1519 struct xfs_buf *bp;
1520 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1521 list_del_init(&bp->b_lru);
Dave Chinnerac8809f2013-12-12 16:34:38 +11001522 if (bp->b_flags & XBF_WRITE_FAIL) {
1523 xfs_alert(btp->bt_mount,
1524"Corruption Alert: Buffer at block 0x%llx had permanent write failures!\n"
1525"Please run xfs_repair to determine the extent of the problem.",
1526 (long long)bp->b_bn);
1527 }
Dave Chinnera4082352013-08-28 10:18:06 +10001528 xfs_buf_rele(bp);
1529 }
1530 if (loop++ != 0)
1531 delay(100);
1532 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001533}
1534
1535static enum lru_status
1536xfs_buftarg_isolate(
1537 struct list_head *item,
1538 spinlock_t *lru_lock,
1539 void *arg)
1540{
1541 struct xfs_buf *bp = container_of(item, struct xfs_buf, b_lru);
1542 struct list_head *dispose = arg;
1543
1544 /*
Dave Chinnera4082352013-08-28 10:18:06 +10001545 * we are inverting the lru lock/bp->b_lock here, so use a trylock.
1546 * If we fail to get the lock, just skip it.
1547 */
1548 if (!spin_trylock(&bp->b_lock))
1549 return LRU_SKIP;
1550 /*
Dave Chinnere80dfa12013-08-28 10:18:05 +10001551 * Decrement the b_lru_ref count unless the value is already
1552 * zero. If the value is already zero, we need to reclaim the
1553 * buffer, otherwise it gets another trip through the LRU.
1554 */
Dave Chinnera4082352013-08-28 10:18:06 +10001555 if (!atomic_add_unless(&bp->b_lru_ref, -1, 0)) {
1556 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001557 return LRU_ROTATE;
Dave Chinnera4082352013-08-28 10:18:06 +10001558 }
Dave Chinnere80dfa12013-08-28 10:18:05 +10001559
Dave Chinnera4082352013-08-28 10:18:06 +10001560 bp->b_state |= XFS_BSTATE_DISPOSE;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001561 list_move(item, dispose);
Dave Chinnera4082352013-08-28 10:18:06 +10001562 spin_unlock(&bp->b_lock);
Dave Chinnere80dfa12013-08-28 10:18:05 +10001563 return LRU_REMOVED;
1564}
1565
Andrew Mortonaddbda42013-08-28 10:18:06 +10001566static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001567xfs_buftarg_shrink_scan(
Dave Chinnerff57ab22010-11-30 17:27:57 +11001568 struct shrinker *shrink,
Ying Han1495f232011-05-24 17:12:27 -07001569 struct shrink_control *sc)
David Chinnera6867a62006-01-11 15:37:58 +11001570{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001571 struct xfs_buftarg *btp = container_of(shrink,
1572 struct xfs_buftarg, bt_shrinker);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001573 LIST_HEAD(dispose);
Andrew Mortonaddbda42013-08-28 10:18:06 +10001574 unsigned long freed;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001575 unsigned long nr_to_scan = sc->nr_to_scan;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001576
Dave Chinnere80dfa12013-08-28 10:18:05 +10001577 freed = list_lru_walk_node(&btp->bt_lru, sc->nid, xfs_buftarg_isolate,
1578 &dispose, &nr_to_scan);
Dave Chinner430cbeb2010-12-02 16:30:55 +11001579
1580 while (!list_empty(&dispose)) {
Dave Chinnere80dfa12013-08-28 10:18:05 +10001581 struct xfs_buf *bp;
Dave Chinner430cbeb2010-12-02 16:30:55 +11001582 bp = list_first_entry(&dispose, struct xfs_buf, b_lru);
1583 list_del_init(&bp->b_lru);
1584 xfs_buf_rele(bp);
1585 }
1586
Dave Chinnere80dfa12013-08-28 10:18:05 +10001587 return freed;
1588}
1589
Andrew Mortonaddbda42013-08-28 10:18:06 +10001590static unsigned long
Dave Chinnere80dfa12013-08-28 10:18:05 +10001591xfs_buftarg_shrink_count(
1592 struct shrinker *shrink,
1593 struct shrink_control *sc)
1594{
1595 struct xfs_buftarg *btp = container_of(shrink,
1596 struct xfs_buftarg, bt_shrinker);
1597 return list_lru_count_node(&btp->bt_lru, sc->nid);
David Chinnera6867a62006-01-11 15:37:58 +11001598}
1599
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600void
1601xfs_free_buftarg(
Christoph Hellwigb7963132009-03-03 14:48:37 -05001602 struct xfs_mount *mp,
1603 struct xfs_buftarg *btp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604{
Dave Chinnerff57ab22010-11-30 17:27:57 +11001605 unregister_shrinker(&btp->bt_shrinker);
Glauber Costaf5e1dd32013-08-28 10:18:18 +10001606 list_lru_destroy(&btp->bt_lru);
Dave Chinnerff57ab22010-11-30 17:27:57 +11001607
Christoph Hellwigb7963132009-03-03 14:48:37 -05001608 if (mp->m_flags & XFS_MOUNT_BARRIER)
1609 xfs_blkdev_issue_flush(btp);
David Chinnera6867a62006-01-11 15:37:58 +11001610
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001611 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612}
1613
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001614int
1615xfs_setsize_buftarg(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 xfs_buftarg_t *btp,
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001617 unsigned int sectorsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618{
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001619 /* Set up metadata sector size info */
Eric Sandeen6da54172014-01-21 16:45:52 -06001620 btp->bt_meta_sectorsize = sectorsize;
1621 btp->bt_meta_sectormask = sectorsize - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
Nathan Scottce8e9222006-01-11 15:39:08 +11001623 if (set_blocksize(btp->bt_bdev, sectorsize)) {
Christoph Hellwig02b102d2011-10-10 16:52:51 +00001624 char name[BDEVNAME_SIZE];
1625
1626 bdevname(btp->bt_bdev, name);
1627
Dave Chinner4f107002011-03-07 10:00:35 +11001628 xfs_warn(btp->bt_mount,
Eric Sandeen08e96e12013-10-11 20:59:05 -05001629 "Cannot set_blocksize to %u on device %s",
Christoph Hellwig02b102d2011-10-10 16:52:51 +00001630 sectorsize, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 return EINVAL;
1632 }
1633
Eric Sandeen7c71ee72014-01-21 16:46:23 -06001634 /* Set up device logical sector size mask */
1635 btp->bt_logical_sectorsize = bdev_logical_block_size(btp->bt_bdev);
1636 btp->bt_logical_sectormask = bdev_logical_block_size(btp->bt_bdev) - 1;
1637
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 return 0;
1639}
1640
1641/*
Eric Sandeen3fefdee2013-11-13 14:53:45 -06001642 * When allocating the initial buffer target we have not yet
1643 * read in the superblock, so don't know what sized sectors
1644 * are being used at this early stage. Play safe.
Nathan Scottce8e9222006-01-11 15:39:08 +11001645 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646STATIC int
1647xfs_setsize_buftarg_early(
1648 xfs_buftarg_t *btp,
1649 struct block_device *bdev)
1650{
Eric Sandeena96c4152014-04-14 19:00:29 +10001651 return xfs_setsize_buftarg(btp, bdev_logical_block_size(bdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652}
1653
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654xfs_buftarg_t *
1655xfs_alloc_buftarg(
Dave Chinnerebad8612010-09-22 10:47:20 +10001656 struct xfs_mount *mp,
Eric Sandeen34dcefd2014-04-14 19:01:00 +10001657 struct block_device *bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658{
1659 xfs_buftarg_t *btp;
1660
Dave Chinnerb17cb362013-05-20 09:51:12 +10001661 btp = kmem_zalloc(sizeof(*btp), KM_SLEEP | KM_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Dave Chinnerebad8612010-09-22 10:47:20 +10001663 btp->bt_mount = mp;
Nathan Scottce8e9222006-01-11 15:39:08 +11001664 btp->bt_dev = bdev->bd_dev;
1665 btp->bt_bdev = bdev;
Dave Chinner0e6e8472011-03-26 09:16:45 +11001666 btp->bt_bdi = blk_get_backing_dev_info(bdev);
1667 if (!btp->bt_bdi)
1668 goto error;
1669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 if (xfs_setsize_buftarg_early(btp, bdev))
1671 goto error;
Glauber Costa5ca302c2013-08-28 10:18:18 +10001672
1673 if (list_lru_init(&btp->bt_lru))
1674 goto error;
1675
Dave Chinnere80dfa12013-08-28 10:18:05 +10001676 btp->bt_shrinker.count_objects = xfs_buftarg_shrink_count;
1677 btp->bt_shrinker.scan_objects = xfs_buftarg_shrink_scan;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001678 btp->bt_shrinker.seeks = DEFAULT_SEEKS;
Dave Chinnere80dfa12013-08-28 10:18:05 +10001679 btp->bt_shrinker.flags = SHRINKER_NUMA_AWARE;
Dave Chinnerff57ab22010-11-30 17:27:57 +11001680 register_shrinker(&btp->bt_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 return btp;
1682
1683error:
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001684 kmem_free(btp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 return NULL;
1686}
1687
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688/*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001689 * Add a buffer to the delayed write list.
1690 *
1691 * This queues a buffer for writeout if it hasn't already been. Note that
1692 * neither this routine nor the buffer list submission functions perform
1693 * any internal synchronization. It is expected that the lists are thread-local
1694 * to the callers.
1695 *
1696 * Returns true if we queued up the buffer, or false if it already had
1697 * been on the buffer list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001699bool
Nathan Scottce8e9222006-01-11 15:39:08 +11001700xfs_buf_delwri_queue(
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001701 struct xfs_buf *bp,
1702 struct list_head *list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001704 ASSERT(xfs_buf_islocked(bp));
1705 ASSERT(!(bp->b_flags & XBF_READ));
1706
1707 /*
1708 * If the buffer is already marked delwri it already is queued up
1709 * by someone else for imediate writeout. Just ignore it in that
1710 * case.
1711 */
1712 if (bp->b_flags & _XBF_DELWRI_Q) {
1713 trace_xfs_buf_delwri_queued(bp, _RET_IP_);
1714 return false;
1715 }
David Chinnera6867a62006-01-11 15:37:58 +11001716
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001717 trace_xfs_buf_delwri_queue(bp, _RET_IP_);
1718
Dave Chinnerd808f612010-02-02 10:13:42 +11001719 /*
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001720 * If a buffer gets written out synchronously or marked stale while it
1721 * is on a delwri list we lazily remove it. To do this, the other party
1722 * clears the _XBF_DELWRI_Q flag but otherwise leaves the buffer alone.
1723 * It remains referenced and on the list. In a rare corner case it
1724 * might get readded to a delwri list after the synchronous writeout, in
1725 * which case we need just need to re-add the flag here.
Dave Chinnerd808f612010-02-02 10:13:42 +11001726 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001727 bp->b_flags |= _XBF_DELWRI_Q;
1728 if (list_empty(&bp->b_list)) {
1729 atomic_inc(&bp->b_hold);
1730 list_add_tail(&bp->b_list, list);
David Chinner585e6d82007-02-10 18:32:29 +11001731 }
David Chinner585e6d82007-02-10 18:32:29 +11001732
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001733 return true;
David Chinner585e6d82007-02-10 18:32:29 +11001734}
1735
Dave Chinner089716a2010-01-26 15:13:25 +11001736/*
1737 * Compare function is more complex than it needs to be because
1738 * the return value is only 32 bits and we are doing comparisons
1739 * on 64 bit values
1740 */
1741static int
1742xfs_buf_cmp(
1743 void *priv,
1744 struct list_head *a,
1745 struct list_head *b)
1746{
1747 struct xfs_buf *ap = container_of(a, struct xfs_buf, b_list);
1748 struct xfs_buf *bp = container_of(b, struct xfs_buf, b_list);
1749 xfs_daddr_t diff;
1750
Mark Tinguelyf4b42422012-12-04 17:18:02 -06001751 diff = ap->b_maps[0].bm_bn - bp->b_maps[0].bm_bn;
Dave Chinner089716a2010-01-26 15:13:25 +11001752 if (diff < 0)
1753 return -1;
1754 if (diff > 0)
1755 return 1;
1756 return 0;
1757}
1758
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001759static int
1760__xfs_buf_delwri_submit(
1761 struct list_head *buffer_list,
1762 struct list_head *io_list,
1763 bool wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001765 struct blk_plug plug;
1766 struct xfs_buf *bp, *n;
1767 int pinned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001769 list_for_each_entry_safe(bp, n, buffer_list, b_list) {
1770 if (!wait) {
1771 if (xfs_buf_ispinned(bp)) {
1772 pinned++;
1773 continue;
1774 }
1775 if (!xfs_buf_trylock(bp))
1776 continue;
1777 } else {
1778 xfs_buf_lock(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001781 /*
1782 * Someone else might have written the buffer synchronously or
1783 * marked it stale in the meantime. In that case only the
1784 * _XBF_DELWRI_Q flag got cleared, and we have to drop the
1785 * reference and remove it from the list here.
1786 */
1787 if (!(bp->b_flags & _XBF_DELWRI_Q)) {
1788 list_del_init(&bp->b_list);
1789 xfs_buf_relse(bp);
1790 continue;
1791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001793 list_move_tail(&bp->b_list, io_list);
1794 trace_xfs_buf_delwri_split(bp, _RET_IP_);
1795 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001797 list_sort(NULL, io_list, xfs_buf_cmp);
Christoph Hellwiga1b7ea52011-03-30 11:05:09 +00001798
1799 blk_start_plug(&plug);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001800 list_for_each_entry_safe(bp, n, io_list, b_list) {
Dave Chinnerac8809f2013-12-12 16:34:38 +11001801 bp->b_flags &= ~(_XBF_DELWRI_Q | XBF_ASYNC | XBF_WRITE_FAIL);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001802 bp->b_flags |= XBF_WRITE;
1803
1804 if (!wait) {
1805 bp->b_flags |= XBF_ASYNC;
1806 list_del_init(&bp->b_list);
Dave Chinner089716a2010-01-26 15:13:25 +11001807 }
Christoph Hellwig939d7232010-07-20 17:51:16 +10001808 xfs_bdstrat_cb(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 }
Christoph Hellwiga1b7ea52011-03-30 11:05:09 +00001810 blk_finish_plug(&plug);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001812 return pinned;
1813}
Nathan Scottf07c2252006-09-28 10:52:15 +10001814
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001815/*
1816 * Write out a buffer list asynchronously.
1817 *
1818 * This will take the @buffer_list, write all non-locked and non-pinned buffers
1819 * out and not wait for I/O completion on any of the buffers. This interface
1820 * is only safely useable for callers that can track I/O completion by higher
1821 * level means, e.g. AIL pushing as the @buffer_list is consumed in this
1822 * function.
1823 */
1824int
1825xfs_buf_delwri_submit_nowait(
1826 struct list_head *buffer_list)
1827{
1828 LIST_HEAD (io_list);
1829 return __xfs_buf_delwri_submit(buffer_list, &io_list, false);
1830}
1831
1832/*
1833 * Write out a buffer list synchronously.
1834 *
1835 * This will take the @buffer_list, write all buffers out and wait for I/O
1836 * completion on all of the buffers. @buffer_list is consumed by the function,
1837 * so callers must have some other way of tracking buffers if they require such
1838 * functionality.
1839 */
1840int
1841xfs_buf_delwri_submit(
1842 struct list_head *buffer_list)
1843{
1844 LIST_HEAD (io_list);
1845 int error = 0, error2;
1846 struct xfs_buf *bp;
1847
1848 __xfs_buf_delwri_submit(buffer_list, &io_list, true);
1849
1850 /* Wait for IO to complete. */
1851 while (!list_empty(&io_list)) {
1852 bp = list_first_entry(&io_list, struct xfs_buf, b_list);
1853
1854 list_del_init(&bp->b_list);
1855 error2 = xfs_buf_iowait(bp);
1856 xfs_buf_relse(bp);
1857 if (!error)
1858 error = error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 }
1860
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001861 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862}
1863
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001864int __init
Nathan Scottce8e9222006-01-11 15:39:08 +11001865xfs_buf_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866{
Nathan Scott87582802006-03-14 13:18:19 +11001867 xfs_buf_zone = kmem_zone_init_flags(sizeof(xfs_buf_t), "xfs_buf",
1868 KM_ZONE_HWALIGN, NULL);
Nathan Scottce8e9222006-01-11 15:39:08 +11001869 if (!xfs_buf_zone)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001870 goto out;
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001871
Dave Chinner51749e42010-09-08 09:00:22 +00001872 xfslogd_workqueue = alloc_workqueue("xfslogd",
Tejun Heo6370a6a2010-10-11 15:12:27 +02001873 WQ_MEM_RECLAIM | WQ_HIGHPRI, 1);
Christoph Hellwig23ea4032005-06-21 15:14:01 +10001874 if (!xfslogd_workqueue)
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001875 goto out_free_buf_zone;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876
Christoph Hellwig23ea4032005-06-21 15:14:01 +10001877 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878
Christoph Hellwig23ea4032005-06-21 15:14:01 +10001879 out_free_buf_zone:
Nathan Scottce8e9222006-01-11 15:39:08 +11001880 kmem_zone_destroy(xfs_buf_zone);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001881 out:
Nathan Scott87582802006-03-14 13:18:19 +11001882 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883}
1884
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885void
Nathan Scottce8e9222006-01-11 15:39:08 +11001886xfs_buf_terminate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887{
Christoph Hellwig04d8b282005-11-02 10:15:05 +11001888 destroy_workqueue(xfslogd_workqueue);
Nathan Scottce8e9222006-01-11 15:39:08 +11001889 kmem_zone_destroy(xfs_buf_zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890}