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