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