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