Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://oss.sgi.com:8090/oss/git/xfs-2.6
* git://oss.sgi.com:8090/oss/git/xfs-2.6:
[XFS] Provide XFS support for the splice syscall.
[XFS] Reenable write barriers by default.
[XFS] Make project quota enforcement return an error code consistent with
[XFS] Implement the silent parameter to fill_super, previously ignored.
[XFS] Cleanup comment to remove reference to obsoleted function
+312
-166
+80
-33
fs/xfs/linux-2.6/xfs_file.c
+80
-33
fs/xfs/linux-2.6/xfs_file.c
···
69
69
return rval;
70
70
}
71
71
72
-
73
72
STATIC ssize_t
74
73
xfs_file_aio_read(
75
74
struct kiocb *iocb,
···
88
89
{
89
90
return __xfs_file_read(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
90
91
}
91
-
92
92
93
93
STATIC inline ssize_t
94
94
__xfs_file_write(
···
111
113
return rval;
112
114
}
113
115
114
-
115
116
STATIC ssize_t
116
117
xfs_file_aio_write(
117
118
struct kiocb *iocb,
···
130
133
{
131
134
return __xfs_file_write(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
132
135
}
133
-
134
136
135
137
STATIC inline ssize_t
136
138
__xfs_file_readv(
···
175
179
return __xfs_file_readv(file, iov, IO_INVIS, nr_segs, ppos);
176
180
}
177
181
178
-
179
182
STATIC inline ssize_t
180
183
__xfs_file_writev(
181
184
struct file *file,
···
199
204
return rval;
200
205
}
201
206
202
-
203
207
STATIC ssize_t
204
208
xfs_file_writev(
205
209
struct file *file,
···
222
228
STATIC ssize_t
223
229
xfs_file_sendfile(
224
230
struct file *filp,
225
-
loff_t *ppos,
231
+
loff_t *pos,
226
232
size_t count,
227
233
read_actor_t actor,
228
234
void *target)
···
230
236
vnode_t *vp = vn_from_inode(filp->f_dentry->d_inode);
231
237
ssize_t rval;
232
238
233
-
VOP_SENDFILE(vp, filp, ppos, 0, count, actor, target, NULL, rval);
239
+
VOP_SENDFILE(vp, filp, pos, 0, count, actor, target, NULL, rval);
234
240
return rval;
235
241
}
236
242
243
+
STATIC ssize_t
244
+
xfs_file_sendfile_invis(
245
+
struct file *filp,
246
+
loff_t *pos,
247
+
size_t count,
248
+
read_actor_t actor,
249
+
void *target)
250
+
{
251
+
vnode_t *vp = vn_from_inode(filp->f_dentry->d_inode);
252
+
ssize_t rval;
253
+
254
+
VOP_SENDFILE(vp, filp, pos, IO_INVIS, count, actor, target, NULL, rval);
255
+
return rval;
256
+
}
257
+
258
+
STATIC ssize_t
259
+
xfs_file_splice_read(
260
+
struct file *infilp,
261
+
struct inode *pipe,
262
+
size_t len,
263
+
unsigned int flags)
264
+
{
265
+
vnode_t *vp = vn_from_inode(infilp->f_dentry->d_inode);
266
+
ssize_t rval;
267
+
268
+
VOP_SPLICE_READ(vp, infilp, pipe, len, flags, 0, NULL, rval);
269
+
return rval;
270
+
}
271
+
272
+
STATIC ssize_t
273
+
xfs_file_splice_read_invis(
274
+
struct file *infilp,
275
+
struct inode *pipe,
276
+
size_t len,
277
+
unsigned int flags)
278
+
{
279
+
vnode_t *vp = vn_from_inode(infilp->f_dentry->d_inode);
280
+
ssize_t rval;
281
+
282
+
VOP_SPLICE_READ(vp, infilp, pipe, len, flags, IO_INVIS, NULL, rval);
283
+
return rval;
284
+
}
285
+
286
+
STATIC ssize_t
287
+
xfs_file_splice_write(
288
+
struct inode *pipe,
289
+
struct file *outfilp,
290
+
size_t len,
291
+
unsigned int flags)
292
+
{
293
+
vnode_t *vp = vn_from_inode(outfilp->f_dentry->d_inode);
294
+
ssize_t rval;
295
+
296
+
VOP_SPLICE_WRITE(vp, pipe, outfilp, len, flags, 0, NULL, rval);
297
+
return rval;
298
+
}
299
+
300
+
STATIC ssize_t
301
+
xfs_file_splice_write_invis(
302
+
struct inode *pipe,
303
+
struct file *outfilp,
304
+
size_t len,
305
+
unsigned int flags)
306
+
{
307
+
vnode_t *vp = vn_from_inode(outfilp->f_dentry->d_inode);
308
+
ssize_t rval;
309
+
310
+
VOP_SPLICE_WRITE(vp, pipe, outfilp, len, flags, IO_INVIS, NULL, rval);
311
+
return rval;
312
+
}
237
313
238
314
STATIC int
239
315
xfs_file_open(
···
315
251
316
252
if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
317
253
return -EFBIG;
318
-
319
-
ASSERT(vp);
320
254
VOP_OPEN(vp, NULL, error);
321
255
return -error;
322
256
}
323
-
324
257
325
258
STATIC int
326
259
xfs_file_release(
···
332
271
return -error;
333
272
}
334
273
335
-
336
274
STATIC int
337
275
xfs_file_fsync(
338
276
struct file *filp,
···
345
285
346
286
if (datasync)
347
287
flags |= FSYNC_DATA;
348
-
349
-
ASSERT(vp);
350
288
VOP_FSYNC(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1, error);
351
289
return -error;
352
290
}
353
291
354
-
/*
355
-
* xfs_file_readdir maps to VOP_READDIR().
356
-
* We need to build a uio, cred, ...
357
-
*/
358
-
359
-
#define nextdp(dp) ((struct xfs_dirent *)((char *)(dp) + (dp)->d_reclen))
360
-
361
292
#ifdef CONFIG_XFS_DMAPI
362
-
363
293
STATIC struct page *
364
294
xfs_vm_nopage(
365
295
struct vm_area_struct *area,
···
369
319
370
320
return filemap_nopage(area, address, type);
371
321
}
372
-
373
322
#endif /* CONFIG_XFS_DMAPI */
374
-
375
323
376
324
STATIC int
377
325
xfs_file_readdir(
···
378
330
filldir_t filldir)
379
331
{
380
332
int error = 0;
381
-
vnode_t *vp;
333
+
vnode_t *vp = vn_from_inode(filp->f_dentry->d_inode);
382
334
uio_t uio;
383
335
iovec_t iov;
384
336
int eof = 0;
···
387
339
size_t rlen = PAGE_CACHE_SIZE;
388
340
xfs_off_t start_offset, curr_offset;
389
341
xfs_dirent_t *dbp = NULL;
390
-
391
-
vp = vn_from_inode(filp->f_dentry->d_inode);
392
-
ASSERT(vp);
393
342
394
343
/* Try fairly hard to get memory */
395
344
do {
···
432
387
}
433
388
size -= dbp->d_reclen;
434
389
curr_offset = (loff_t)dbp->d_off /* & 0x7fffffff */;
435
-
dbp = nextdp(dbp);
390
+
dbp = (xfs_dirent_t *)((char *)dbp + dbp->d_reclen);
436
391
}
437
392
}
438
393
done:
···
446
401
kfree(read_buf);
447
402
return -error;
448
403
}
449
-
450
404
451
405
STATIC int
452
406
xfs_file_mmap(
···
501
457
unsigned int cmd,
502
458
unsigned long arg)
503
459
{
504
-
int error;
505
460
struct inode *inode = filp->f_dentry->d_inode;
506
461
vnode_t *vp = vn_from_inode(inode);
462
+
int error;
507
463
508
-
ASSERT(vp);
509
464
VOP_IOCTL(vp, inode, filp, IO_INVIS, cmd, (void __user *)arg, error);
510
465
VMODIFY(vp);
511
466
···
580
537
.aio_read = xfs_file_aio_read,
581
538
.aio_write = xfs_file_aio_write,
582
539
.sendfile = xfs_file_sendfile,
540
+
.splice_read = xfs_file_splice_read,
541
+
.splice_write = xfs_file_splice_write,
583
542
.unlocked_ioctl = xfs_file_ioctl,
584
543
#ifdef CONFIG_COMPAT
585
544
.compat_ioctl = xfs_file_compat_ioctl,
···
603
558
.writev = xfs_file_writev_invis,
604
559
.aio_read = xfs_file_aio_read_invis,
605
560
.aio_write = xfs_file_aio_write_invis,
606
-
.sendfile = xfs_file_sendfile,
561
+
.sendfile = xfs_file_sendfile_invis,
562
+
.splice_read = xfs_file_splice_read_invis,
563
+
.splice_write = xfs_file_splice_write_invis,
607
564
.unlocked_ioctl = xfs_file_ioctl_invis,
608
565
#ifdef CONFIG_COMPAT
609
566
.compat_ioctl = xfs_file_compat_invis_ioctl,
+1
fs/xfs/linux-2.6/xfs_linux.h
+1
fs/xfs/linux-2.6/xfs_linux.h
···
103
103
*/
104
104
#undef HAVE_REFCACHE /* reference cache not needed for NFS in 2.6 */
105
105
#define HAVE_SENDFILE /* sendfile(2) exists in 2.6, but not in 2.4 */
106
+
#define HAVE_SPLICE /* a splice(2) exists in 2.6, but not in 2.4 */
106
107
#ifdef CONFIG_SMP
107
108
#define HAVE_PERCPU_SB /* per cpu superblock counters are a 2.6 feature */
108
109
#else
+96
-30
fs/xfs/linux-2.6/xfs_lrw.c
+96
-30
fs/xfs/linux-2.6/xfs_lrw.c
···
301
301
void *target,
302
302
cred_t *credp)
303
303
{
304
+
xfs_inode_t *ip = XFS_BHVTOI(bdp);
305
+
xfs_mount_t *mp = ip->i_mount;
304
306
ssize_t ret;
305
-
xfs_fsize_t n;
306
-
xfs_inode_t *ip;
307
-
xfs_mount_t *mp;
308
-
vnode_t *vp;
309
-
310
-
ip = XFS_BHVTOI(bdp);
311
-
vp = BHV_TO_VNODE(bdp);
312
-
mp = ip->i_mount;
313
307
314
308
XFS_STATS_INC(xs_read_calls);
315
-
316
-
n = XFS_MAXIOFFSET(mp) - *offset;
317
-
if ((n <= 0) || (count == 0))
318
-
return 0;
319
-
320
-
if (n < count)
321
-
count = n;
322
-
323
-
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
309
+
if (XFS_FORCED_SHUTDOWN(mp))
324
310
return -EIO;
325
311
326
312
xfs_ilock(ip, XFS_IOLOCK_SHARED);
327
313
328
-
if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ) &&
314
+
if (DM_EVENT_ENABLED(BHV_TO_VNODE(bdp)->v_vfsp, ip, DM_EVENT_READ) &&
329
315
(!(ioflags & IO_INVIS))) {
330
316
vrwlock_t locktype = VRWLOCK_READ;
331
317
int error;
332
318
333
-
error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp), *offset, count,
319
+
error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp),
320
+
*offset, count,
334
321
FILP_DELAY_FLAG(filp), &locktype);
335
322
if (error) {
336
323
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
···
327
340
xfs_rw_enter_trace(XFS_SENDFILE_ENTER, &ip->i_iocore,
328
341
(void *)(unsigned long)target, count, *offset, ioflags);
329
342
ret = generic_file_sendfile(filp, offset, count, actor, target);
330
-
331
-
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
332
-
333
343
if (ret > 0)
334
344
XFS_STATS_ADD(xs_read_bytes, ret);
335
345
346
+
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
347
+
return ret;
348
+
}
349
+
350
+
ssize_t
351
+
xfs_splice_read(
352
+
bhv_desc_t *bdp,
353
+
struct file *infilp,
354
+
struct inode *pipe,
355
+
size_t count,
356
+
int flags,
357
+
int ioflags,
358
+
cred_t *credp)
359
+
{
360
+
xfs_inode_t *ip = XFS_BHVTOI(bdp);
361
+
xfs_mount_t *mp = ip->i_mount;
362
+
ssize_t ret;
363
+
364
+
XFS_STATS_INC(xs_read_calls);
365
+
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
366
+
return -EIO;
367
+
368
+
xfs_ilock(ip, XFS_IOLOCK_SHARED);
369
+
370
+
if (DM_EVENT_ENABLED(BHV_TO_VNODE(bdp)->v_vfsp, ip, DM_EVENT_READ) &&
371
+
(!(ioflags & IO_INVIS))) {
372
+
vrwlock_t locktype = VRWLOCK_READ;
373
+
int error;
374
+
375
+
error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp),
376
+
infilp->f_pos, count,
377
+
FILP_DELAY_FLAG(infilp), &locktype);
378
+
if (error) {
379
+
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
380
+
return -error;
381
+
}
382
+
}
383
+
xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, &ip->i_iocore,
384
+
pipe, count, infilp->f_pos, ioflags);
385
+
ret = generic_file_splice_read(infilp, pipe, count, flags);
386
+
if (ret > 0)
387
+
XFS_STATS_ADD(xs_read_bytes, ret);
388
+
389
+
xfs_iunlock(ip, XFS_IOLOCK_SHARED);
390
+
return ret;
391
+
}
392
+
393
+
ssize_t
394
+
xfs_splice_write(
395
+
bhv_desc_t *bdp,
396
+
struct inode *pipe,
397
+
struct file *outfilp,
398
+
size_t count,
399
+
int flags,
400
+
int ioflags,
401
+
cred_t *credp)
402
+
{
403
+
xfs_inode_t *ip = XFS_BHVTOI(bdp);
404
+
xfs_mount_t *mp = ip->i_mount;
405
+
ssize_t ret;
406
+
407
+
XFS_STATS_INC(xs_write_calls);
408
+
if (XFS_FORCED_SHUTDOWN(ip->i_mount))
409
+
return -EIO;
410
+
411
+
xfs_ilock(ip, XFS_IOLOCK_EXCL);
412
+
413
+
if (DM_EVENT_ENABLED(BHV_TO_VNODE(bdp)->v_vfsp, ip, DM_EVENT_WRITE) &&
414
+
(!(ioflags & IO_INVIS))) {
415
+
vrwlock_t locktype = VRWLOCK_WRITE;
416
+
int error;
417
+
418
+
error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, BHV_TO_VNODE(bdp),
419
+
outfilp->f_pos, count,
420
+
FILP_DELAY_FLAG(outfilp), &locktype);
421
+
if (error) {
422
+
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
423
+
return -error;
424
+
}
425
+
}
426
+
xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, &ip->i_iocore,
427
+
pipe, count, outfilp->f_pos, ioflags);
428
+
ret = generic_file_splice_write(pipe, outfilp, count, flags);
429
+
if (ret > 0)
430
+
XFS_STATS_ADD(xs_write_bytes, ret);
431
+
432
+
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
336
433
return ret;
337
434
}
338
435
···
434
363
xfs_fsize_t end_size)
435
364
{
436
365
xfs_fileoff_t last_fsb;
437
-
xfs_mount_t *mp;
366
+
xfs_mount_t *mp = io->io_mount;
438
367
int nimaps;
439
368
int zero_offset;
440
369
int zero_len;
···
443
372
loff_t loff;
444
373
445
374
ASSERT(ismrlocked(io->io_lock, MR_UPDATE) != 0);
446
-
447
-
mp = io->io_mount;
448
375
449
376
zero_offset = XFS_B_FSB_OFFSET(mp, isize);
450
377
if (zero_offset == 0) {
···
474
405
* don't deadlock when the buffer cache calls back to us.
475
406
*/
476
407
XFS_IUNLOCK(mp, io, XFS_ILOCK_EXCL| XFS_EXTSIZE_RD);
408
+
477
409
loff = XFS_FSB_TO_B(mp, last_fsb);
478
-
479
410
zero_len = mp->m_sb.sb_blocksize - zero_offset;
480
-
481
411
error = xfs_iozero(ip, loff + zero_offset, zero_len, end_size);
482
412
483
413
XFS_ILOCK(mp, io, XFS_ILOCK_EXCL|XFS_EXTSIZE_RD);
···
509
441
xfs_fileoff_t zero_count_fsb;
510
442
xfs_fileoff_t last_fsb;
511
443
xfs_extlen_t buf_len_fsb;
512
-
xfs_mount_t *mp;
444
+
xfs_mount_t *mp = io->io_mount;
513
445
int nimaps;
514
446
int error = 0;
515
447
xfs_bmbt_irec_t imap;
···
517
449
ASSERT(ismrlocked(io->io_lock, MR_UPDATE));
518
450
ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));
519
451
ASSERT(offset > isize);
520
-
521
-
mp = io->io_mount;
522
452
523
453
/*
524
454
* First handle zeroing the block on which isize resides.
+9
-2
fs/xfs/linux-2.6/xfs_lrw.h
+9
-2
fs/xfs/linux-2.6/xfs_lrw.h
···
60
60
#define XFS_IOMAP_ALLOC_ENTER 25
61
61
#define XFS_IOMAP_ALLOC_MAP 26
62
62
#define XFS_IOMAP_UNWRITTEN 27
63
+
#define XFS_SPLICE_READ_ENTER 28
64
+
#define XFS_SPLICE_WRITE_ENTER 29
63
65
extern void xfs_rw_enter_trace(int, struct xfs_iocore *,
64
66
void *, size_t, loff_t, int);
65
67
extern void xfs_inval_cached_trace(struct xfs_iocore *,
···
80
78
struct xfs_iomap *, int *);
81
79
extern int xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
82
80
extern int xfs_bdstrat_cb(struct xfs_buf *);
81
+
extern int xfs_dev_is_read_only(struct xfs_mount *, char *);
83
82
84
83
extern int xfs_zero_eof(struct vnode *, struct xfs_iocore *, xfs_off_t,
85
84
xfs_fsize_t, xfs_fsize_t);
···
93
90
extern ssize_t xfs_sendfile(struct bhv_desc *, struct file *,
94
91
loff_t *, int, size_t, read_actor_t,
95
92
void *, struct cred *);
96
-
97
-
extern int xfs_dev_is_read_only(struct xfs_mount *, char *);
93
+
extern ssize_t xfs_splice_read(struct bhv_desc *, struct file *,
94
+
struct inode *, size_t, int, int,
95
+
struct cred *);
96
+
extern ssize_t xfs_splice_write(struct bhv_desc *, struct inode *,
97
+
struct file *, size_t, int, int,
98
+
struct cred *);
98
99
99
100
#endif /* __XFS_LRW_H__ */
+6
-5
fs/xfs/linux-2.6/xfs_super.c
+6
-5
fs/xfs/linux-2.6/xfs_super.c
···
67
67
68
68
STATIC struct xfs_mount_args *
69
69
xfs_args_allocate(
70
-
struct super_block *sb)
70
+
struct super_block *sb,
71
+
int silent)
71
72
{
72
73
struct xfs_mount_args *args;
73
74
···
81
80
args->flags |= XFSMNT_DIRSYNC;
82
81
if (sb->s_flags & MS_SYNCHRONOUS)
83
82
args->flags |= XFSMNT_WSYNC;
84
-
85
-
/* Default to 32 bit inodes on Linux all the time */
83
+
if (silent)
84
+
args->flags |= XFSMNT_QUIET;
86
85
args->flags |= XFSMNT_32BITINODES;
87
86
88
87
return args;
···
720
719
char *options)
721
720
{
722
721
vfs_t *vfsp = vfs_from_sb(sb);
723
-
struct xfs_mount_args *args = xfs_args_allocate(sb);
722
+
struct xfs_mount_args *args = xfs_args_allocate(sb, 0);
724
723
int error;
725
724
726
725
VFS_PARSEARGS(vfsp, options, args, 1, error);
···
826
825
{
827
826
vnode_t *rootvp;
828
827
struct vfs *vfsp = vfs_allocate(sb);
829
-
struct xfs_mount_args *args = xfs_args_allocate(sb);
828
+
struct xfs_mount_args *args = xfs_args_allocate(sb, silent);
830
829
struct kstatfs statvfs;
831
830
int error, error2;
832
831
+12
fs/xfs/linux-2.6/xfs_vnode.h
+12
fs/xfs/linux-2.6/xfs_vnode.h
···
173
173
typedef ssize_t (*vop_sendfile_t)(bhv_desc_t *, struct file *,
174
174
loff_t *, int, size_t, read_actor_t,
175
175
void *, struct cred *);
176
+
typedef ssize_t (*vop_splice_read_t)(bhv_desc_t *, struct file *,
177
+
struct inode *, size_t, int, int,
178
+
struct cred *);
179
+
typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct inode *,
180
+
struct file *, size_t, int, int,
181
+
struct cred *);
176
182
typedef int (*vop_ioctl_t)(bhv_desc_t *, struct inode *, struct file *,
177
183
int, unsigned int, void __user *);
178
184
typedef int (*vop_getattr_t)(bhv_desc_t *, struct vattr *, int,
···
237
231
vop_read_t vop_read;
238
232
vop_write_t vop_write;
239
233
vop_sendfile_t vop_sendfile;
234
+
vop_splice_read_t vop_splice_read;
235
+
vop_splice_write_t vop_splice_write;
240
236
vop_ioctl_t vop_ioctl;
241
237
vop_getattr_t vop_getattr;
242
238
vop_setattr_t vop_setattr;
···
284
276
rv = _VOP_(vop_write, vp)((vp)->v_fbhv,file,iov,segs,offset,ioflags,cr)
285
277
#define VOP_SENDFILE(vp,f,off,ioflags,cnt,act,targ,cr,rv) \
286
278
rv = _VOP_(vop_sendfile, vp)((vp)->v_fbhv,f,off,ioflags,cnt,act,targ,cr)
279
+
#define VOP_SPLICE_READ(vp,f,pipe,cnt,fl,iofl,cr,rv) \
280
+
rv = _VOP_(vop_splice_read, vp)((vp)->v_fbhv,f,pipe,cnt,fl,iofl,cr)
281
+
#define VOP_SPLICE_WRITE(vp,f,pipe,cnt,fl,iofl,cr,rv) \
282
+
rv = _VOP_(vop_splice_write, vp)((vp)->v_fbhv,f,pipe,cnt,fl,iofl,cr)
287
283
#define VOP_BMAP(vp,of,sz,rw,b,n,rv) \
288
284
rv = _VOP_(vop_bmap, vp)((vp)->v_fbhv,of,sz,rw,b,n)
289
285
#define VOP_OPEN(vp, cr, rv) \
+10
-7
fs/xfs/quota/xfs_qm.c
+10
-7
fs/xfs/quota/xfs_qm.c
···
2624
2624
{
2625
2625
int error;
2626
2626
xfs_mount_t *mp;
2627
-
uint delblks, blkflags;
2627
+
uint delblks, blkflags, prjflags = 0;
2628
2628
xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2629
2629
2630
2630
ASSERT(XFS_ISLOCKED_INODE(ip));
···
2650
2650
}
2651
2651
}
2652
2652
if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
2653
-
if ((XFS_IS_GQUOTA_ON(ip->i_mount) &&
2654
-
ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id)) ||
2655
-
(XFS_IS_PQUOTA_ON(ip->i_mount) &&
2656
-
ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))) {
2653
+
if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2654
+
ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))
2655
+
prjflags = XFS_QMOPT_ENOSPC;
2656
+
2657
+
if (prjflags ||
2658
+
(XFS_IS_GQUOTA_ON(ip->i_mount) &&
2659
+
ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
2657
2660
delblksgdq = gdqp;
2658
2661
if (delblks) {
2659
2662
ASSERT(ip->i_gdquot);
···
2667
2664
2668
2665
if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2669
2666
delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
2670
-
flags | blkflags)))
2667
+
flags | blkflags | prjflags)))
2671
2668
return (error);
2672
2669
2673
2670
/*
···
2684
2681
ASSERT(unresudq || unresgdq);
2685
2682
if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2686
2683
delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
2687
-
flags | blkflags)))
2684
+
flags | blkflags | prjflags)))
2688
2685
return (error);
2689
2686
xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2690
2687
unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
+36
-32
fs/xfs/quota/xfs_trans_dquot.c
+36
-32
fs/xfs/quota/xfs_trans_dquot.c
···
595
595
}
596
596
}
597
597
598
+
STATIC int
599
+
xfs_quota_error(uint flags)
600
+
{
601
+
if (flags & XFS_QMOPT_ENOSPC)
602
+
return ENOSPC;
603
+
return EDQUOT;
604
+
}
605
+
598
606
/*
599
607
* This reserves disk blocks and inodes against a dquot.
600
608
* Flags indicate if the dquot is to be locked here and also
601
609
* if the blk reservation is for RT or regular blocks.
602
610
* Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
603
-
* Returns EDQUOT if quota is exceeded.
604
611
*/
605
612
STATIC int
606
613
xfs_trans_dqresv(
···
673
666
*/
674
667
if (hardlimit > 0ULL &&
675
668
(hardlimit <= nblks + *resbcountp)) {
676
-
error = EDQUOT;
669
+
error = xfs_quota_error(flags);
677
670
goto error_return;
678
671
}
679
672
680
673
if (softlimit > 0ULL &&
681
674
(softlimit <= nblks + *resbcountp)) {
682
-
/*
683
-
* If timer or warnings has expired,
684
-
* return EDQUOT
685
-
*/
686
675
if ((timer != 0 && get_seconds() > timer) ||
687
676
(warns != 0 && warns >= warnlimit)) {
688
-
error = EDQUOT;
677
+
error = xfs_quota_error(flags);
689
678
goto error_return;
690
679
}
691
680
}
···
698
695
if (!softlimit)
699
696
softlimit = q->qi_isoftlimit;
700
697
if (hardlimit > 0ULL && count >= hardlimit) {
701
-
error = EDQUOT;
698
+
error = xfs_quota_error(flags);
702
699
goto error_return;
703
700
} else if (softlimit > 0ULL && count >= softlimit) {
704
-
/*
705
-
* If timer or warnings has expired,
706
-
* return EDQUOT
707
-
*/
708
701
if ((timer != 0 && get_seconds() > timer) ||
709
702
(warns != 0 && warns >= warnlimit)) {
710
-
error = EDQUOT;
703
+
error = xfs_quota_error(flags);
711
704
goto error_return;
712
705
}
713
706
}
···
750
751
751
752
752
753
/*
753
-
* Given a dquot(s), make disk block and/or inode reservations against them.
754
+
* Given dquot(s), make disk block and/or inode reservations against them.
754
755
* The fact that this does the reservation against both the usr and
755
-
* grp quotas is important, because this follows a both-or-nothing
756
+
* grp/prj quotas is important, because this follows a both-or-nothing
756
757
* approach.
757
758
*
758
759
* flags = XFS_QMOPT_DQLOCK indicate if dquot(s) need to be locked.
759
760
* XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
761
+
* XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT. Used by pquota.
760
762
* XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
761
763
* XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
762
764
* dquots are unlocked on return, if they were not locked by caller.
···
772
772
long ninos,
773
773
uint flags)
774
774
{
775
-
int resvd;
775
+
int resvd = 0, error;
776
776
777
-
if (! XFS_IS_QUOTA_ON(mp))
778
-
return (0);
777
+
if (!XFS_IS_QUOTA_ON(mp))
778
+
return 0;
779
779
780
780
if (tp && tp->t_dqinfo == NULL)
781
781
xfs_trans_alloc_dqinfo(tp);
782
782
783
783
ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
784
-
resvd = 0;
785
784
786
785
if (udqp) {
787
-
if (xfs_trans_dqresv(tp, mp, udqp, nblks, ninos, flags))
788
-
return (EDQUOT);
786
+
error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos,
787
+
(flags & ~XFS_QMOPT_ENOSPC));
788
+
if (error)
789
+
return error;
789
790
resvd = 1;
790
791
}
791
792
792
793
if (gdqp) {
793
-
if (xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags)) {
794
+
error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
795
+
if (error) {
794
796
/*
795
797
* can't do it, so backout previous reservation
796
798
*/
···
801
799
xfs_trans_dqresv(tp, mp, udqp,
802
800
-nblks, -ninos, flags);
803
801
}
804
-
return (EDQUOT);
802
+
return error;
805
803
}
806
804
}
807
805
808
806
/*
809
807
* Didn't change anything critical, so, no need to log
810
808
*/
811
-
return (0);
809
+
return 0;
812
810
}
813
811
814
812
···
816
814
* Lock the dquot and change the reservation if we can.
817
815
* This doesn't change the actual usage, just the reservation.
818
816
* The inode sent in is locked.
819
-
*
820
-
* Returns 0 on success, EDQUOT or other errors otherwise
821
817
*/
822
818
STATIC int
823
819
xfs_trans_reserve_quota_nblks(
···
824
824
xfs_inode_t *ip,
825
825
long nblks,
826
826
long ninos,
827
-
uint type)
827
+
uint flags)
828
828
{
829
829
int error;
830
830
831
831
if (!XFS_IS_QUOTA_ON(mp))
832
-
return (0);
832
+
return 0;
833
+
if (XFS_IS_PQUOTA_ON(mp))
834
+
flags |= XFS_QMOPT_ENOSPC;
833
835
834
836
ASSERT(ip->i_ino != mp->m_sb.sb_uquotino);
835
837
ASSERT(ip->i_ino != mp->m_sb.sb_gquotino);
836
838
837
839
ASSERT(XFS_ISLOCKED_INODE_EXCL(ip));
838
840
ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
839
-
ASSERT((type & ~XFS_QMOPT_FORCE_RES) == XFS_TRANS_DQ_RES_RTBLKS ||
840
-
(type & ~XFS_QMOPT_FORCE_RES) == XFS_TRANS_DQ_RES_BLKS);
841
+
ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
842
+
XFS_TRANS_DQ_RES_RTBLKS ||
843
+
(flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
844
+
XFS_TRANS_DQ_RES_BLKS);
841
845
842
846
/*
843
847
* Reserve nblks against these dquots, with trans as the mediator.
···
849
845
error = xfs_trans_reserve_quota_bydquots(tp, mp,
850
846
ip->i_udquot, ip->i_gdquot,
851
847
nblks, ninos,
852
-
type);
853
-
return (error);
848
+
flags);
849
+
return error;
854
850
}
855
851
856
852
/*
+5
-6
fs/xfs/xfs_bmap.c
+5
-6
fs/xfs/xfs_bmap.c
···
4719
4719
/*
4720
4720
* Make a transaction-less quota reservation for
4721
4721
* delayed allocation blocks. This number gets
4722
-
* adjusted later.
4723
-
* We return EDQUOT if we haven't allocated
4724
-
* blks already inside this loop;
4722
+
* adjusted later. We return if we haven't
4723
+
* allocated blocks already inside this loop.
4725
4724
*/
4726
-
if (XFS_TRANS_RESERVE_QUOTA_NBLKS(
4725
+
if ((error = XFS_TRANS_RESERVE_QUOTA_NBLKS(
4727
4726
mp, NULL, ip, (long)alen, 0,
4728
4727
rt ? XFS_QMOPT_RES_RTBLKS :
4729
-
XFS_QMOPT_RES_REGBLKS)) {
4728
+
XFS_QMOPT_RES_REGBLKS))) {
4730
4729
if (n == 0) {
4731
4730
*nmap = 0;
4732
4731
ASSERT(cur == NULL);
4733
-
return XFS_ERROR(EDQUOT);
4732
+
return error;
4734
4733
}
4735
4734
break;
4736
4735
}
+5
-4
fs/xfs/xfs_bmap.h
+5
-4
fs/xfs/xfs_bmap.h
···
353
353
xfs_extnum_t num);
354
354
355
355
/*
356
-
* Call xfs_bmap_do_search_extents() to search for the extent
357
-
* record containing block bno. If in multi-level in-core extent
358
-
* allocation mode, find and extract the target extent buffer,
359
-
* otherwise just use the direct extent list.
356
+
* Search the extent records for the entry containing block bno.
357
+
* If bno lies in a hole, point to the next entry. If bno lies
358
+
* past eof, *eofp will be set, and *prevp will contain the last
359
+
* entry (null if none). Else, *lastxp will be set to the index
360
+
* of the found entry; *gotp will contain the entry.
360
361
*/
361
362
xfs_bmbt_rec_t *
362
363
xfs_bmap_search_multi_extents(struct xfs_ifork *, xfs_fileoff_t, int *,
+1
fs/xfs/xfs_clnt.h
+1
fs/xfs/xfs_clnt.h
···
68
68
* enforcement */
69
69
#define XFSMNT_PQUOTAENF 0x00000040 /* IRIX project quota limit
70
70
* enforcement */
71
+
#define XFSMNT_QUIET 0x00000080 /* don't report mount errors */
71
72
#define XFSMNT_NOALIGN 0x00000200 /* don't allocate at
72
73
* stripe boundaries*/
73
74
#define XFSMNT_RETERR 0x00000400 /* return error to user */
+3
fs/xfs/xfs_error.h
+3
fs/xfs/xfs_error.h
···
186
186
#define xfs_fs_repair_cmn_err(level, mp, fmt, args...) \
187
187
xfs_fs_cmn_err(level, mp, fmt " Unmount and run xfs_repair.", ## args)
188
188
189
+
#define xfs_fs_mount_cmn_err(f, fmt, args...) \
190
+
((f & XFS_MFSI_QUIET)? cmn_err(CE_WARN, "XFS: " fmt, ## args) : (void)0)
191
+
189
192
#endif /* __XFS_ERROR_H__ */
+31
-40
fs/xfs/xfs_mount.c
+31
-40
fs/xfs/xfs_mount.c
···
213
213
STATIC int
214
214
xfs_mount_validate_sb(
215
215
xfs_mount_t *mp,
216
-
xfs_sb_t *sbp)
216
+
xfs_sb_t *sbp,
217
+
int flags)
217
218
{
218
219
/*
219
220
* If the log device and data device have the
···
224
223
* a volume filesystem in a non-volume manner.
225
224
*/
226
225
if (sbp->sb_magicnum != XFS_SB_MAGIC) {
227
-
cmn_err(CE_WARN, "XFS: bad magic number");
226
+
xfs_fs_mount_cmn_err(flags, "bad magic number");
228
227
return XFS_ERROR(EWRONGFS);
229
228
}
230
229
231
230
if (!XFS_SB_GOOD_VERSION(sbp)) {
232
-
cmn_err(CE_WARN, "XFS: bad version");
231
+
xfs_fs_mount_cmn_err(flags, "bad version");
233
232
return XFS_ERROR(EWRONGFS);
234
233
}
235
234
236
235
if (unlikely(
237
236
sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) {
238
-
cmn_err(CE_WARN,
239
-
"XFS: filesystem is marked as having an external log; "
240
-
"specify logdev on the\nmount command line.");
241
-
XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(1)",
242
-
XFS_ERRLEVEL_HIGH, mp, sbp);
243
-
return XFS_ERROR(EFSCORRUPTED);
237
+
xfs_fs_mount_cmn_err(flags,
238
+
"filesystem is marked as having an external log; "
239
+
"specify logdev on the\nmount command line.");
240
+
return XFS_ERROR(EINVAL);
244
241
}
245
242
246
243
if (unlikely(
247
244
sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) {
248
-
cmn_err(CE_WARN,
249
-
"XFS: filesystem is marked as having an internal log; "
250
-
"don't specify logdev on\nthe mount command line.");
251
-
XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(2)",
252
-
XFS_ERRLEVEL_HIGH, mp, sbp);
253
-
return XFS_ERROR(EFSCORRUPTED);
245
+
xfs_fs_mount_cmn_err(flags,
246
+
"filesystem is marked as having an internal log; "
247
+
"do not specify logdev on\nthe mount command line.");
248
+
return XFS_ERROR(EINVAL);
254
249
}
255
250
256
251
/*
···
271
274
(sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) ||
272
275
(sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) ||
273
276
(sbp->sb_imax_pct > 100 || sbp->sb_imax_pct < 1))) {
274
-
cmn_err(CE_WARN, "XFS: SB sanity check 1 failed");
275
-
XFS_CORRUPTION_ERROR("xfs_mount_validate_sb(3)",
276
-
XFS_ERRLEVEL_LOW, mp, sbp);
277
+
xfs_fs_mount_cmn_err(flags, "SB sanity check 1 failed");
277
278
return XFS_ERROR(EFSCORRUPTED);
278
279
}
279
280
···
284
289
(xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks ||
285
290
sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) *
286
291
sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) {
287
-
cmn_err(CE_WARN, "XFS: SB sanity check 2 failed");
288
-
XFS_ERROR_REPORT("xfs_mount_validate_sb(4)",
289
-
XFS_ERRLEVEL_LOW, mp);
292
+
xfs_fs_mount_cmn_err(flags, "SB sanity check 2 failed");
290
293
return XFS_ERROR(EFSCORRUPTED);
291
294
}
292
295
···
300
307
(sbp->sb_dblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX ||
301
308
(sbp->sb_rblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX)) {
302
309
#endif
303
-
cmn_err(CE_WARN,
304
-
"XFS: File system is too large to be mounted on this system.");
310
+
xfs_fs_mount_cmn_err(flags,
311
+
"file system too large to be mounted on this system.");
305
312
return XFS_ERROR(E2BIG);
306
313
}
307
314
308
315
if (unlikely(sbp->sb_inprogress)) {
309
-
cmn_err(CE_WARN, "XFS: file system busy");
310
-
XFS_ERROR_REPORT("xfs_mount_validate_sb(5)",
311
-
XFS_ERRLEVEL_LOW, mp);
316
+
xfs_fs_mount_cmn_err(flags, "file system busy");
312
317
return XFS_ERROR(EFSCORRUPTED);
313
318
}
314
319
···
314
323
* Version 1 directory format has never worked on Linux.
315
324
*/
316
325
if (unlikely(!XFS_SB_VERSION_HASDIRV2(sbp))) {
317
-
cmn_err(CE_WARN,
318
-
"XFS: Attempted to mount file system using version 1 directory format");
326
+
xfs_fs_mount_cmn_err(flags,
327
+
"file system using version 1 directory format");
319
328
return XFS_ERROR(ENOSYS);
320
329
}
321
330
···
323
332
* Until this is fixed only page-sized or smaller data blocks work.
324
333
*/
325
334
if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
326
-
cmn_err(CE_WARN,
327
-
"XFS: Attempted to mount file system with blocksize %d bytes",
335
+
xfs_fs_mount_cmn_err(flags,
336
+
"file system with blocksize %d bytes",
328
337
sbp->sb_blocksize);
329
-
cmn_err(CE_WARN,
330
-
"XFS: Only page-sized (%ld) or less blocksizes currently work.",
338
+
xfs_fs_mount_cmn_err(flags,
339
+
"only pagesize (%ld) or less will currently work.",
331
340
PAGE_SIZE);
332
341
return XFS_ERROR(ENOSYS);
333
342
}
···
475
484
* Does the initial read of the superblock.
476
485
*/
477
486
int
478
-
xfs_readsb(xfs_mount_t *mp)
487
+
xfs_readsb(xfs_mount_t *mp, int flags)
479
488
{
480
489
unsigned int sector_size;
481
490
unsigned int extra_flags;
···
497
506
bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
498
507
BTOBB(sector_size), extra_flags);
499
508
if (!bp || XFS_BUF_ISERROR(bp)) {
500
-
cmn_err(CE_WARN, "XFS: SB read failed");
509
+
xfs_fs_mount_cmn_err(flags, "SB read failed");
501
510
error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
502
511
goto fail;
503
512
}
···
511
520
sbp = XFS_BUF_TO_SBP(bp);
512
521
xfs_xlatesb(XFS_BUF_PTR(bp), &(mp->m_sb), 1, XFS_SB_ALL_BITS);
513
522
514
-
error = xfs_mount_validate_sb(mp, &(mp->m_sb));
523
+
error = xfs_mount_validate_sb(mp, &(mp->m_sb), flags);
515
524
if (error) {
516
-
cmn_err(CE_WARN, "XFS: SB validate failed");
525
+
xfs_fs_mount_cmn_err(flags, "SB validate failed");
517
526
goto fail;
518
527
}
519
528
···
521
530
* We must be able to do sector-sized and sector-aligned IO.
522
531
*/
523
532
if (sector_size > mp->m_sb.sb_sectsize) {
524
-
cmn_err(CE_WARN,
525
-
"XFS: device supports only %u byte sectors (not %u)",
533
+
xfs_fs_mount_cmn_err(flags,
534
+
"device supports only %u byte sectors (not %u)",
526
535
sector_size, mp->m_sb.sb_sectsize);
527
536
error = ENOSYS;
528
537
goto fail;
···
539
548
bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR,
540
549
BTOBB(sector_size), extra_flags);
541
550
if (!bp || XFS_BUF_ISERROR(bp)) {
542
-
cmn_err(CE_WARN, "XFS: SB re-read failed");
551
+
xfs_fs_mount_cmn_err(flags, "SB re-read failed");
543
552
error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM;
544
553
goto fail;
545
554
}
···
669
678
int error = 0;
670
679
671
680
if (mp->m_sb_bp == NULL) {
672
-
if ((error = xfs_readsb(mp))) {
681
+
if ((error = xfs_readsb(mp, mfsi_flags))) {
673
682
return error;
674
683
}
675
684
}
+4
-1
fs/xfs/xfs_mount.h
+4
-1
fs/xfs/xfs_mount.h
···
510
510
*/
511
511
#define XFS_MFSI_SECOND 0x01 /* Secondary mount -- skip stuff */
512
512
#define XFS_MFSI_CLIENT 0x02 /* Is a client -- skip lots of stuff */
513
+
/* XFS_MFSI_RRINODES */
513
514
#define XFS_MFSI_NOUNLINK 0x08 /* Skip unlinked inode processing in */
514
515
/* log recovery */
515
516
#define XFS_MFSI_NO_QUOTACHECK 0x10 /* Skip quotacheck processing */
517
+
/* XFS_MFSI_CONVERT_SUNIT */
518
+
#define XFS_MFSI_QUIET 0x40 /* Be silent if mount errors found */
516
519
517
520
/*
518
521
* Macros for getting from mount to vfs and back.
···
584
581
extern int xfs_mod_incore_sb_batch(xfs_mount_t *, xfs_mod_sb_t *,
585
582
uint, int);
586
583
extern struct xfs_buf *xfs_getsb(xfs_mount_t *, int);
587
-
extern int xfs_readsb(xfs_mount_t *mp);
584
+
extern int xfs_readsb(xfs_mount_t *, int);
588
585
extern void xfs_freesb(xfs_mount_t *);
589
586
extern void xfs_do_force_shutdown(bhv_desc_t *, int, char *, int);
590
587
extern int xfs_syncsub(xfs_mount_t *, int, int, int *);
+3
-2
fs/xfs/xfs_quota.h
+3
-2
fs/xfs/xfs_quota.h
···
196
196
#define XFS_QMOPT_QUOTAOFF 0x0000080 /* quotas are being turned off */
197
197
#define XFS_QMOPT_UMOUNTING 0x0000100 /* filesys is being unmounted */
198
198
#define XFS_QMOPT_DOLOG 0x0000200 /* log buf changes (in quotacheck) */
199
-
#define XFS_QMOPT_DOWARN 0x0000400 /* increase warning cnt if necessary */
199
+
#define XFS_QMOPT_DOWARN 0x0000400 /* increase warning cnt if needed */
200
200
#define XFS_QMOPT_ILOCKED 0x0000800 /* inode is already locked (excl) */
201
-
#define XFS_QMOPT_DQREPAIR 0x0001000 /* repair dquot, if damaged. */
201
+
#define XFS_QMOPT_DQREPAIR 0x0001000 /* repair dquot if damaged */
202
202
#define XFS_QMOPT_GQUOTA 0x0002000 /* group dquot requested */
203
+
#define XFS_QMOPT_ENOSPC 0x0004000 /* enospc instead of edquot (prj) */
203
204
204
205
/*
205
206
* flags to xfs_trans_mod_dquot to indicate which field needs to be
+6
-4
fs/xfs/xfs_vfsops.c
+6
-4
fs/xfs/xfs_vfsops.c
···
442
442
p = vfs_bhv_lookup(vfsp, VFS_POSITION_IO);
443
443
mp->m_io_ops = p ? *(xfs_ioops_t *) vfs_bhv_custom(p) : xfs_iocore_xfs;
444
444
445
+
if (args->flags & XFSMNT_QUIET)
446
+
flags |= XFS_MFSI_QUIET;
447
+
445
448
/*
446
449
* Open real time and log devices - order is important.
447
450
*/
···
495
492
error = xfs_start_flags(vfsp, args, mp);
496
493
if (error)
497
494
goto error1;
498
-
error = xfs_readsb(mp);
495
+
error = xfs_readsb(mp, flags);
499
496
if (error)
500
497
goto error1;
501
498
error = xfs_finish_flags(vfsp, args, mp);
···
1700
1697
int dsunit, dswidth, vol_dsunit, vol_dswidth;
1701
1698
int iosize;
1702
1699
1703
-
args->flags2 |= XFSMNT2_COMPAT_IOSIZE;
1704
1700
args->flags |= XFSMNT_IDELETE;
1701
+
args->flags |= XFSMNT_BARRIER;
1702
+
args->flags2 |= XFSMNT2_COMPAT_IOSIZE;
1705
1703
1706
1704
if (!options)
1707
1705
goto done;
···
1951
1947
seq_printf(m, "," MNTOPT_IKEEP);
1952
1948
if (!(mp->m_flags & XFS_MOUNT_COMPAT_IOSIZE))
1953
1949
seq_printf(m, "," MNTOPT_LARGEIO);
1954
-
if (mp->m_flags & XFS_MOUNT_BARRIER)
1955
-
seq_printf(m, "," MNTOPT_BARRIER);
1956
1950
1957
1951
if (!(vfsp->vfs_flag & VFS_32BITINODES))
1958
1952
seq_printf(m, "," MNTOPT_64BITINODE);
+4
fs/xfs/xfs_vnodeops.c
+4
fs/xfs/xfs_vnodeops.c
···
4649
4649
#ifdef HAVE_SENDFILE
4650
4650
.vop_sendfile = xfs_sendfile,
4651
4651
#endif
4652
+
#ifdef HAVE_SPLICE
4653
+
.vop_splice_read = xfs_splice_read,
4654
+
.vop_splice_write = xfs_splice_write,
4655
+
#endif
4652
4656
.vop_write = xfs_write,
4653
4657
.vop_ioctl = xfs_ioctl,
4654
4658
.vop_getattr = xfs_getattr,