Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
f1adc05e | 2 | * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
1da177e4 LT |
3 | * Licensed under the GPL |
4 | */ | |
5 | ||
1da177e4 | 6 | #include <stdio.h> |
84b3db04 JD |
7 | #include <stddef.h> |
8 | #include <unistd.h> | |
1da177e4 LT |
9 | #include <dirent.h> |
10 | #include <errno.h> | |
84b3db04 | 11 | #include <fcntl.h> |
1da177e4 LT |
12 | #include <string.h> |
13 | #include <sys/stat.h> | |
14 | #include <sys/time.h> | |
84b3db04 | 15 | #include <sys/types.h> |
1da177e4 LT |
16 | #include <sys/vfs.h> |
17 | #include "hostfs.h" | |
84b3db04 | 18 | #include "os.h" |
1da177e4 | 19 | #include "user.h" |
84b3db04 | 20 | #include <utime.h> |
1da177e4 LT |
21 | |
22 | int stat_file(const char *path, unsigned long long *inode_out, int *mode_out, | |
23 | int *nlink_out, int *uid_out, int *gid_out, | |
24 | unsigned long long *size_out, struct timespec *atime_out, | |
25 | struct timespec *mtime_out, struct timespec *ctime_out, | |
5822b7fa | 26 | int *blksize_out, unsigned long long *blocks_out, int fd) |
1da177e4 LT |
27 | { |
28 | struct stat64 buf; | |
29 | ||
84b3db04 | 30 | if (fd >= 0) { |
5822b7fa | 31 | if (fstat64(fd, &buf) < 0) |
f1adc05e | 32 | return -errno; |
84b3db04 | 33 | } else if (lstat64(path, &buf) < 0) { |
f1adc05e | 34 | return -errno; |
5822b7fa | 35 | } |
1da177e4 | 36 | |
84b3db04 JD |
37 | if (inode_out != NULL) |
38 | *inode_out = buf.st_ino; | |
39 | if (mode_out != NULL) | |
40 | *mode_out = buf.st_mode; | |
41 | if (nlink_out != NULL) | |
42 | *nlink_out = buf.st_nlink; | |
43 | if (uid_out != NULL) | |
44 | *uid_out = buf.st_uid; | |
45 | if (gid_out != NULL) | |
46 | *gid_out = buf.st_gid; | |
47 | if (size_out != NULL) | |
48 | *size_out = buf.st_size; | |
49 | if (atime_out != NULL) { | |
1da177e4 LT |
50 | atime_out->tv_sec = buf.st_atime; |
51 | atime_out->tv_nsec = 0; | |
52 | } | |
84b3db04 | 53 | if (mtime_out != NULL) { |
1da177e4 LT |
54 | mtime_out->tv_sec = buf.st_mtime; |
55 | mtime_out->tv_nsec = 0; | |
56 | } | |
84b3db04 | 57 | if (ctime_out != NULL) { |
1da177e4 LT |
58 | ctime_out->tv_sec = buf.st_ctime; |
59 | ctime_out->tv_nsec = 0; | |
60 | } | |
84b3db04 JD |
61 | if (blksize_out != NULL) |
62 | *blksize_out = buf.st_blksize; | |
63 | if (blocks_out != NULL) | |
64 | *blocks_out = buf.st_blocks; | |
f1adc05e | 65 | return 0; |
1da177e4 LT |
66 | } |
67 | ||
68 | int file_type(const char *path, int *maj, int *min) | |
69 | { | |
70 | struct stat64 buf; | |
71 | ||
84b3db04 | 72 | if (lstat64(path, &buf) < 0) |
f1adc05e | 73 | return -errno; |
84b3db04 JD |
74 | /* |
75 | * We cannot pass rdev as is because glibc and the kernel disagree | |
76 | * about its definition. | |
77 | */ | |
78 | if (maj != NULL) | |
005a59ec | 79 | *maj = os_major(buf.st_rdev); |
84b3db04 | 80 | if (min != NULL) |
005a59ec | 81 | *min = os_minor(buf.st_rdev); |
1da177e4 | 82 | |
84b3db04 JD |
83 | if (S_ISDIR(buf.st_mode)) |
84 | return OS_TYPE_DIR; | |
85 | else if (S_ISLNK(buf.st_mode)) | |
86 | return OS_TYPE_SYMLINK; | |
87 | else if (S_ISCHR(buf.st_mode)) | |
88 | return OS_TYPE_CHARDEV; | |
89 | else if (S_ISBLK(buf.st_mode)) | |
90 | return OS_TYPE_BLOCKDEV; | |
91 | else if (S_ISFIFO(buf.st_mode)) | |
92 | return OS_TYPE_FIFO; | |
93 | else if (S_ISSOCK(buf.st_mode)) | |
94 | return OS_TYPE_SOCK; | |
f1adc05e | 95 | else return OS_TYPE_FILE; |
1da177e4 LT |
96 | } |
97 | ||
98 | int access_file(char *path, int r, int w, int x) | |
99 | { | |
100 | int mode = 0; | |
101 | ||
84b3db04 JD |
102 | if (r) |
103 | mode = R_OK; | |
104 | if (w) | |
105 | mode |= W_OK; | |
106 | if (x) | |
107 | mode |= X_OK; | |
108 | if (access(path, mode) != 0) | |
f1adc05e JD |
109 | return -errno; |
110 | else return 0; | |
1da177e4 LT |
111 | } |
112 | ||
113 | int open_file(char *path, int r, int w, int append) | |
114 | { | |
115 | int mode = 0, fd; | |
116 | ||
84b3db04 | 117 | if (r && !w) |
1da177e4 | 118 | mode = O_RDONLY; |
84b3db04 | 119 | else if (!r && w) |
1da177e4 | 120 | mode = O_WRONLY; |
84b3db04 | 121 | else if (r && w) |
1da177e4 LT |
122 | mode = O_RDWR; |
123 | else panic("Impossible mode in open_file"); | |
124 | ||
84b3db04 | 125 | if (append) |
1da177e4 LT |
126 | mode |= O_APPEND; |
127 | fd = open64(path, mode); | |
84b3db04 | 128 | if (fd < 0) |
f1adc05e JD |
129 | return -errno; |
130 | else return fd; | |
1da177e4 LT |
131 | } |
132 | ||
133 | void *open_dir(char *path, int *err_out) | |
134 | { | |
135 | DIR *dir; | |
136 | ||
137 | dir = opendir(path); | |
138 | *err_out = errno; | |
84b3db04 | 139 | if (dir == NULL) |
f1adc05e JD |
140 | return NULL; |
141 | return dir; | |
1da177e4 LT |
142 | } |
143 | ||
144 | char *read_dir(void *stream, unsigned long long *pos, | |
145 | unsigned long long *ino_out, int *len_out) | |
146 | { | |
147 | DIR *dir = stream; | |
148 | struct dirent *ent; | |
149 | ||
150 | seekdir(dir, *pos); | |
151 | ent = readdir(dir); | |
84b3db04 | 152 | if (ent == NULL) |
f1adc05e | 153 | return NULL; |
1da177e4 LT |
154 | *len_out = strlen(ent->d_name); |
155 | *ino_out = ent->d_ino; | |
156 | *pos = telldir(dir); | |
f1adc05e | 157 | return ent->d_name; |
1da177e4 LT |
158 | } |
159 | ||
160 | int read_file(int fd, unsigned long long *offset, char *buf, int len) | |
161 | { | |
162 | int n; | |
163 | ||
164 | n = pread64(fd, buf, len, *offset); | |
84b3db04 | 165 | if (n < 0) |
f1adc05e | 166 | return -errno; |
1da177e4 | 167 | *offset += n; |
f1adc05e | 168 | return n; |
1da177e4 LT |
169 | } |
170 | ||
171 | int write_file(int fd, unsigned long long *offset, const char *buf, int len) | |
172 | { | |
173 | int n; | |
174 | ||
175 | n = pwrite64(fd, buf, len, *offset); | |
84b3db04 | 176 | if (n < 0) |
f1adc05e | 177 | return -errno; |
1da177e4 | 178 | *offset += n; |
f1adc05e | 179 | return n; |
1da177e4 LT |
180 | } |
181 | ||
182 | int lseek_file(int fd, long long offset, int whence) | |
183 | { | |
184 | int ret; | |
185 | ||
186 | ret = lseek64(fd, offset, whence); | |
84b3db04 | 187 | if (ret < 0) |
f1adc05e JD |
188 | return -errno; |
189 | return 0; | |
1da177e4 LT |
190 | } |
191 | ||
a2d76bd8 PBG |
192 | int fsync_file(int fd, int datasync) |
193 | { | |
194 | int ret; | |
195 | if (datasync) | |
196 | ret = fdatasync(fd); | |
197 | else | |
198 | ret = fsync(fd); | |
199 | ||
200 | if (ret < 0) | |
201 | return -errno; | |
202 | return 0; | |
203 | } | |
204 | ||
1da177e4 LT |
205 | void close_file(void *stream) |
206 | { | |
207 | close(*((int *) stream)); | |
208 | } | |
209 | ||
210 | void close_dir(void *stream) | |
211 | { | |
212 | closedir(stream); | |
213 | } | |
214 | ||
215 | int file_create(char *name, int ur, int uw, int ux, int gr, | |
216 | int gw, int gx, int or, int ow, int ox) | |
217 | { | |
218 | int mode, fd; | |
219 | ||
220 | mode = 0; | |
221 | mode |= ur ? S_IRUSR : 0; | |
222 | mode |= uw ? S_IWUSR : 0; | |
223 | mode |= ux ? S_IXUSR : 0; | |
224 | mode |= gr ? S_IRGRP : 0; | |
225 | mode |= gw ? S_IWGRP : 0; | |
226 | mode |= gx ? S_IXGRP : 0; | |
227 | mode |= or ? S_IROTH : 0; | |
228 | mode |= ow ? S_IWOTH : 0; | |
229 | mode |= ox ? S_IXOTH : 0; | |
230 | fd = open64(name, O_CREAT | O_RDWR, mode); | |
84b3db04 | 231 | if (fd < 0) |
f1adc05e JD |
232 | return -errno; |
233 | return fd; | |
1da177e4 LT |
234 | } |
235 | ||
5822b7fa | 236 | int set_attr(const char *file, struct hostfs_iattr *attrs, int fd) |
1da177e4 | 237 | { |
5822b7fa AB |
238 | struct timeval times[2]; |
239 | struct timespec atime_ts, mtime_ts; | |
1da177e4 LT |
240 | int err, ma; |
241 | ||
5822b7fa AB |
242 | if (attrs->ia_valid & HOSTFS_ATTR_MODE) { |
243 | if (fd >= 0) { | |
244 | if (fchmod(fd, attrs->ia_mode) != 0) | |
245 | return (-errno); | |
246 | } else if (chmod(file, attrs->ia_mode) != 0) { | |
f1adc05e | 247 | return -errno; |
5822b7fa | 248 | } |
1da177e4 | 249 | } |
5822b7fa AB |
250 | if (attrs->ia_valid & HOSTFS_ATTR_UID) { |
251 | if (fd >= 0) { | |
252 | if (fchown(fd, attrs->ia_uid, -1)) | |
f1adc05e | 253 | return -errno; |
84b3db04 | 254 | } else if (chown(file, attrs->ia_uid, -1)) { |
f1adc05e | 255 | return -errno; |
5822b7fa | 256 | } |
1da177e4 | 257 | } |
5822b7fa AB |
258 | if (attrs->ia_valid & HOSTFS_ATTR_GID) { |
259 | if (fd >= 0) { | |
260 | if (fchown(fd, -1, attrs->ia_gid)) | |
f1adc05e | 261 | return -errno; |
5822b7fa | 262 | } else if (chown(file, -1, attrs->ia_gid)) { |
f1adc05e | 263 | return -errno; |
5822b7fa | 264 | } |
1da177e4 | 265 | } |
5822b7fa AB |
266 | if (attrs->ia_valid & HOSTFS_ATTR_SIZE) { |
267 | if (fd >= 0) { | |
268 | if (ftruncate(fd, attrs->ia_size)) | |
f1adc05e | 269 | return -errno; |
5822b7fa | 270 | } else if (truncate(file, attrs->ia_size)) { |
f1adc05e | 271 | return -errno; |
5822b7fa | 272 | } |
1da177e4 | 273 | } |
5822b7fa | 274 | |
84b3db04 JD |
275 | /* |
276 | * Update accessed and/or modified time, in two parts: first set | |
5822b7fa | 277 | * times according to the changes to perform, and then call futimes() |
84b3db04 JD |
278 | * or utimes() to apply them. |
279 | */ | |
5822b7fa AB |
280 | ma = (HOSTFS_ATTR_ATIME_SET | HOSTFS_ATTR_MTIME_SET); |
281 | if (attrs->ia_valid & ma) { | |
282 | err = stat_file(file, NULL, NULL, NULL, NULL, NULL, NULL, | |
283 | &atime_ts, &mtime_ts, NULL, NULL, NULL, fd); | |
284 | if (err != 0) | |
285 | return err; | |
286 | ||
287 | times[0].tv_sec = atime_ts.tv_sec; | |
d7b88513 | 288 | times[0].tv_usec = atime_ts.tv_nsec / 1000; |
5822b7fa | 289 | times[1].tv_sec = mtime_ts.tv_sec; |
d7b88513 | 290 | times[1].tv_usec = mtime_ts.tv_nsec / 1000; |
5822b7fa AB |
291 | |
292 | if (attrs->ia_valid & HOSTFS_ATTR_ATIME_SET) { | |
293 | times[0].tv_sec = attrs->ia_atime.tv_sec; | |
d7b88513 | 294 | times[0].tv_usec = attrs->ia_atime.tv_nsec / 1000; |
1da177e4 | 295 | } |
5822b7fa AB |
296 | if (attrs->ia_valid & HOSTFS_ATTR_MTIME_SET) { |
297 | times[1].tv_sec = attrs->ia_mtime.tv_sec; | |
d7b88513 | 298 | times[1].tv_usec = attrs->ia_mtime.tv_nsec / 1000; |
5822b7fa AB |
299 | } |
300 | ||
301 | if (fd >= 0) { | |
302 | if (futimes(fd, times) != 0) | |
f1adc05e | 303 | return -errno; |
5822b7fa | 304 | } else if (utimes(file, times) != 0) { |
f1adc05e | 305 | return -errno; |
1da177e4 LT |
306 | } |
307 | } | |
5822b7fa | 308 | |
baabd156 | 309 | /* Note: ctime is not handled */ |
84b3db04 | 310 | if (attrs->ia_valid & (HOSTFS_ATTR_ATIME | HOSTFS_ATTR_MTIME)) { |
1da177e4 LT |
311 | err = stat_file(file, NULL, NULL, NULL, NULL, NULL, NULL, |
312 | &attrs->ia_atime, &attrs->ia_mtime, NULL, | |
5822b7fa | 313 | NULL, NULL, fd); |
84b3db04 | 314 | if (err != 0) |
f1adc05e | 315 | return err; |
1da177e4 | 316 | } |
f1adc05e | 317 | return 0; |
1da177e4 LT |
318 | } |
319 | ||
320 | int make_symlink(const char *from, const char *to) | |
321 | { | |
322 | int err; | |
323 | ||
324 | err = symlink(to, from); | |
84b3db04 | 325 | if (err) |
f1adc05e JD |
326 | return -errno; |
327 | return 0; | |
1da177e4 LT |
328 | } |
329 | ||
330 | int unlink_file(const char *file) | |
331 | { | |
332 | int err; | |
333 | ||
334 | err = unlink(file); | |
84b3db04 | 335 | if (err) |
f1adc05e JD |
336 | return -errno; |
337 | return 0; | |
1da177e4 LT |
338 | } |
339 | ||
340 | int do_mkdir(const char *file, int mode) | |
341 | { | |
342 | int err; | |
343 | ||
344 | err = mkdir(file, mode); | |
84b3db04 | 345 | if (err) |
f1adc05e JD |
346 | return -errno; |
347 | return 0; | |
1da177e4 LT |
348 | } |
349 | ||
350 | int do_rmdir(const char *file) | |
351 | { | |
352 | int err; | |
353 | ||
354 | err = rmdir(file); | |
84b3db04 | 355 | if (err) |
f1adc05e JD |
356 | return -errno; |
357 | return 0; | |
1da177e4 LT |
358 | } |
359 | ||
88f6cd0c | 360 | int do_mknod(const char *file, int mode, unsigned int major, unsigned int minor) |
1da177e4 LT |
361 | { |
362 | int err; | |
363 | ||
005a59ec | 364 | err = mknod(file, mode, os_makedev(major, minor)); |
84b3db04 | 365 | if (err) |
f1adc05e JD |
366 | return -errno; |
367 | return 0; | |
1da177e4 LT |
368 | } |
369 | ||
370 | int link_file(const char *to, const char *from) | |
371 | { | |
372 | int err; | |
373 | ||
374 | err = link(to, from); | |
84b3db04 | 375 | if (err) |
f1adc05e JD |
376 | return -errno; |
377 | return 0; | |
1da177e4 LT |
378 | } |
379 | ||
ea7e743e | 380 | int hostfs_do_readlink(char *file, char *buf, int size) |
1da177e4 LT |
381 | { |
382 | int n; | |
383 | ||
384 | n = readlink(file, buf, size); | |
84b3db04 | 385 | if (n < 0) |
f1adc05e | 386 | return -errno; |
84b3db04 | 387 | if (n < size) |
1da177e4 | 388 | buf[n] = '\0'; |
f1adc05e | 389 | return n; |
1da177e4 LT |
390 | } |
391 | ||
392 | int rename_file(char *from, char *to) | |
393 | { | |
394 | int err; | |
395 | ||
396 | err = rename(from, to); | |
84b3db04 | 397 | if (err < 0) |
f1adc05e JD |
398 | return -errno; |
399 | return 0; | |
1da177e4 LT |
400 | } |
401 | ||
402 | int do_statfs(char *root, long *bsize_out, long long *blocks_out, | |
403 | long long *bfree_out, long long *bavail_out, | |
404 | long long *files_out, long long *ffree_out, | |
405 | void *fsid_out, int fsid_size, long *namelen_out, | |
406 | long *spare_out) | |
407 | { | |
408 | struct statfs64 buf; | |
409 | int err; | |
410 | ||
411 | err = statfs64(root, &buf); | |
84b3db04 | 412 | if (err < 0) |
f1adc05e JD |
413 | return -errno; |
414 | ||
1da177e4 LT |
415 | *bsize_out = buf.f_bsize; |
416 | *blocks_out = buf.f_blocks; | |
417 | *bfree_out = buf.f_bfree; | |
418 | *bavail_out = buf.f_bavail; | |
419 | *files_out = buf.f_files; | |
420 | *ffree_out = buf.f_ffree; | |
421 | memcpy(fsid_out, &buf.f_fsid, | |
422 | sizeof(buf.f_fsid) > fsid_size ? fsid_size : | |
423 | sizeof(buf.f_fsid)); | |
424 | *namelen_out = buf.f_namelen; | |
425 | spare_out[0] = buf.f_spare[0]; | |
426 | spare_out[1] = buf.f_spare[1]; | |
427 | spare_out[2] = buf.f_spare[2]; | |
428 | spare_out[3] = buf.f_spare[3]; | |
429 | spare_out[4] = buf.f_spare[4]; | |
f1adc05e | 430 | return 0; |
1da177e4 | 431 | } |