arch/sparc64/solaris/fs.c

   1 /* $Id: fs.c,v 1.27 2002/02/08 03:57:14 davem Exp $
   2  * fs.c: fs related syscall emulation for Solaris
   3  *
   4  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   5  *
   6  * 1999-08-19 Implemented solaris F_FREESP (truncate)
   7  *            fcntl, by Jason Rappleye (rappleye@ccr.buffalo.edu)
   8  */
   9
  10 #include <linux/types.h>
  11 #include <linux/sched.h>
  12 #include <linux/slab.h>
  13 #include <linux/capability.h>
  14 #include <linux/fs.h>
  15 #include <linux/namei.h>
  16 #include <linux/mm.h>
  17 #include <linux/file.h>
  18 #include <linux/stat.h>
  19 #include <linux/smp_lock.h>
  20 #include <linux/limits.h>
  21 #include <linux/resource.h>
  22 #include <linux/quotaops.h>
  23 #include <linux/mount.h>
  24 #include <linux/vfs.h>
  25
  26 #include <asm/uaccess.h>
  27 #include <asm/string.h>
  28 #include <asm/ptrace.h>
  29
  30 #include "conv.h"
  31
  32 #define R3_VERSION      1
  33 #define R4_VERSION      2
  34
  35 typedef struct {
  36         s32     tv_sec;
  37         s32     tv_nsec;
  38 } timestruct_t;
  39
  40 struct sol_stat {
  41         u32             st_dev;
  42         s32             st_pad1[3];     /* network id */
  43         u32             st_ino;
  44         u32             st_mode;
  45         u32             st_nlink;
  46         u32             st_uid;
  47         u32             st_gid;
  48         u32             st_rdev;
  49         s32             st_pad2[2];
  50         s32             st_size;
  51         s32             st_pad3;        /* st_size, off_t expansion */
  52         timestruct_t    st_atime;
  53         timestruct_t    st_mtime;
  54         timestruct_t    st_ctime;
  55         s32             st_blksize;
  56         s32             st_blocks;
  57         char            st_fstype[16];
  58         s32             st_pad4[8];     /* expansion area */
  59 };
  60
  61 struct sol_stat64 {
  62         u32             st_dev;
  63         s32             st_pad1[3];     /* network id */
  64         u64             st_ino;
  65         u32             st_mode;
  66         u32             st_nlink;
  67         u32             st_uid;
  68         u32             st_gid;
  69         u32             st_rdev;
  70         s32             st_pad2[2];
  71         s64             st_size;
  72         timestruct_t    st_atime;
  73         timestruct_t    st_mtime;
  74         timestruct_t    st_ctime;
  75         s64             st_blksize;
  76         s32             st_blocks;
  77         char            st_fstype[16];
  78         s32             st_pad4[4];     /* expansion area */
  79 };
  80
  81 #define UFSMAGIC (((unsigned)'u'<<24)||((unsigned)'f'<<16)||((unsigned)'s'<<8))
  82
  83 static inline int putstat(struct sol_stat __user *ubuf, struct kstat *kbuf)
  84 {
  85         u32 ino;
  86
  87         if (kbuf->size > MAX_NON_LFS ||
  88             !sysv_valid_dev(kbuf->dev) ||
  89             !sysv_valid_dev(kbuf->rdev))
  90                 return -EOVERFLOW;
  91         ino = kbuf->ino;
  92         if (sizeof(ino) < sizeof(kbuf->ino) && ino != kbuf->ino)
  93                 return -EOVERFLOW;
  94         if (put_user (sysv_encode_dev(kbuf->dev), &ubuf->st_dev)        ||
  95             __put_user (ino, &ubuf->st_ino)                             ||
  96             __put_user (kbuf->mode, &ubuf->st_mode)             ||
  97             __put_user (kbuf->nlink, &ubuf->st_nlink)   ||
  98             __put_user (kbuf->uid, &ubuf->st_uid)               ||
  99             __put_user (kbuf->gid, &ubuf->st_gid)               ||
 100             __put_user (sysv_encode_dev(kbuf->rdev), &ubuf->st_rdev)    ||
 101             __put_user (kbuf->size, &ubuf->st_size)             ||
 102             __put_user (kbuf->atime.tv_sec, &ubuf->st_atime.tv_sec)     ||
 103             __put_user (kbuf->atime.tv_nsec, &ubuf->st_atime.tv_nsec)   ||
 104             __put_user (kbuf->mtime.tv_sec, &ubuf->st_mtime.tv_sec)     ||
 105             __put_user (kbuf->mtime.tv_nsec, &ubuf->st_mtime.tv_nsec)   ||
 106             __put_user (kbuf->ctime.tv_sec, &ubuf->st_ctime.tv_sec)     ||
 107             __put_user (kbuf->ctime.tv_nsec, &ubuf->st_ctime.tv_nsec)   ||
 108             __put_user (kbuf->blksize, &ubuf->st_blksize)       ||
 109             __put_user (kbuf->blocks, &ubuf->st_blocks) ||
 110             __put_user (UFSMAGIC, (unsigned __user *)ubuf->st_fstype))
 111                 return -EFAULT;
 112         return 0;
 113 }
 114
 115 static inline int putstat64(struct sol_stat64 __user *ubuf, struct kstat *kbuf)
 116 {
 117         if (!sysv_valid_dev(kbuf->dev) || !sysv_valid_dev(kbuf->rdev))
 118                 return -EOVERFLOW;
 119         if (put_user (sysv_encode_dev(kbuf->dev), &ubuf->st_dev)        ||
 120             __put_user (kbuf->ino, &ubuf->st_ino)               ||
 121             __put_user (kbuf->mode, &ubuf->st_mode)             ||
 122             __put_user (kbuf->nlink, &ubuf->st_nlink)   ||
 123             __put_user (kbuf->uid, &ubuf->st_uid)               ||
 124             __put_user (kbuf->gid, &ubuf->st_gid)               ||
 125             __put_user (sysv_encode_dev(kbuf->rdev), &ubuf->st_rdev)    ||
 126             __put_user (kbuf->size, &ubuf->st_size)             ||
 127             __put_user (kbuf->atime.tv_sec, &ubuf->st_atime.tv_sec)     ||
 128             __put_user (kbuf->atime.tv_nsec, &ubuf->st_atime.tv_nsec)   ||
 129             __put_user (kbuf->mtime.tv_sec, &ubuf->st_mtime.tv_sec)     ||
 130             __put_user (kbuf->mtime.tv_nsec, &ubuf->st_mtime.tv_nsec)   ||
 131             __put_user (kbuf->ctime.tv_sec, &ubuf->st_ctime.tv_sec)     ||
 132             __put_user (kbuf->ctime.tv_nsec, &ubuf->st_ctime.tv_nsec)   ||
 133             __put_user (kbuf->blksize, &ubuf->st_blksize)       ||
 134             __put_user (kbuf->blocks, &ubuf->st_blocks) ||
 135             __put_user (UFSMAGIC, (unsigned __user *)ubuf->st_fstype))
 136                 return -EFAULT;
 137         return 0;
 138 }
 139
 140 asmlinkage int solaris_stat(u32 filename, u32 statbuf)
 141 {
 142         struct kstat s;
 143         int ret = vfs_stat(A(filename), &s);
 144         if (!ret)
 145                 return putstat(A(statbuf), &s);
 146         return ret;
 147 }
 148
 149 asmlinkage int solaris_xstat(int vers, u32 filename, u32 statbuf)
 150 {
 151         /* Solaris doesn't bother with looking at vers, so we do neither */
 152         return solaris_stat(filename, statbuf);
 153 }
 154
 155 asmlinkage int solaris_stat64(u32 filename, u32 statbuf)
 156 {
 157         struct kstat s;
 158         int ret = vfs_stat(A(filename), &s);
 159         if (!ret)
 160                 return putstat64(A(statbuf), &s);
 161         return ret;
 162 }
 163
 164 asmlinkage int solaris_lstat(u32 filename, u32 statbuf)
 165 {
 166         struct kstat s;
 167         int ret = vfs_lstat(A(filename), &s);
 168         if (!ret)
 169                 return putstat(A(statbuf), &s);
 170         return ret;
 171 }
 172
 173 asmlinkage int solaris_lxstat(int vers, u32 filename, u32 statbuf)
 174 {
 175         return solaris_lstat(filename, statbuf);
 176 }
 177
 178 asmlinkage int solaris_lstat64(u32 filename, u32 statbuf)
 179 {
 180         struct kstat s;
 181         int ret = vfs_lstat(A(filename), &s);
 182         if (!ret)
 183                 return putstat64(A(statbuf), &s);
 184         return ret;
 185 }
 186
 187 asmlinkage int solaris_fstat(unsigned int fd, u32 statbuf)
 188 {
 189         struct kstat s;
 190         int ret = vfs_fstat(fd, &s);
 191         if (!ret)
 192                 return putstat(A(statbuf), &s);
 193         return ret;
 194 }
 195
 196 asmlinkage int solaris_fxstat(int vers, u32 fd, u32 statbuf)
 197 {
 198         return solaris_fstat(fd, statbuf);
 199 }
 200
 201 asmlinkage int solaris_fstat64(unsigned int fd, u32 statbuf)
 202 {
 203         struct kstat s;
 204         int ret = vfs_fstat(fd, &s);
 205         if (!ret)
 206                 return putstat64(A(statbuf), &s);
 207         return ret;
 208 }
 209
 210 asmlinkage int solaris_mknod(u32 path, u32 mode, s32 dev)
 211 {
 212         int (*sys_mknod)(const char __user *,int,unsigned) =
 213                 (int (*)(const char __user *,int,unsigned))SYS(mknod);
 214         int major = sysv_major(dev);
 215         int minor = sysv_minor(dev);
 216
 217         /* minor is guaranteed to be OK for MKDEV, major might be not */
 218         if (major > 0xfff)
 219                 return -EINVAL;
 220         return sys_mknod(A(path), mode, new_encode_dev(MKDEV(major,minor)));
 221 }
 222
 223 asmlinkage int solaris_xmknod(int vers, u32 path, u32 mode, s32 dev)
 224 {
 225         return solaris_mknod(path, mode, dev);
 226 }
 227
 228 asmlinkage int solaris_getdents64(unsigned int fd, void __user *dirent, unsigned int count)
 229 {
 230         int (*sys_getdents)(unsigned int, void __user *, unsigned int) =
 231                 (int (*)(unsigned int, void __user *, unsigned int))SYS(getdents);
 232
 233         return sys_getdents(fd, dirent, count);
 234 }
 235
 236 /* This statfs thingie probably will go in the near future, but... */
 237
 238 struct sol_statfs {
 239         short   f_type;
 240         s32     f_bsize;
 241         s32     f_frsize;
 242         s32     f_blocks;
 243         s32     f_bfree;
 244         u32     f_files;
 245         u32     f_ffree;
 246         char    f_fname[6];
 247         char    f_fpack[6];
 248 };
 249
 250 asmlinkage int solaris_statfs(u32 path, u32 buf, int len, int fstype)
 251 {
 252         int ret;
 253         struct statfs s;
 254         mm_segment_t old_fs = get_fs();
 255         int (*sys_statfs)(const char __user *,struct statfs __user *) =
 256                 (int (*)(const char __user *,struct statfs __user *))SYS(statfs);
 257         struct sol_statfs __user *ss = A(buf);
 258
 259         if (len != sizeof(struct sol_statfs)) return -EINVAL;
 260         if (!fstype) {
 261                 /* FIXME: mixing userland and kernel pointers */
 262                 set_fs (KERNEL_DS);
 263                 ret = sys_statfs(A(path), &s);
 264                 set_fs (old_fs);
 265                 if (!ret) {
 266                         if (put_user (s.f_type, &ss->f_type)            ||
 267                             __put_user (s.f_bsize, &ss->f_bsize)        ||
 268                             __put_user (0, &ss->f_frsize)               ||
 269                             __put_user (s.f_blocks, &ss->f_blocks)      ||
 270                             __put_user (s.f_bfree, &ss->f_bfree)        ||
 271                             __put_user (s.f_files, &ss->f_files)        ||
 272                             __put_user (s.f_ffree, &ss->f_ffree)        ||
 273                             __clear_user (&ss->f_fname, 12))
 274                                 return -EFAULT;
 275                 }
 276                 return ret;
 277         }
 278 /* Linux can't stat unmounted filesystems so we
 279  * simply lie and claim 100MB of 1GB is free. Sorry.
 280  */
 281         if (put_user (fstype, &ss->f_type)              ||
 282             __put_user (1024, &ss->f_bsize)             ||
 283             __put_user (0, &ss->f_frsize)               ||
 284             __put_user (1024*1024, &ss->f_blocks)       ||
 285             __put_user (100*1024, &ss->f_bfree)         ||
 286             __put_user (60000, &ss->f_files)            ||
 287             __put_user (50000, &ss->f_ffree)            ||
 288             __clear_user (&ss->f_fname, 12))
 289                 return -EFAULT;
 290         return 0;
 291 }
 292
 293 asmlinkage int solaris_fstatfs(u32 fd, u32 buf, int len, int fstype)
 294 {
 295         int ret;
 296         struct statfs s;
 297         mm_segment_t old_fs = get_fs();
 298         int (*sys_fstatfs)(unsigned,struct statfs __user *) =
 299                 (int (*)(unsigned,struct statfs __user *))SYS(fstatfs);
 300         struct sol_statfs __user *ss = A(buf);
 301
 302         if (len != sizeof(struct sol_statfs)) return -EINVAL;
 303         if (!fstype) {
 304                 set_fs (KERNEL_DS);
 305                 ret = sys_fstatfs(fd, &s);
 306                 set_fs (old_fs);
 307                 if (!ret) {
 308                         if (put_user (s.f_type, &ss->f_type)            ||
 309                             __put_user (s.f_bsize, &ss->f_bsize)        ||
 310                             __put_user (0, &ss->f_frsize)               ||
 311                             __put_user (s.f_blocks, &ss->f_blocks)      ||
 312                             __put_user (s.f_bfree, &ss->f_bfree)        ||
 313                             __put_user (s.f_files, &ss->f_files)        ||
 314                             __put_user (s.f_ffree, &ss->f_ffree)        ||
 315                             __clear_user (&ss->f_fname, 12))
 316                                 return -EFAULT;
 317                 }
 318                 return ret;
 319         }
 320         /* Otherwise fstatfs is the same as statfs */
 321         return solaris_statfs(0, buf, len, fstype);
 322 }
 323
 324 struct sol_statvfs {
 325         u32     f_bsize;
 326         u32     f_frsize;
 327         u32     f_blocks;
 328         u32     f_bfree;
 329         u32     f_bavail;
 330         u32     f_files;
 331         u32     f_ffree;
 332         u32     f_favail;
 333         u32     f_fsid;
 334         char    f_basetype[16];
 335         u32     f_flag;
 336         u32     f_namemax;
 337         char    f_fstr[32];
 338         u32     f_filler[16];
 339 };
 340
 341 struct sol_statvfs64 {
 342         u32     f_bsize;
 343         u32     f_frsize;
 344         u64     f_blocks;
 345         u64     f_bfree;
 346         u64     f_bavail;
 347         u64     f_files;
 348         u64     f_ffree;
 349         u64     f_favail;
 350         u32     f_fsid;
 351         char    f_basetype[16];
 352         u32     f_flag;
 353         u32     f_namemax;
 354         char    f_fstr[32];
 355         u32     f_filler[16];
 356 };
 357
 358 static int report_statvfs(struct vfsmount *mnt, struct inode *inode, u32 buf)
 359 {
 360         struct kstatfs s;
 361         int error;
 362         struct sol_statvfs __user *ss = A(buf);
 363
 364         error = vfs_statfs(mnt->mnt_root, &s);
 365         if (!error) {
 366                 const char *p = mnt->mnt_sb->s_type->name;
 367                 int i = 0;
 368                 int j = strlen (p);
 369
 370                 if (j > 15) j = 15;
 371                 if (IS_RDONLY(inode)) i = 1;
 372                 if (mnt->mnt_flags & MNT_NOSUID) i |= 2;
 373                 if (!sysv_valid_dev(inode->i_sb->s_dev))
 374                         return -EOVERFLOW;
 375                 if (put_user (s.f_bsize, &ss->f_bsize)          ||
 376                     __put_user (0, &ss->f_frsize)               ||
 377                     __put_user (s.f_blocks, &ss->f_blocks)      ||
 378                     __put_user (s.f_bfree, &ss->f_bfree)        ||
 379                     __put_user (s.f_bavail, &ss->f_bavail)      ||
 380                     __put_user (s.f_files, &ss->f_files)        ||
 381                     __put_user (s.f_ffree, &ss->f_ffree)        ||
 382                     __put_user (s.f_ffree, &ss->f_favail)       ||
 383                     __put_user (sysv_encode_dev(inode->i_sb->s_dev), &ss->f_fsid) ||
 384                     __copy_to_user (ss->f_basetype,p,j)         ||
 385                     __put_user (0, (char __user *)&ss->f_basetype[j])   ||
 386                     __put_user (s.f_namelen, &ss->f_namemax)    ||
 387                     __put_user (i, &ss->f_flag)                 ||
 388                     __clear_user (&ss->f_fstr, 32))
 389                         return -EFAULT;
 390         }
 391         return error;
 392 }
 393
 394 static int report_statvfs64(struct vfsmount *mnt, struct inode *inode, u32 buf)
 395 {
 396         struct kstatfs s;
 397         int error;
 398         struct sol_statvfs64 __user *ss = A(buf);
 399
 400         error = vfs_statfs(mnt->mnt_root, &s);
 401         if (!error) {
 402                 const char *p = mnt->mnt_sb->s_type->name;
 403                 int i = 0;
 404                 int j = strlen (p);
 405
 406                 if (j > 15) j = 15;
 407                 if (IS_RDONLY(inode)) i = 1;
 408                 if (mnt->mnt_flags & MNT_NOSUID) i |= 2;
 409                 if (!sysv_valid_dev(inode->i_sb->s_dev))
 410                         return -EOVERFLOW;
 411                 if (put_user (s.f_bsize, &ss->f_bsize)          ||
 412                     __put_user (0, &ss->f_frsize)               ||
 413                     __put_user (s.f_blocks, &ss->f_blocks)      ||
 414                     __put_user (s.f_bfree, &ss->f_bfree)        ||
 415                     __put_user (s.f_bavail, &ss->f_bavail)      ||
 416                     __put_user (s.f_files, &ss->f_files)        ||
 417                     __put_user (s.f_ffree, &ss->f_ffree)        ||
 418                     __put_user (s.f_ffree, &ss->f_favail)       ||
 419                     __put_user (sysv_encode_dev(inode->i_sb->s_dev), &ss->f_fsid) ||
 420                     __copy_to_user (ss->f_basetype,p,j)         ||
 421                     __put_user (0, (char __user *)&ss->f_basetype[j])   ||
 422                     __put_user (s.f_namelen, &ss->f_namemax)    ||
 423                     __put_user (i, &ss->f_flag)                 ||
 424                     __clear_user (&ss->f_fstr, 32))
 425                         return -EFAULT;
 426         }
 427         return error;
 428 }
 429
 430 asmlinkage int solaris_statvfs(u32 path, u32 buf)
 431 {
 432         struct nameidata nd;
 433         int error;
 434
 435         error = user_path_walk(A(path),&nd);
 436         if (!error) {
 437                 struct inode * inode = nd.dentry->d_inode;
 438                 error = report_statvfs(nd.mnt, inode, buf);
 439                 path_release(&nd);
 440         }
 441         return error;
 442 }
 443
 444 asmlinkage int solaris_fstatvfs(unsigned int fd, u32 buf)
 445 {
 446         struct file * file;
 447         int error;
 448
 449         error = -EBADF;
 450         file = fget(fd);
 451         if (file) {
 452                 error = report_statvfs(file->f_path.mnt, file->f_path.dentry->d_inode, buf);
 453                 fput(file);
 454         }
 455
 456         return error;
 457 }
 458
 459 asmlinkage int solaris_statvfs64(u32 path, u32 buf)
 460 {
 461         struct nameidata nd;
 462         int error;
 463
 464         lock_kernel();
 465         error = user_path_walk(A(path), &nd);
 466         if (!error) {
 467                 struct inode * inode = nd.dentry->d_inode;
 468                 error = report_statvfs64(nd.mnt, inode, buf);
 469                 path_release(&nd);
 470         }
 471         unlock_kernel();
 472         return error;
 473 }
 474
 475 asmlinkage int solaris_fstatvfs64(unsigned int fd, u32 buf)
 476 {
 477         struct file * file;
 478         int error;
 479
 480         error = -EBADF;
 481         file = fget(fd);
 482         if (file) {
 483                 lock_kernel();
 484                 error = report_statvfs64(file->f_path.mnt, file->f_path.dentry->d_inode, buf);
 485                 unlock_kernel();
 486                 fput(file);
 487         }
 488         return error;
 489 }
 490
 491 extern asmlinkage long sparc32_open(const char * filename, int flags, int mode);
 492
 493 asmlinkage int solaris_open(u32 fname, int flags, u32 mode)
 494 {
 495         const char *filename = (const char *)(long)fname;
 496         int fl = flags & 0xf;
 497
 498         /* Translate flags first. */
 499         if (flags & 0x2000) fl |= O_LARGEFILE;
 500         if (flags & 0x8050) fl |= O_SYNC;
 501         if (flags & 0x80) fl |= O_NONBLOCK;
 502         if (flags & 0x100) fl |= O_CREAT;
 503         if (flags & 0x200) fl |= O_TRUNC;
 504         if (flags & 0x400) fl |= O_EXCL;
 505         if (flags & 0x800) fl |= O_NOCTTY;
 506         flags = fl;
 507
 508         return sparc32_open(filename, flags, mode);
 509 }
 510
 511 #define SOL_F_SETLK     6
 512 #define SOL_F_SETLKW    7
 513 #define SOL_F_FREESP    11
 514 #define SOL_F_ISSTREAM  13
 515 #define SOL_F_GETLK     14
 516 #define SOL_F_PRIV      15
 517 #define SOL_F_NPRIV     16
 518 #define SOL_F_QUOTACTL  17
 519 #define SOL_F_BLOCKS    18
 520 #define SOL_F_BLKSIZE   19
 521 #define SOL_F_GETOWN    23
 522 #define SOL_F_SETOWN    24
 523
 524 struct sol_flock {
 525         short   l_type;
 526         short   l_whence;
 527         u32     l_start;
 528         u32     l_len;
 529         s32     l_sysid;
 530         s32     l_pid;
 531         s32     l_pad[4];
 532 };
 533
 534 asmlinkage int solaris_fcntl(unsigned fd, unsigned cmd, u32 arg)
 535 {
 536         int (*sys_fcntl)(unsigned,unsigned,unsigned long) =
 537                 (int (*)(unsigned,unsigned,unsigned long))SYS(fcntl);
 538         int ret, flags;
 539
 540         switch (cmd) {
 541         case F_DUPFD:
 542         case F_GETFD:
 543         case F_SETFD: return sys_fcntl(fd, cmd, (unsigned long)arg);
 544         case F_GETFL:
 545                 flags = sys_fcntl(fd, cmd, 0);
 546                 ret = flags & 0xf;
 547                 if (flags & O_SYNC) ret |= 0x8050;
 548                 if (flags & O_NONBLOCK) ret |= 0x80;
 549                 return ret;
 550         case F_SETFL:
 551                 flags = arg & 0xf;
 552                 if (arg & 0x8050) flags |= O_SYNC;
 553                 if (arg & 0x80) flags |= O_NONBLOCK;
 554                 return sys_fcntl(fd, cmd, (long)flags);
 555         case SOL_F_GETLK:
 556         case SOL_F_SETLK:
 557         case SOL_F_SETLKW:
 558                 {
 559                         struct flock f;
 560                         struct sol_flock __user *p = A(arg);
 561                         mm_segment_t old_fs = get_fs();
 562
 563                         switch (cmd) {
 564                         case SOL_F_GETLK: cmd = F_GETLK; break;
 565                         case SOL_F_SETLK: cmd = F_SETLK; break;
 566                         case SOL_F_SETLKW: cmd = F_SETLKW; break;
 567                         }
 568
 569                         if (get_user (f.l_type, &p->l_type) ||
 570                             __get_user (f.l_whence, &p->l_whence) ||
 571                             __get_user (f.l_start, &p->l_start) ||
 572                             __get_user (f.l_len, &p->l_len) ||
 573                             __get_user (f.l_pid, &p->l_sysid))
 574                                 return -EFAULT;
 575
 576                         set_fs(KERNEL_DS);
 577                         ret = sys_fcntl(fd, cmd, (unsigned long)&f);
 578                         set_fs(old_fs);
 579
 580                         if (__put_user (f.l_type, &p->l_type) ||
 581                             __put_user (f.l_whence, &p->l_whence) ||
 582                             __put_user (f.l_start, &p->l_start) ||
 583                             __put_user (f.l_len, &p->l_len) ||
 584                             __put_user (f.l_pid, &p->l_pid) ||
 585                             __put_user (0, &p->l_sysid))
 586                                 return -EFAULT;
 587
 588                         return ret;
 589                 }
 590         case SOL_F_FREESP:
 591                 {
 592                     int length;
 593                     int (*sys_newftruncate)(unsigned int, unsigned long)=
 594                             (int (*)(unsigned int, unsigned long))SYS(ftruncate);
 595
 596                     if (get_user(length, &((struct sol_flock __user *)A(arg))->l_start))
 597                             return -EFAULT;
 598
 599                     return sys_newftruncate(fd, length);
 600                 }
 601         };
 602         return -EINVAL;
 603 }
 604
 605 asmlinkage int solaris_ulimit(int cmd, int val)
 606 {
 607         switch (cmd) {
 608         case 1: /* UL_GETFSIZE - in 512B chunks */
 609                 return current->signal->rlim[RLIMIT_FSIZE].rlim_cur >> 9;
 610         case 2: /* UL_SETFSIZE */
 611                 if ((unsigned long)val > (LONG_MAX>>9)) return -ERANGE;
 612                 val <<= 9;
 613                 task_lock(current->group_leader);
 614                 if (val > current->signal->rlim[RLIMIT_FSIZE].rlim_max) {
 615                         if (!capable(CAP_SYS_RESOURCE)) {
 616                                 task_unlock(current->group_leader);
 617                                 return -EPERM;
 618                         }
 619                         current->signal->rlim[RLIMIT_FSIZE].rlim_max = val;
 620                 }
 621                 current->signal->rlim[RLIMIT_FSIZE].rlim_cur = val;
 622                 task_unlock(current->group_leader);
 623                 return 0;
 624         case 3: /* UL_GMEMLIM */
 625                 return current->signal->rlim[RLIMIT_DATA].rlim_cur;
 626         case 4: /* UL_GDESLIM */
 627                 return NR_OPEN;
 628         }
 629         return -EINVAL;
 630 }
 631
 632 /* At least at the time I'm writing this, Linux doesn't have ACLs, so we
 633    just fake this */
 634 asmlinkage int solaris_acl(u32 filename, int cmd, int nentries, u32 aclbufp)
 635 {
 636         return -ENOSYS;
 637 }
 638
 639 asmlinkage int solaris_facl(unsigned int fd, int cmd, int nentries, u32 aclbufp)
 640 {
 641         return -ENOSYS;
 642 }
 643
 644 asmlinkage int solaris_pread(unsigned int fd, char __user *buf, u32 count, u32 pos)
 645 {
 646         ssize_t (*sys_pread64)(unsigned int, char __user *, size_t, loff_t) =
 647                 (ssize_t (*)(unsigned int, char __user *, size_t, loff_t))SYS(pread64);
 648
 649         return sys_pread64(fd, buf, count, (loff_t)pos);
 650 }
 651
 652 asmlinkage int solaris_pwrite(unsigned int fd, char __user *buf, u32 count, u32 pos)
 653 {
 654         ssize_t (*sys_pwrite64)(unsigned int, char __user *, size_t, loff_t) =
 655                 (ssize_t (*)(unsigned int, char __user *, size_t, loff_t))SYS(pwrite64);
 656
 657         return sys_pwrite64(fd, buf, count, (loff_t)pos);
 658 }
 659
 660 /* POSIX.1 names */
 661 #define _PC_LINK_MAX    1
 662 #define _PC_MAX_CANON   2
 663 #define _PC_MAX_INPUT   3
 664 #define _PC_NAME_MAX    4
 665 #define _PC_PATH_MAX    5
 666 #define _PC_PIPE_BUF    6
 667 #define _PC_NO_TRUNC    7
 668 #define _PC_VDISABLE    8
 669 #define _PC_CHOWN_RESTRICTED    9
 670 /* POSIX.4 names */
 671 #define _PC_ASYNC_IO    10
 672 #define _PC_PRIO_IO     11
 673 #define _PC_SYNC_IO     12
 674 #define _PC_LAST        12
 675
 676 /* This is not a real and complete implementation yet, just to keep
 677  * the easy Solaris binaries happy.
 678  */
 679 asmlinkage int solaris_fpathconf(int fd, int name)
 680 {
 681         int ret;
 682
 683         switch(name) {
 684         case _PC_LINK_MAX:
 685                 ret = LINK_MAX;
 686                 break;
 687         case _PC_MAX_CANON:
 688                 ret = MAX_CANON;
 689                 break;
 690         case _PC_MAX_INPUT:
 691                 ret = MAX_INPUT;
 692                 break;
 693         case _PC_NAME_MAX:
 694                 ret = NAME_MAX;
 695                 break;
 696         case _PC_PATH_MAX:
 697                 ret = PATH_MAX;
 698                 break;
 699         case _PC_PIPE_BUF:
 700                 ret = PIPE_BUF;
 701                 break;
 702         case _PC_CHOWN_RESTRICTED:
 703                 ret = 1;
 704                 break;
 705         case _PC_NO_TRUNC:
 706         case _PC_VDISABLE:
 707                 ret = 0;
 708                 break;
 709         default:
 710                 ret = -EINVAL;
 711                 break;
 712         }
 713         return ret;
 714 }
 715
 716 asmlinkage int solaris_pathconf(u32 path, int name)
 717 {
 718         return solaris_fpathconf(0, name);
 719 }
 720
 721 /* solaris_llseek returns long long - quite difficult */
 722 asmlinkage long solaris_llseek(struct pt_regs *regs, u32 off_hi, u32 off_lo, int whence)
 723 {
 724         int (*sys_llseek)(unsigned int, unsigned long, unsigned long, loff_t __user *, unsigned int) =
 725                 (int (*)(unsigned int, unsigned long, unsigned long, loff_t __user *, unsigned int))SYS(_llseek);
 726         int ret;
 727         mm_segment_t old_fs = get_fs();
 728         loff_t retval;
 729
 730         set_fs(KERNEL_DS);
 731         ret = sys_llseek((unsigned int)regs->u_regs[UREG_I0], off_hi, off_lo, &retval, whence);
 732         set_fs(old_fs);
 733         if (ret < 0) return ret;
 734         regs->u_regs[UREG_I1] = (u32)retval;
 735         return (retval >> 32);
 736 }
 737
 738 /* Have to mask out all but lower 3 bits */
 739 asmlinkage int solaris_access(u32 filename, long mode)
 740 {
 741         int (*sys_access)(const char __user *, int) =
 742                 (int (*)(const char __user *, int))SYS(access);
 743
 744         return sys_access(A(filename), mode & 7);
 745 }