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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// SPDX-License-Identifier: GPL-2.0+
/*
* erofs_utils/lib/io.c
*
* Copyright (C) 2018 HUAWEI, Inc.
* http://www.huawei.com/
* Created by Li Guifu <bluce.liguifu@huawei.com>
*/
#define _LARGEFILE64_SOURCE
#define _GNU_SOURCE
#include <sys/stat.h>
#include <sys/ioctl.h>
#include "erofs/io.h"
#ifdef HAVE_LINUX_FS_H
#include <linux/fs.h>
#endif
#ifdef HAVE_LINUX_FALLOC_H
#include <linux/falloc.h>
#endif
#define pr_fmt(fmt) "EROFS IO: " FUNC_LINE_FMT fmt "\n"
#include "erofs/print.h"
static const char *erofs_devname;
static int erofs_devfd = -1;
static u64 erofs_devsz;
int dev_get_blkdev_size(int fd, u64 *bytes)
{
errno = ENOTSUP;
#ifdef BLKGETSIZE64
if (ioctl(fd, BLKGETSIZE64, bytes) >= 0)
return 0;
#endif
#ifdef BLKGETSIZE
{
unsigned long size;
if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
*bytes = ((u64)size << 9);
return 0;
}
}
#endif
return -errno;
}
void dev_close(void)
{
close(erofs_devfd);
erofs_devname = NULL;
erofs_devfd = -1;
erofs_devsz = 0;
}
int dev_open(const char *dev)
{
struct stat st;
int fd, ret;
fd = open(dev, O_RDWR | O_CREAT | O_BINARY, 0644);
if (fd < 0) {
erofs_err("failed to open(%s).", dev);
return -errno;
}
ret = fstat(fd, &st);
if (ret) {
erofs_err("failed to fstat(%s).", dev);
close(fd);
return -errno;
}
switch (st.st_mode & S_IFMT) {
case S_IFBLK:
ret = dev_get_blkdev_size(fd, &erofs_devsz);
if (ret) {
erofs_err("failed to get block device size(%s).", dev);
close(fd);
return ret;
}
break;
case S_IFREG:
ret = ftruncate(fd, 0);
if (ret) {
erofs_err("failed to ftruncate(%s).", dev);
close(fd);
return -errno;
}
/* INT64_MAX is the limit of kernel vfs */
erofs_devsz = INT64_MAX;
break;
default:
erofs_err("bad file type (%s, %o).", dev, st.st_mode);
close(fd);
return -EINVAL;
}
erofs_devname = dev;
erofs_devfd = fd;
erofs_devsz = round_down(erofs_devsz, EROFS_BLKSIZ);
erofs_info("successfully to open %s", dev);
return 0;
}
u64 dev_length(void)
{
return erofs_devsz;
}
int dev_write(const void *buf, u64 offset, size_t len)
{
int ret;
if (cfg.c_dry_run)
return 0;
if (!buf) {
erofs_err("buf is NULL");
return -EINVAL;
}
if (offset >= erofs_devsz || len > erofs_devsz ||
offset > erofs_devsz - len) {
erofs_err("Write posion[%" PRIu64 ", %zd] is too large beyond the end of device(%" PRIu64 ").",
offset, len, erofs_devsz);
return -EINVAL;
}
ret = pwrite64(erofs_devfd, buf, len, (off64_t)offset);
if (ret != (int)len) {
if (ret < 0) {
erofs_err("Failed to write data into device - %s:[%" PRIu64 ", %zd].",
erofs_devname, offset, len);
return -errno;
}
erofs_err("Writing data into device - %s:[%" PRIu64 ", %zd] - was truncated.",
erofs_devname, offset, len);
return -ERANGE;
}
return 0;
}
int dev_fillzero(u64 offset, size_t len, bool padding)
{
static const char zero[EROFS_BLKSIZ] = {0};
int ret;
if (cfg.c_dry_run)
return 0;
#if defined(HAVE_FALLOCATE) && defined(FALLOC_FL_PUNCH_HOLE)
if (!padding && fallocate(erofs_devfd, FALLOC_FL_PUNCH_HOLE |
FALLOC_FL_KEEP_SIZE, offset, len) >= 0)
return 0;
#endif
while (len > EROFS_BLKSIZ) {
ret = dev_write(zero, offset, EROFS_BLKSIZ);
if (ret)
return ret;
len -= EROFS_BLKSIZ;
offset += EROFS_BLKSIZ;
}
return dev_write(zero, offset, len);
}
int dev_fsync(void)
{
int ret;
ret = fsync(erofs_devfd);
if (ret) {
erofs_err("Could not fsync device!!!");
return -EIO;
}
return 0;
}
|
