sys/emulation/linux/linux_stats.c

   1 /*-
   2  * Copyright (c) 1994-1995 Søren Schmidt
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software withough specific prior written permission
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/compat/linux/linux_stats.c,v 1.22.2.3 2001/11/05 19:08:23 marcel Exp $
  29  * $DragonFly: src/sys/emulation/linux/linux_stats.c,v 1.27 2008/09/28 05:08:16 dillon Exp $
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/conf.h>
  35 #include <sys/dirent.h>
  36 #include <sys/file.h>
  37 #include <sys/filedesc.h>
  38 #include <sys/proc.h>
  39 #include <sys/mount.h>
  40 #include <sys/nlookup.h>
  41 #include <sys/stat.h>
  42 #include <sys/sysctl.h>
  43 #include <sys/systm.h>
  44 #include <sys/unistd.h>
  45 #include <sys/vnode.h>
  46 #include <sys/device.h>
  47 #include <sys/file2.h>
  48 #include <sys/kern_syscall.h>
  49
  50 #include <arch_linux/linux.h>
  51 #include <arch_linux/linux_proto.h>
  52 #include "linux_util.h"
  53
  54 static int
  55 newstat_copyout(struct stat *buf, void *ubuf)
  56 {
  57         struct l_newstat tbuf;
  58         cdev_t dev;
  59         int error;
  60
  61         tbuf.st_dev = uminor(buf->st_dev) | (umajor(buf->st_dev) << 8);
  62         tbuf.st_ino = INO64TO32(buf->st_ino);
  63         tbuf.st_mode = buf->st_mode;
  64         tbuf.st_nlink = buf->st_nlink;
  65         tbuf.st_uid = buf->st_uid;
  66         tbuf.st_gid = buf->st_gid;
  67         tbuf.st_rdev = buf->st_rdev;
  68         tbuf.st_size = buf->st_size;
  69         tbuf.st_atime = buf->st_atime;
  70         tbuf.st_mtime = buf->st_mtime;
  71         tbuf.st_ctime = buf->st_ctime;
  72         tbuf.st_blksize = buf->st_blksize;
  73         tbuf.st_blocks = buf->st_blocks;
  74
  75         /* Lie about disk drives which are character devices
  76          * in FreeBSD but block devices under Linux.
  77          */
  78         if (S_ISCHR(tbuf.st_mode) &&
  79             (dev = udev2dev(buf->st_rdev, 0)) != NULL) {
  80                 if (dev_is_good(dev) && (dev_dflags(dev) & D_DISK)) {
  81                         tbuf.st_mode &= ~S_IFMT;
  82                         tbuf.st_mode |= S_IFBLK;
  83
  84                         /* XXX this may not be quite right */
  85                         /* Map major number to 0 */
  86                         tbuf.st_dev = uminor(buf->st_dev) & 0xf;
  87                         tbuf.st_rdev = buf->st_rdev & 0xff;
  88                 }
  89         }
  90
  91         error = copyout(&tbuf, ubuf, sizeof(tbuf));
  92         return (error);
  93 }
  94
  95 /*
  96  * MPALMOSTSAFE
  97  */
  98 int
  99 sys_linux_newstat(struct linux_newstat_args *args)
 100 {
 101         struct stat buf;
 102         struct nlookupdata nd;
 103         char *path;
 104         int error;
 105
 106         error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
 107         if (error)
 108                 return (error);
 109 #ifdef DEBUG
 110         if (ldebug(newstat))
 111                 kprintf(ARGS(newstat, "%s, *"), path);
 112 #endif
 113         get_mplock();
 114         error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
 115         if (error == 0) {
 116                 error = kern_stat(&nd, &buf);
 117                 if (error == 0)
 118                         error = newstat_copyout(&buf, args->buf);
 119                 nlookup_done(&nd);
 120         }
 121         rel_mplock();
 122         linux_free_path(&path);
 123         return (error);
 124 }
 125
 126 /*
 127  * MPALMOSTSAFE
 128  */
 129 int
 130 sys_linux_newlstat(struct linux_newlstat_args *args)
 131 {
 132         struct stat sb;
 133         struct nlookupdata nd;
 134         char *path;
 135         int error;
 136
 137         error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
 138         if (error)
 139                 return (error);
 140 #ifdef DEBUG
 141         if (ldebug(newlstat))
 142                 kprintf(ARGS(newlstat, "%s, *"), path);
 143 #endif
 144         get_mplock();
 145         error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
 146         if (error == 0) {
 147                 error = kern_stat(&nd, &sb);
 148                 if (error == 0)
 149                         error = newstat_copyout(&sb, args->buf);
 150                 nlookup_done(&nd);
 151         }
 152         rel_mplock();
 153         linux_free_path(&path);
 154         return (error);
 155 }
 156
 157 /*
 158  * MPALMOSTSAFE
 159  */
 160 int
 161 sys_linux_newfstat(struct linux_newfstat_args *args)
 162 {
 163         struct stat buf;
 164         int error;
 165
 166 #ifdef DEBUG
 167         if (ldebug(newfstat))
 168                 kprintf(ARGS(newfstat, "%d, *"), args->fd);
 169 #endif
 170         get_mplock();
 171         error = kern_fstat(args->fd, &buf);
 172         rel_mplock();
 173
 174         if (error == 0)
 175                 error = newstat_copyout(&buf, args->buf);
 176         return (error);
 177 }
 178
 179 /* XXX - All fields of type l_int are defined as l_long on i386 */
 180 struct l_statfs {
 181         l_int           f_type;
 182         l_int           f_bsize;
 183         l_int           f_blocks;
 184         l_int           f_bfree;
 185         l_int           f_bavail;
 186         l_int           f_files;
 187         l_int           f_ffree;
 188         l_fsid_t        f_fsid;
 189         l_int           f_namelen;
 190         l_int           f_spare[6];
 191 };
 192
 193 #define LINUX_CODA_SUPER_MAGIC  0x73757245L
 194 #define LINUX_EXT2_SUPER_MAGIC  0xEF53L
 195 #define LINUX_HPFS_SUPER_MAGIC  0xf995e849L
 196 #define LINUX_ISOFS_SUPER_MAGIC 0x9660L
 197 #define LINUX_MSDOS_SUPER_MAGIC 0x4d44L
 198 #define LINUX_NCP_SUPER_MAGIC   0x564cL
 199 #define LINUX_NFS_SUPER_MAGIC   0x6969L
 200 #define LINUX_NTFS_SUPER_MAGIC  0x5346544EL
 201 #define LINUX_PROC_SUPER_MAGIC  0x9fa0L
 202 #define LINUX_UFS_SUPER_MAGIC   0x00011954L     /* XXX - UFS_MAGIC in Linux */
 203
 204 static long
 205 bsd_to_linux_ftype(const char *fstypename)
 206 {
 207         int i;
 208         static struct {const char *bsd_name; long linux_type;} b2l_tbl[] = {
 209                 {"ufs",     LINUX_UFS_SUPER_MAGIC},
 210                 {"cd9660",  LINUX_ISOFS_SUPER_MAGIC},
 211                 {"nfs",     LINUX_NFS_SUPER_MAGIC},
 212                 {"ext2fs",  LINUX_EXT2_SUPER_MAGIC},
 213                 {"procfs",  LINUX_PROC_SUPER_MAGIC},
 214                 {"msdosfs", LINUX_MSDOS_SUPER_MAGIC},
 215                 {"ntfs",    LINUX_NTFS_SUPER_MAGIC},
 216                 {"nwfs",    LINUX_NCP_SUPER_MAGIC},
 217                 {"hpfs",    LINUX_HPFS_SUPER_MAGIC},
 218                 {NULL,      0L}};
 219
 220         for (i = 0; b2l_tbl[i].bsd_name != NULL; i++)
 221                 if (strcmp(b2l_tbl[i].bsd_name, fstypename) == 0)
 222                         return (b2l_tbl[i].linux_type);
 223
 224         return (0L);
 225 }
 226
 227 static int
 228 statfs_copyout(struct statfs *statfs, struct l_statfs_buf *buf, l_int namelen)
 229 {
 230         struct l_statfs linux_statfs;
 231         int error;
 232
 233         linux_statfs.f_type = bsd_to_linux_ftype(statfs->f_fstypename);
 234         linux_statfs.f_bsize = statfs->f_bsize;
 235         linux_statfs.f_blocks = statfs->f_blocks;
 236         linux_statfs.f_bfree = statfs->f_bfree;
 237         linux_statfs.f_bavail = statfs->f_bavail;
 238         linux_statfs.f_ffree = statfs->f_ffree;
 239         linux_statfs.f_files = statfs->f_files;
 240         linux_statfs.f_fsid.val[0] = statfs->f_fsid.val[0];
 241         linux_statfs.f_fsid.val[1] = statfs->f_fsid.val[1];
 242         linux_statfs.f_namelen = namelen;
 243
 244         error = copyout(&linux_statfs, buf, sizeof(linux_statfs));
 245         return (error);
 246 }
 247
 248 /*
 249  * MPALMOSTSAFE
 250  */
 251 int
 252 sys_linux_statfs(struct linux_statfs_args *args)
 253 {
 254         struct statfs statfs;
 255         struct nlookupdata nd;
 256         char *path;
 257         int error, namelen;
 258
 259         error = linux_copyin_path(args->path, &path, LINUX_PATH_EXISTS);
 260         if (error)
 261                 return (error);
 262 #ifdef DEBUG
 263         if (ldebug(statfs))
 264                 kprintf(ARGS(statfs, "%s, *"), path);
 265 #endif
 266         get_mplock();
 267         error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
 268         if (error == 0)
 269                 error = kern_statfs(&nd, &statfs);
 270         if (error == 0) {
 271                 if (nd.nl_nch.ncp->nc_vp != NULL)
 272                         error = vn_get_namelen(nd.nl_nch.ncp->nc_vp, &namelen);
 273                 else
 274                         error = EINVAL;
 275         }
 276         nlookup_done(&nd);
 277         rel_mplock();
 278         if (error == 0)
 279                 error = statfs_copyout(&statfs, args->buf, (l_int)namelen);
 280         linux_free_path(&path);
 281         return (error);
 282 }
 283
 284 /*
 285  * MPALMOSTSAFE
 286  */
 287 int
 288 sys_linux_fstatfs(struct linux_fstatfs_args *args)
 289 {
 290         struct proc *p = curthread->td_proc;
 291         struct file *fp;
 292         struct statfs statfs;
 293         int error, namelen;
 294
 295 #ifdef DEBUG
 296         if (ldebug(fstatfs))
 297                 kprintf(ARGS(fstatfs, "%d, *"), args->fd);
 298 #endif
 299         get_mplock();
 300         if ((error = kern_fstatfs(args->fd, &statfs)) != 0)
 301                 return (error);
 302         if ((error = holdvnode(p->p_fd, args->fd, &fp)) != 0)
 303                 return (error);
 304         error = vn_get_namelen((struct vnode *)fp->f_data, &namelen);
 305         rel_mplock();
 306         fdrop(fp);
 307         if (error == 0)
 308                 error = statfs_copyout(&statfs, args->buf, (l_int)namelen);
 309         return (error);
 310 }
 311
 312 struct l_ustat
 313 {
 314         l_daddr_t       f_tfree;
 315         l_ino_t         f_tinode;
 316         char            f_fname[6];
 317         char            f_fpack[6];
 318 };
 319
 320 /*
 321  * MPALMOSTSAFE
 322  */
 323 int
 324 sys_linux_ustat(struct linux_ustat_args *args)
 325 {
 326         struct thread *td = curthread;
 327         struct l_ustat lu;
 328         cdev_t dev;
 329         struct vnode *vp;
 330         struct statfs *stat;
 331         int error;
 332
 333 #ifdef DEBUG
 334         if (ldebug(ustat))
 335                 kprintf(ARGS(ustat, "%d, *"), args->dev);
 336 #endif
 337
 338         /*
 339          * lu.f_fname and lu.f_fpack are not used. They are always zeroed.
 340          * lu.f_tinode and lu.f_tfree are set from the device's super block.
 341          */
 342         bzero(&lu, sizeof(lu));
 343
 344         /*
 345          * XXX - Don't return an error if we can't find a vnode for the
 346          * device. Our cdev_t is 32-bits whereas Linux only has a 16-bits
 347          * cdev_t. The dev_t that is used now may as well be a truncated
 348          * cdev_t returned from previous syscalls. Just return a bzeroed
 349          * ustat in that case.
 350          */
 351         get_mplock();
 352         dev = udev2dev(makeudev(args->dev >> 8, args->dev & 0xFF), 0);
 353         if (dev != NULL && vfinddev(dev, VCHR, &vp)) {
 354                 if (vp->v_mount == NULL) {
 355                         vrele(vp);
 356                         error = EINVAL;
 357                         goto done;
 358                 }
 359                 stat = &(vp->v_mount->mnt_stat);
 360                 error = VFS_STATFS(vp->v_mount, stat, td->td_ucred);
 361                 vrele(vp);
 362                 if (error == 0) {
 363                         lu.f_tfree = stat->f_bfree;
 364                         lu.f_tinode = stat->f_ffree;
 365                 }
 366         } else {
 367                 error = 0;
 368         }
 369 done:
 370         rel_mplock();
 371         if (error == 0)
 372                 error = copyout(&lu, args->ubuf, sizeof(lu));
 373         return (error);
 374 }
 375
 376 #if defined(__i386__)
 377
 378 static int
 379 stat64_copyout(struct stat *buf, void *ubuf)
 380 {
 381         struct l_stat64 lbuf;
 382         int error;
 383
 384         bzero(&lbuf, sizeof(lbuf));
 385         lbuf.st_dev = uminor(buf->st_dev) | (umajor(buf->st_dev) << 8);
 386         lbuf.st_ino = buf->st_ino;
 387         lbuf.st_mode = buf->st_mode;
 388         lbuf.st_nlink = buf->st_nlink;
 389         lbuf.st_uid = buf->st_uid;
 390         lbuf.st_gid = buf->st_gid;
 391         lbuf.st_rdev = buf->st_rdev;
 392         lbuf.st_size = buf->st_size;
 393         lbuf.st_atime = buf->st_atime;
 394         lbuf.st_mtime = buf->st_mtime;
 395         lbuf.st_ctime = buf->st_ctime;
 396         lbuf.st_blksize = buf->st_blksize;
 397         lbuf.st_blocks = buf->st_blocks;
 398
 399         /*
 400          * The __st_ino field makes all the difference. In the Linux kernel
 401          * it is conditionally compiled based on STAT64_HAS_BROKEN_ST_INO,
 402          * but without the assignment to __st_ino the runtime linker refuses
 403          * to mmap(2) any shared libraries. I guess it's broken alright :-)
 404          */
 405         lbuf.__st_ino = INO64TO32(buf->st_ino);
 406
 407         error = copyout(&lbuf, ubuf, sizeof(lbuf));
 408         return (error);
 409 }
 410
 411 /*
 412  * MPALMOSTSAFE
 413  */
 414 int
 415 sys_linux_stat64(struct linux_stat64_args *args)
 416 {
 417         struct nlookupdata nd;
 418         struct stat buf;
 419         char *path;
 420         int error;
 421
 422         error = linux_copyin_path(args->filename, &path, LINUX_PATH_EXISTS);
 423         if (error)
 424                 return (error);
 425 #ifdef DEBUG
 426         if (ldebug(stat64))
 427                 kprintf(ARGS(stat64, "%s, *"), path);
 428 #endif
 429         get_mplock();
 430         error = nlookup_init(&nd, path, UIO_SYSSPACE, NLC_FOLLOW);
 431         if (error == 0) {
 432                 error = kern_stat(&nd, &buf);
 433                 nlookup_done(&nd);
 434         }
 435         rel_mplock();
 436         if (error == 0)
 437                 error = stat64_copyout(&buf, args->statbuf);
 438         linux_free_path(&path);
 439         return (error);
 440 }
 441
 442 /*
 443  * MPALMOSTSAFE
 444  */
 445 int
 446 sys_linux_lstat64(struct linux_lstat64_args *args)
 447 {
 448         struct nlookupdata nd;
 449         struct stat sb;
 450         char *path;
 451         int error;
 452
 453         error = linux_copyin_path(args->filename, &path, LINUX_PATH_EXISTS);
 454         if (error)
 455                 return (error);
 456 #ifdef DEBUG
 457         if (ldebug(lstat64))
 458                 kprintf(ARGS(lstat64, "%s, *"), path);
 459 #endif
 460         get_mplock();
 461         error = nlookup_init(&nd, path, UIO_SYSSPACE, 0);
 462         if (error == 0) {
 463                 error = kern_stat(&nd, &sb);
 464                 nlookup_done(&nd);
 465         }
 466         rel_mplock();
 467         if (error == 0)
 468                 error = stat64_copyout(&sb, args->statbuf);
 469         linux_free_path(&path);
 470         return (error);
 471 }
 472
 473 /*
 474  * MPALMOSTSAFE
 475  */
 476 int
 477 sys_linux_fstat64(struct linux_fstat64_args *args)
 478 {
 479         struct stat buf;
 480         int error;
 481
 482 #ifdef DEBUG
 483         if (ldebug(fstat64))
 484                 kprintf(ARGS(fstat64, "%d, *"), args->fd);
 485 #endif
 486         get_mplock();
 487         error = kern_fstat(args->fd, &buf);
 488         rel_mplock();
 489
 490         if (error == 0)
 491                 error = stat64_copyout(&buf, args->statbuf);
 492         return (error);
 493 }
 494
 495 #endif /* __i386__ */