blob: 0f14b2e4bf6cb03b803ff42abbf1c026fc74c70d [file] [log] [blame]
Christoph Hellwig52785112015-02-16 11:49:23 +11001/*
2 * Copyright (c) 2014 Christoph Hellwig.
3 */
Christoph Hellwig199a31c2016-06-21 09:22:39 +10004#include <linux/iomap.h>
Christoph Hellwig52785112015-02-16 11:49:23 +11005#include "xfs.h"
6#include "xfs_format.h"
7#include "xfs_log_format.h"
8#include "xfs_trans_resv.h"
9#include "xfs_sb.h"
10#include "xfs_mount.h"
11#include "xfs_inode.h"
12#include "xfs_trans.h"
13#include "xfs_log.h"
14#include "xfs_bmap.h"
15#include "xfs_bmap_util.h"
16#include "xfs_error.h"
17#include "xfs_iomap.h"
18#include "xfs_shared.h"
19#include "xfs_bit.h"
20#include "xfs_pnfs.h"
21
22/*
Christoph Hellwig781355c2015-02-16 11:59:50 +110023 * Ensure that we do not have any outstanding pNFS layouts that can be used by
24 * clients to directly read from or write to this inode. This must be called
25 * before every operation that can remove blocks from the extent map.
26 * Additionally we call it during the write operation, where aren't concerned
27 * about exposing unallocated blocks but just want to provide basic
28 * synchronization between a local writer and pNFS clients. mmap writes would
29 * also benefit from this sort of synchronization, but due to the tricky locking
30 * rules in the page fault path we don't bother.
31 */
32int
33xfs_break_layouts(
34 struct inode *inode,
Christoph Hellwig21c3ea12015-04-13 11:38:29 +100035 uint *iolock,
36 bool with_imutex)
Christoph Hellwig781355c2015-02-16 11:59:50 +110037{
38 struct xfs_inode *ip = XFS_I(inode);
39 int error;
40
41 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL));
42
43 while ((error = break_layout(inode, false) == -EWOULDBLOCK)) {
44 xfs_iunlock(ip, *iolock);
Christoph Hellwig21c3ea12015-04-13 11:38:29 +100045 if (with_imutex && (*iolock & XFS_IOLOCK_EXCL))
Al Viro59551022016-01-22 15:40:57 -050046 inode_unlock(inode);
Christoph Hellwig781355c2015-02-16 11:59:50 +110047 error = break_layout(inode, true);
48 *iolock = XFS_IOLOCK_EXCL;
Christoph Hellwig21c3ea12015-04-13 11:38:29 +100049 if (with_imutex)
Al Viro59551022016-01-22 15:40:57 -050050 inode_lock(inode);
Christoph Hellwig781355c2015-02-16 11:59:50 +110051 xfs_ilock(ip, *iolock);
52 }
53
54 return error;
55}
56
57/*
Christoph Hellwig52785112015-02-16 11:49:23 +110058 * Get a unique ID including its location so that the client can identify
59 * the exported device.
60 */
61int
62xfs_fs_get_uuid(
63 struct super_block *sb,
64 u8 *buf,
65 u32 *len,
66 u64 *offset)
67{
68 struct xfs_mount *mp = XFS_M(sb);
69
70 printk_once(KERN_NOTICE
71"XFS (%s): using experimental pNFS feature, use at your own risk!\n",
72 mp->m_fsname);
73
74 if (*len < sizeof(uuid_t))
75 return -EINVAL;
76
77 memcpy(buf, &mp->m_sb.sb_uuid, sizeof(uuid_t));
78 *len = sizeof(uuid_t);
79 *offset = offsetof(struct xfs_dsb, sb_uuid);
80 return 0;
81}
82
Christoph Hellwig52785112015-02-16 11:49:23 +110083/*
84 * Get a layout for the pNFS client.
85 */
86int
87xfs_fs_map_blocks(
88 struct inode *inode,
89 loff_t offset,
90 u64 length,
91 struct iomap *iomap,
92 bool write,
93 u32 *device_generation)
94{
95 struct xfs_inode *ip = XFS_I(inode);
96 struct xfs_mount *mp = ip->i_mount;
97 struct xfs_bmbt_irec imap;
98 xfs_fileoff_t offset_fsb, end_fsb;
99 loff_t limit;
100 int bmapi_flags = XFS_BMAPI_ENTIRE;
101 int nimaps = 1;
102 uint lock_flags;
103 int error = 0;
104
105 if (XFS_FORCED_SHUTDOWN(mp))
106 return -EIO;
107
108 /*
109 * We can't export inodes residing on the realtime device. The realtime
110 * device doesn't have a UUID to identify it, so the client has no way
111 * to find it.
112 */
113 if (XFS_IS_REALTIME_INODE(ip))
114 return -ENXIO;
115
116 /*
117 * Lock out any other I/O before we flush and invalidate the pagecache,
118 * and then hand out a layout to the remote system. This is very
119 * similar to direct I/O, except that the synchronization is much more
120 * complicated. See the comment near xfs_break_layouts for a detailed
121 * explanation.
122 */
123 xfs_ilock(ip, XFS_IOLOCK_EXCL);
124
125 error = -EINVAL;
126 limit = mp->m_super->s_maxbytes;
127 if (!write)
128 limit = max(limit, round_up(i_size_read(inode),
129 inode->i_sb->s_blocksize));
130 if (offset > limit)
131 goto out_unlock;
132 if (offset > limit - length)
133 length = limit - offset;
134
135 error = filemap_write_and_wait(inode->i_mapping);
136 if (error)
137 goto out_unlock;
138 error = invalidate_inode_pages2(inode->i_mapping);
139 if (WARN_ON_ONCE(error))
140 return error;
141
142 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + length);
143 offset_fsb = XFS_B_TO_FSBT(mp, offset);
144
145 lock_flags = xfs_ilock_data_map_shared(ip);
146 error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
147 &imap, &nimaps, bmapi_flags);
148 xfs_iunlock(ip, lock_flags);
149
150 if (error)
151 goto out_unlock;
152
153 if (write) {
154 enum xfs_prealloc_flags flags = 0;
155
156 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
157
158 if (!nimaps || imap.br_startblock == HOLESTARTBLOCK) {
Brian Foster009c6e82015-10-12 15:34:20 +1100159 /*
160 * xfs_iomap_write_direct() expects to take ownership of
161 * the shared ilock.
162 */
163 xfs_ilock(ip, XFS_ILOCK_SHARED);
Christoph Hellwig52785112015-02-16 11:49:23 +1100164 error = xfs_iomap_write_direct(ip, offset, length,
165 &imap, nimaps);
166 if (error)
167 goto out_unlock;
168
169 /*
170 * Ensure the next transaction is committed
171 * synchronously so that the blocks allocated and
172 * handed out to the client are guaranteed to be
173 * present even after a server crash.
174 */
175 flags |= XFS_PREALLOC_SET | XFS_PREALLOC_SYNC;
176 }
177
178 error = xfs_update_prealloc_flags(ip, flags);
179 if (error)
180 goto out_unlock;
181 }
182 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
183
184 xfs_bmbt_to_iomap(ip, iomap, &imap);
185 *device_generation = mp->m_generation;
186 return error;
187out_unlock:
188 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
189 return error;
190}
191
192/*
193 * Ensure the size update falls into a valid allocated block.
194 */
195static int
196xfs_pnfs_validate_isize(
197 struct xfs_inode *ip,
198 xfs_off_t isize)
199{
200 struct xfs_bmbt_irec imap;
201 int nimaps = 1;
202 int error = 0;
203
204 xfs_ilock(ip, XFS_ILOCK_SHARED);
205 error = xfs_bmapi_read(ip, XFS_B_TO_FSBT(ip->i_mount, isize - 1), 1,
206 &imap, &nimaps, 0);
207 xfs_iunlock(ip, XFS_ILOCK_SHARED);
208 if (error)
209 return error;
210
211 if (imap.br_startblock == HOLESTARTBLOCK ||
212 imap.br_startblock == DELAYSTARTBLOCK ||
213 imap.br_state == XFS_EXT_UNWRITTEN)
214 return -EIO;
215 return 0;
216}
217
218/*
219 * Make sure the blocks described by maps are stable on disk. This includes
220 * converting any unwritten extents, flushing the disk cache and updating the
221 * time stamps.
222 *
223 * Note that we rely on the caller to always send us a timestamp update so that
224 * we always commit a transaction here. If that stops being true we will have
225 * to manually flush the cache here similar to what the fsync code path does
226 * for datasyncs on files that have no dirty metadata.
227 */
228int
229xfs_fs_commit_blocks(
230 struct inode *inode,
231 struct iomap *maps,
232 int nr_maps,
233 struct iattr *iattr)
234{
235 struct xfs_inode *ip = XFS_I(inode);
236 struct xfs_mount *mp = ip->i_mount;
237 struct xfs_trans *tp;
238 bool update_isize = false;
239 int error, i;
240 loff_t size;
241
242 ASSERT(iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME));
243
244 xfs_ilock(ip, XFS_IOLOCK_EXCL);
245
246 size = i_size_read(inode);
247 if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size > size) {
248 update_isize = true;
249 size = iattr->ia_size;
250 }
251
252 for (i = 0; i < nr_maps; i++) {
253 u64 start, length, end;
254
255 start = maps[i].offset;
256 if (start > size)
257 continue;
258
259 end = start + maps[i].length;
260 if (end > size)
261 end = size;
262
263 length = end - start;
264 if (!length)
265 continue;
266
267 /*
268 * Make sure reads through the pagecache see the new data.
269 */
270 error = invalidate_inode_pages2_range(inode->i_mapping,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300271 start >> PAGE_SHIFT,
272 (end - 1) >> PAGE_SHIFT);
Christoph Hellwig52785112015-02-16 11:49:23 +1100273 WARN_ON_ONCE(error);
274
275 error = xfs_iomap_write_unwritten(ip, start, length);
276 if (error)
277 goto out_drop_iolock;
278 }
279
280 if (update_isize) {
281 error = xfs_pnfs_validate_isize(ip, size);
282 if (error)
283 goto out_drop_iolock;
284 }
285
Christoph Hellwig253f4912016-04-06 09:19:55 +1000286 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
287 if (error)
Christoph Hellwig52785112015-02-16 11:49:23 +1100288 goto out_drop_iolock;
Christoph Hellwig52785112015-02-16 11:49:23 +1100289
290 xfs_ilock(ip, XFS_ILOCK_EXCL);
291 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
292 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
293
294 xfs_setattr_time(ip, iattr);
295 if (update_isize) {
296 i_size_write(inode, iattr->ia_size);
297 ip->i_d.di_size = iattr->ia_size;
298 }
299
300 xfs_trans_set_sync(tp);
Christoph Hellwig70393312015-06-04 13:48:08 +1000301 error = xfs_trans_commit(tp);
Christoph Hellwig52785112015-02-16 11:49:23 +1100302
303out_drop_iolock:
304 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
305 return error;
306}