#include <linux/namei.h>
#include <linux/uio.h>
#include <linux/vfs.h>
+#include <linux/rcupdate.h>
+#include <linux/vs_cvirt.h>
#include <asm/fpu.h>
#include <asm/io.h>
osf_utsname(char __user *name)
{
int error;
+ struct new_utsname *ptr;
down_read(&uts_sem);
+ ptr = vx_new_utsname();
error = -EFAULT;
- if (copy_to_user(name + 0, system_utsname.sysname, 32))
+ if (copy_to_user(name + 0, ptr->sysname, 32))
goto out;
- if (copy_to_user(name + 32, system_utsname.nodename, 32))
+ if (copy_to_user(name + 32, ptr->nodename, 32))
goto out;
- if (copy_to_user(name + 64, system_utsname.release, 32))
+ if (copy_to_user(name + 64, ptr->release, 32))
goto out;
- if (copy_to_user(name + 96, system_utsname.version, 32))
+ if (copy_to_user(name + 96, ptr->version, 32))
goto out;
- if (copy_to_user(name + 128, system_utsname.machine, 32))
+ if (copy_to_user(name + 128, ptr->machine, 32))
goto out;
error = 0;
osf_getdomainname(char __user *name, int namelen)
{
unsigned len;
- int i, error;
+ int i;
+ char *domainname;
- error = verify_area(VERIFY_WRITE, name, namelen);
- if (error)
- goto out;
+ if (!access_ok(VERIFY_WRITE, name, namelen))
+ return -EFAULT;
len = namelen;
if (namelen > 32)
len = 32;
down_read(&uts_sem);
+ domainname = vx_new_uts(domainname);
for (i = 0; i < len; ++i) {
- __put_user(system_utsname.domainname[i], name + i);
- if (system_utsname.domainname[i] == '\0')
+ __put_user(domainname[i], name + i);
+ if (domainname[i] == '\0')
break;
}
up_read(&uts_sem);
- out:
- return error;
-}
-asmlinkage long
-osf_shmat(int shmid, void __user *shmaddr, int shmflg)
-{
- unsigned long raddr;
- long err;
-
- err = do_shmat(shmid, shmaddr, shmflg, &raddr);
-
- /*
- * This works because all user-level addresses are
- * non-negative longs!
- */
- return err ? err : (long)raddr;
+ return 0;
}
-
/*
* The following stuff should move into a header file should it ever
* be labeled "officially supported." Right now, there is just enough
asmlinkage long
osf_sysinfo(int command, char __user *buf, long count)
{
- static char * sysinfo_table[] = {
- system_utsname.sysname,
- system_utsname.nodename,
- system_utsname.release,
- system_utsname.version,
- system_utsname.machine,
- "alpha", /* instruction set architecture */
- "dummy", /* hardware serial number */
- "dummy", /* hardware manufacturer */
- "dummy", /* secure RPC domain */
- };
unsigned long offset;
char *res;
long len, err = -EINVAL;
}
down_read(&uts_sem);
- res = sysinfo_table[offset];
+ switch (offset)
+ {
+ case 0: res = vx_new_uts(sysname); break;
+ case 1: res = vx_new_uts(nodename); break;
+ case 2: res = vx_new_uts(release); break;
+ case 3: res = vx_new_uts(version); break;
+ case 4: res = vx_new_uts(machine); break;
+ case 5: res = "alpha"; break;
+ default:
+ res = "dummy";
+ break;
+ }
len = strlen(res)+1;
if (len > count)
len = count;
return -EFAULT;
}
- return do_utimes(filename, tvs ? ktvs : NULL);
+ return do_utimes(AT_FDCWD, filename, tvs ? ktvs : NULL);
}
#define MAX_SELECT_SECONDS \
char *bits;
size_t size;
long timeout;
- int ret;
+ int ret = -EINVAL;
+ struct fdtable *fdt;
+ int max_fdset;
timeout = MAX_SCHEDULE_TIMEOUT;
if (tvp) {
time_t sec, usec;
- if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
- || (ret = __get_user(sec, &tvp->tv_sec))
- || (ret = __get_user(usec, &tvp->tv_usec)))
+ if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp))
+ || __get_user(sec, &tvp->tv_sec)
+ || __get_user(usec, &tvp->tv_usec)) {
+ ret = -EFAULT;
goto out_nofds;
+ }
- ret = -EINVAL;
if (sec < 0 || usec < 0)
goto out_nofds;
}
}
- ret = -EINVAL;
- if (n < 0 || n > current->files->max_fdset)
+ rcu_read_lock();
+ fdt = files_fdtable(current->files);
+ max_fdset = fdt->max_fdset;
+ rcu_read_unlock();
+ if (n < 0 || n > max_fdset)
goto out_nofds;
/*
if (get_tv32(&tmp, sleep))
goto fault;
- ticks = tmp.tv_usec;
- ticks = (ticks + (1000000 / HZ) - 1) / (1000000 / HZ);
- ticks += tmp.tv_sec * HZ;
+ ticks = timeval_to_jiffies(&tmp);
- current->state = TASK_INTERRUPTIBLE;
- ticks = schedule_timeout(ticks);
+ ticks = schedule_timeout_interruptible(ticks);
if (remain) {
- tmp.tv_sec = ticks / HZ;
- tmp.tv_usec = ticks % HZ;
+ jiffies_to_timeval(ticks, &tmp);
if (put_tv32(remain, &tmp))
goto fault;
}