1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/*
* fsync.c
*
* PURPOSE
* Fsync handling routines for the OSTA-UDF(tm) filesystem.
*
* CONTACTS
* E-mail regarding any portion of the Linux UDF file system should be
* directed to the development team mailing list (run by majordomo):
* linux_udf@hootie.lvld.hp.com
*
* COPYRIGHT
* This file is distributed under the terms of the GNU General Public
* License (GPL). Copies of the GPL can be obtained from:
* ftp://prep.ai.mit.edu/pub/gnu/GPL
* Each contributing author retains all rights to their own work.
*
* (C) 1999-2000 Ben Fennema
* (C) 1999-2000 Stelias Computing Inc
*
* HISTORY
*
* 05/22/99 blf Created.
*/
#include "udfdecl.h"
#include <linux/fs.h>
#include <linux/locks.h>
#include <linux/smp_lock.h>
#include <linux/udf_fs.h>
#include "udf_i.h"
static int sync_extent_block (struct inode * inode, Uint32 block, int wait)
{
struct buffer_head * bh;
if (!block)
return 0;
bh = get_hash_table (inode->i_dev, block, inode->i_sb->s_blocksize);
if (!bh)
return 0;
if (wait && buffer_req(bh) && !buffer_uptodate(bh)) {
/* There can be a parallell read(2) that started read-I/O
on the buffer so we can't assume that there's been
an I/O error without first waiting I/O completation. */
wait_on_buffer(bh);
if (!buffer_uptodate(bh))
{
brelse (bh);
return -1;
}
}
if (wait || !buffer_uptodate(bh) || !buffer_dirty(bh)) {
if (wait)
/* when we return from fsync all the blocks
must be _just_ stored on disk */
wait_on_buffer(bh);
brelse (bh);
return 0;
}
ll_rw_block (WRITE, 1, &bh);
atomic_dec(&bh->b_count);
return 0;
}
static int sync_all_extents(struct inode * inode, int wait)
{
lb_addr bloc, eloc;
Uint32 extoffset, lextoffset, elen, offset, block;
int err = 0, etype;
struct buffer_head *bh = NULL;
if ((etype = inode_bmap(inode, 0, &bloc, &extoffset, &eloc, &elen, &offset, &bh)) != -1)
{
block = udf_get_lb_pblock(inode->i_sb, bloc, 0);
err |= sync_extent_block(inode, block, wait);
lextoffset = extoffset;
while ((etype = udf_next_aext(inode, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
{
if (lextoffset > extoffset)
{
block = udf_get_lb_pblock(inode->i_sb, bloc, 0);
err |= sync_extent_block(inode, block, wait);
}
lextoffset = extoffset;
}
}
udf_release_data(bh);
return err;
}
/*
* File may be NULL when we are called. Perhaps we shouldn't
* even pass file to fsync ?
*/
int udf_sync_file(struct file * file, struct dentry *dentry, int datasync)
{
int wait, err = 0;
struct inode *inode = dentry->d_inode;
lock_kernel();
if (S_ISLNK(inode->i_mode) && !(inode->i_blocks))
{
/*
* Don't sync fast links! or ICB_FLAG_AD_IN_ICB
*/
goto skip;
}
err = generic_buffer_fdatasync(inode, 0, ~0UL);
for (wait=0; wait<=1; wait++)
{
err |= sync_all_extents (inode, wait);
}
skip:
err |= udf_sync_inode (inode);
unlock_kernel();
return err ? -EIO : 0;
}
|
