long do_handle_open(int mountdirfd,
struct file_handle __user *ufh, int open_flag)
{
long retval = 0;
struct path path;
struct file *file;
int fd;
retval = handle_to_path(mountdirfd, ufh, &path);
if (retval)
return retval;
fd = get_unused_fd_flags(open_flag);
if (fd < 0) {
path_put(&path);
return fd;
}
file = file_open_root(path.dentry, path.mnt, "", open_flag);
if (IS_ERR(file)) {
put_unused_fd(fd);
retval = PTR_ERR(file);
} else {
retval = fd;
fsnotify_open(file);
fd_install(fd, file);
}
path_put(&path);
return retval;
}
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
struct open_flags op;
int fd = build_open_flags(flags, mode, &op);
struct filename *tmp;
if (fd)
return fd;
tmp = getname(filename);
if (IS_ERR(tmp))
return PTR_ERR(tmp);
fd = get_unused_fd_flags(flags);
if (fd >= 0) {
struct file *f = do_filp_open(dfd, tmp, &op);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fsnotify_open(f);
fd_install(fd, f);
}
}
putname(tmp);
return fd;
}
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
struct open_flags op;
int lookup = build_open_flags(flags, mode, &op);
char *tmp = getname(filename);
int fd = PTR_ERR(tmp);
if (!IS_ERR(tmp)) {
fd = get_unused_fd_flags(flags);
if (fd >= 0) {
struct file *f = do_filp_open(dfd, tmp, &op, lookup);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fsnotify_open(f);
fd_install(fd, f);
/* LGE_CHANGE_S
*
* do read/mmap profiling during booting
* in order to use the data as readahead args
*
* [email protected] 20120503
*/
sreadahead_prof( f, 0, 0);
/* LGE_CHANGE_E */
}
}
putname(tmp);
}
return fd;
}
/**
* vtpmx_ioc_new_dev - handler for the %VTPM_PROXY_IOC_NEW_DEV ioctl
* @file: /dev/vtpmx
* @ioctl: the ioctl number
* @arg: pointer to the struct vtpmx_proxy_new_dev
*
* Creates an anonymous file that is used by the process acting as a TPM to
* communicate with the client processes. The function will also add a new TPM
* device through which data is proxied to this TPM acting process. The caller
* will be provided with a file descriptor to communicate with the clients and
* major and minor numbers for the TPM device.
*/
static long vtpmx_ioc_new_dev(struct file *file, unsigned int ioctl,
unsigned long arg)
{
void __user *argp = (void __user *)arg;
struct vtpm_proxy_new_dev __user *vtpm_new_dev_p;
struct vtpm_proxy_new_dev vtpm_new_dev;
struct file *vtpm_file;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
vtpm_new_dev_p = argp;
if (copy_from_user(&vtpm_new_dev, vtpm_new_dev_p,
sizeof(vtpm_new_dev)))
return -EFAULT;
vtpm_file = vtpm_proxy_create_device(&vtpm_new_dev);
if (IS_ERR(vtpm_file))
return PTR_ERR(vtpm_file);
if (copy_to_user(vtpm_new_dev_p, &vtpm_new_dev,
sizeof(vtpm_new_dev))) {
put_unused_fd(vtpm_new_dev.fd);
fput(vtpm_file);
return -EFAULT;
}
fd_install(vtpm_new_dev.fd, vtpm_file);
return 0;
}
/*
* Open a file descriptor on the autofs mount point corresponding
* to the given path and device number (aka. new_encode_dev(sb->s_dev)).
*/
static int autofs_dev_ioctl_open_mountpoint(const char *name, dev_t devid)
{
int err, fd;
fd = get_unused_fd_flags(O_CLOEXEC);
if (likely(fd >= 0)) {
struct file *filp;
struct path path;
err = find_autofs_mount(name, &path, test_by_dev, &devid);
if (err)
goto out;
filp = dentry_open(&path, O_RDONLY, current_cred());
path_put(&path);
if (IS_ERR(filp)) {
err = PTR_ERR(filp);
goto out;
}
fd_install(fd, filp);
}
return fd;
out:
put_unused_fd(fd);
return err;
}
static
int lttng_abi_create_session(void)
{
struct lttng_session *session;
struct file *session_file;
int session_fd, ret;
session = lttng_session_create();
if (!session)
return -ENOMEM;
session_fd = lttng_get_unused_fd();
if (session_fd < 0) {
ret = session_fd;
goto fd_error;
}
session_file = anon_inode_getfile("[lttng_session]",
<tng_session_fops,
session, O_RDWR);
if (IS_ERR(session_file)) {
ret = PTR_ERR(session_file);
goto file_error;
}
session->file = session_file;
fd_install(session_fd, session_file);
return session_fd;
file_error:
put_unused_fd(session_fd);
fd_error:
lttng_session_destroy(session);
return ret;
}
long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
{
struct open_flags op;
int lookup = build_open_flags(flags, mode, &op);
char *tmp = getname(filename);
int fd = PTR_ERR(tmp);
if (!IS_ERR(tmp)) {
fd = get_unused_fd_flags(flags);
if (fd >= 0) {
struct file *f = do_filp_open(dfd, tmp, &op, lookup);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fsnotify_open(f);
fd_install(fd, f);
//ASUS_BSP +++ Jimmy,Josh "remove fuse"
if(strcmp(f->f_vfsmnt->mnt_mountpoint->d_iname,"sdcard")==0){
chown_common(&(f->f_path),-1,1015);
}
//ASUS_BSP --- Jimmy,Josh "remove fuse"
}
}
putname(tmp);
}
return fd;
}
asmlinkage long sys_open(const char __user * filename, int flags, int mode)
{
char * tmp;
int fd, error;
#if BITS_PER_LONG != 32
flags |= O_LARGEFILE;
#endif
tmp = getname(filename);
fd = PTR_ERR(tmp);
if (!IS_ERR(tmp)) {
fd = get_unused_fd();
if (fd >= 0) {
struct file *f = filp_open(tmp, flags, mode);
error = PTR_ERR(f);
if (IS_ERR(f))
goto out_error;
ltt_ev_file_system(LTT_EV_FILE_SYSTEM_OPEN,
fd,
f->f_dentry->d_name.len,
f->f_dentry->d_name.name);
fd_install(fd, f);
}
out:
putname(tmp);
}
return fd;
out_error:
put_unused_fd(fd);
fd = error;
goto out;
}
static
int lttng_abi_syscall_list(void)
{
struct file *syscall_list_file;
int file_fd, ret;
file_fd = lttng_get_unused_fd();
if (file_fd < 0) {
ret = file_fd;
goto fd_error;
}
syscall_list_file = anon_inode_getfile("[lttng_syscall_list]",
<tng_syscall_list_fops,
NULL, O_RDWR);
if (IS_ERR(syscall_list_file)) {
ret = PTR_ERR(syscall_list_file);
goto file_error;
}
ret = lttng_syscall_list_fops.open(NULL, syscall_list_file);
if (ret < 0)
goto open_error;
fd_install(file_fd, syscall_list_file);
return file_fd;
open_error:
fput(syscall_list_file);
file_error:
put_unused_fd(file_fd);
fd_error:
return ret;
}
ssize_t ib_uverbs_create_comp_channel(struct ib_uverbs_file *file,
const char __user *buf, int in_len,
int out_len)
{
struct ib_uverbs_create_comp_channel cmd;
struct ib_uverbs_create_comp_channel_resp resp;
struct file *filp;
if (out_len < sizeof resp)
return -ENOSPC;
if (copy_from_user(&cmd, buf, sizeof cmd))
return -EFAULT;
filp = ib_uverbs_alloc_event_file(file, 0, &resp.fd);
if (IS_ERR(filp))
return PTR_ERR(filp);
if (copy_to_user((void __user *) (unsigned long) cmd.response,
&resp, sizeof resp)) {
put_unused_fd(resp.fd);
fput(filp);
return -EFAULT;
}
fd_install(resp.fd, filp);
return in_len;
}
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
struct open_flags op;
int lookup = build_open_flags(flags, mode, &op);
char *tmp = getname(filename);
int fd = PTR_ERR(tmp);
if (!IS_ERR(tmp)) {
fd = get_unused_fd_flags(flags);
if (fd >= 0) {
struct file *f = do_filp_open(dfd, tmp, &op, lookup);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fsnotify_open(f);
fd_install(fd, f);
/*
*/
sreadahead_prof( f, 0, 0);
/* */
}
}
putname(tmp);
}
return fd;
}
/*
* vtpmx_fops_ioctl: ioctl on /dev/vtpmx
*
* Return value:
* Returns 0 on success, a negative error code otherwise.
*/
static long vtpmx_fops_ioctl(struct file *f, unsigned int ioctl,
unsigned long arg)
{
void __user *argp = (void __user *)arg;
struct vtpm_proxy_new_dev __user *vtpm_new_dev_p;
struct vtpm_proxy_new_dev vtpm_new_dev;
struct file *file;
switch (ioctl) {
case VTPM_PROXY_IOC_NEW_DEV:
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
vtpm_new_dev_p = argp;
if (copy_from_user(&vtpm_new_dev, vtpm_new_dev_p,
sizeof(vtpm_new_dev)))
return -EFAULT;
file = vtpm_proxy_create_device(&vtpm_new_dev);
if (IS_ERR(file))
return PTR_ERR(file);
if (copy_to_user(vtpm_new_dev_p, &vtpm_new_dev,
sizeof(vtpm_new_dev))) {
put_unused_fd(vtpm_new_dev.fd);
fput(file);
return -EFAULT;
}
fd_install(vtpm_new_dev.fd, file);
return 0;
default:
return -ENOIOCTLCMD;
}
}
asmlinkage long sys_open(const char * filename, int flags, int mode)
{
char * tmp;
int fd, error;
#if BITS_PER_LONG != 32
flags |= O_LARGEFILE;
#endif
tmp = getname(filename);
fd = PTR_ERR(tmp);
if (!IS_ERR(tmp)) {
fd = get_unused_fd();
if (fd >= 0) {
struct file *f = filp_open(tmp, flags, mode);
error = PTR_ERR(f);
if (IS_ERR(f))
goto out_error;
fd_install(fd, f);
}
out:
putname(tmp);
}
return fd;
out_error:
put_unused_fd(fd);
fd = error;
goto out;
}
__NOMIPS16
#endif
void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm)
{
struct cmsghdr *cm = (struct cmsghdr*)msg->msg_control;
int fdmax = 0;
int fdnum = scm->fp->count;
struct file **fp = scm->fp->fp;
int *cmfptr;
int err = 0, i;
if (msg->msg_controllen > sizeof(struct cmsghdr))
fdmax = ((msg->msg_controllen - sizeof(struct cmsghdr))
/ sizeof(int));
if (fdnum < fdmax)
fdmax = fdnum;
for (i=0, cmfptr=(int*)CMSG_DATA(cm); i<fdmax; i++, cmfptr++)
{
int new_fd;
err = get_unused_fd();
if (err < 0)
break;
new_fd = err;
err = put_user(new_fd, cmfptr);
if (err) {
put_unused_fd(new_fd);
break;
}
/* Bump the usage count and install the file. */
get_file(fp[i]);
fd_install(new_fd, fp[i]);
}
if (i > 0)
{
int cmlen = CMSG_LEN(i*sizeof(int));
if (!err)
err = put_user(SOL_SOCKET, &cm->cmsg_level);
if (!err)
err = put_user(SCM_RIGHTS, &cm->cmsg_type);
if (!err)
err = put_user(cmlen, &cm->cmsg_len);
if (!err) {
cmlen = CMSG_SPACE(i*sizeof(int));
msg->msg_control += cmlen;
msg->msg_controllen -= cmlen;
}
}
if (i < fdnum || (fdnum && fdmax <= 0))
msg->msg_flags |= MSG_CTRUNC;
/*
* All of the files that fit in the message have had their
* usage counts incremented, so we just free the list.
*/
__scm_destroy(scm);
}
static long
eventfd_link_ioctl_copy2(unsigned long arg)
{
void __user *argp = (void __user *) arg;
struct task_struct *task_target = NULL;
struct file *file;
struct files_struct *files;
struct eventfd_copy2 eventfd_copy2;
long ret = -EFAULT;
if (copy_from_user(&eventfd_copy2, argp, sizeof(struct eventfd_copy2)))
goto out;
/*
* Find the task struct for the target pid
*/
ret = -ESRCH;
task_target =
get_pid_task(find_vpid(eventfd_copy2.pid), PIDTYPE_PID);
if (task_target == NULL) {
pr_info("Unable to find pid %d\n", eventfd_copy2.pid);
goto out;
}
ret = -ESTALE;
files = get_files_struct(task_target);
if (files == NULL) {
pr_info("Failed to get target files struct\n");
goto out_task;
}
ret = -EBADF;
file = fget_from_files(files, eventfd_copy2.fd);
put_files_struct(files);
if (file == NULL) {
pr_info("Failed to get fd %d from target\n", eventfd_copy2.fd);
goto out_task;
}
/*
* Install the file struct from the target process into the
* newly allocated file desciptor of the source process.
*/
ret = get_unused_fd_flags(eventfd_copy2.flags);
if (ret < 0) {
fput(file);
goto out_task;
}
fd_install(ret, file);
out_task:
put_task_struct(task_target);
out:
return ret;
}
/**
* bus1_queue_entry_install() - install file descriptors
* @entry: queue entry carrying file descriptors
* @pool: parent pool of the queue entry
*
* This installs the file-descriptors that are carried by @entry into the
* current process. If no file-descriptors are carried, this is a no-op. If
* anything goes wrong, an error is returned without any file-descriptor being
* installed (i.e., this operation either installs all, or none).
*
* The caller must make sure the queue-entry @entry has a linked slice with
* enough trailing space to place the file-descriptors into. Furthermore, @pool
* must point to the pool where that slice resides in.
*
* Return: 0 on success, negative error code on failure.
*/
int bus1_queue_entry_install(struct bus1_queue_entry *entry,
struct bus1_pool *pool)
{
struct kvec vec;
size_t i, n = 0;
int r, *fds;
/* bail out if no files are passed or if the entry is invalid */
if (entry->n_files == 0)
return 0;
if (WARN_ON(!entry->slice ||
entry->slice->size < entry->n_files * sizeof(*fds)))
return -EFAULT;
/* allocate temporary array to hold all FDs */
fds = kmalloc_array(entry->n_files, sizeof(*fds), GFP_TEMPORARY);
if (!fds)
return -ENOMEM;
/* pre-allocate unused FDs */
for (i = 0; i < entry->n_files; ++i) {
if (WARN_ON(!entry->files[i])) {
fds[n++] = -1;
} else {
r = get_unused_fd_flags(O_CLOEXEC);
if (r < 0)
goto exit;
fds[n++] = r;
}
}
/* copy FD numbers into the slice */
vec.iov_base = fds;
vec.iov_len = n * sizeof(*fds);
r = bus1_pool_write_kvec(pool, entry->slice,
entry->slice->size - n * sizeof(*fds),
&vec, 1, vec.iov_len);
if (r < 0)
goto exit;
/* all worked out fine, now install the actual files */
for (i = 0; i < n; ++i)
if (fds[i] >= 0)
fd_install(fds[i], get_file(entry->files[i]));
r = 0;
exit:
if (r < 0)
for (i = 0; i < n; ++i)
put_unused_fd(fds[i]);
kfree(fds);
return r;
}
static inline int dupfd(unsigned int fd, unsigned int start)
{
struct files_struct * files = current->files;
struct file * file;
unsigned int newfd;
int error;
error = -EINVAL;
if (start >= NR_OPEN)
goto out;
error = -EBADF;
file = fget(fd);
if (!file)
goto out;
repeat:
error = -EMFILE;
if (start < files->next_fd)
start = files->next_fd;
/* At this point, start MUST be <= max_fdset */
#if 1
if (start > files->max_fdset)
printk (KERN_ERR "dupfd: fd %d, max %d\n",
start, files->max_fdset);
#endif
newfd = find_next_zero_bit(files->open_fds->fds_bits,
files->max_fdset,
start);
if (newfd >= current->rlim[RLIMIT_NOFILE].rlim_cur)
goto out_putf;
error = expand_files(files, newfd);
if (error < 0)
goto out_putf;
if (error) /* If we might have blocked, try again. */
goto repeat;
FD_SET(newfd, files->open_fds);
FD_CLR(newfd, files->close_on_exec);
if (start <= files->next_fd)
files->next_fd = newfd + 1;
fd_install(newfd, file);
error = newfd;
out:
#ifdef FDSET_DEBUG
if (error < 0)
printk (KERN_ERR __FUNCTION__ ": return %d\n", error);
#endif
return error;
out_putf:
fput(file);
goto out;
}
static long sync_file_ioctl_merge(struct sync_file *sync_file,
unsigned long arg)
{
int fd = get_unused_fd_flags(O_CLOEXEC);
int err;
struct sync_file *fence2, *fence3;
struct sync_merge_data data;
if (fd < 0)
return fd;
if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
err = -EFAULT;
goto err_put_fd;
}
if (data.flags || data.pad) {
err = -EINVAL;
goto err_put_fd;
}
fence2 = sync_file_fdget(data.fd2);
if (!fence2) {
err = -ENOENT;
goto err_put_fd;
}
data.name[sizeof(data.name) - 1] = '\0';
fence3 = sync_file_merge(data.name, sync_file, fence2);
if (!fence3) {
err = -ENOMEM;
goto err_put_fence2;
}
data.fence = fd;
if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
err = -EFAULT;
goto err_put_fence3;
}
fd_install(fd, fence3->file);
fput(fence2->file);
return 0;
err_put_fence3:
fput(fence3->file);
err_put_fence2:
fput(fence2->file);
err_put_fd:
put_unused_fd(fd);
return err;
}
void scm_detach_fds_compat(struct msghdr *kmsg, struct scm_cookie *scm)
{
struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;
int fdmax = (kmsg->msg_controllen - sizeof(struct compat_cmsghdr)) / sizeof(int);
int fdnum = scm->fp->count;
struct file **fp = scm->fp->fp;
int __user *cmfptr;
int err = 0, i;
if (fdnum < fdmax)
fdmax = fdnum;
for (i = 0, cmfptr = (int __user *) CMSG_COMPAT_DATA(cm); i < fdmax; i++, cmfptr++) {
int new_fd;
err = security_file_receive(fp[i]);
if (err)
break;
err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & kmsg->msg_flags
? O_CLOEXEC : 0);
if (err < 0)
break;
new_fd = err;
err = put_user(new_fd, cmfptr);
if (err) {
put_unused_fd(new_fd);
break;
}
/* Bump the usage count and install the file. */
get_file(fp[i]);
fd_install(new_fd, fp[i]);
}
if (i > 0) {
int cmlen = CMSG_COMPAT_LEN(i * sizeof(int));
err = put_user(SOL_SOCKET, &cm->cmsg_level);
if (!err)
err = put_user(SCM_RIGHTS, &cm->cmsg_type);
if (!err)
err = put_user(cmlen, &cm->cmsg_len);
if (!err) {
cmlen = CMSG_COMPAT_SPACE(i * sizeof(int));
kmsg->msg_control += cmlen;
kmsg->msg_controllen -= cmlen;
}
}
if (i < fdnum)
kmsg->msg_flags |= MSG_CTRUNC;
/*
* All of the files that fit in the message have had their
* usage counts incremented, so we just free the list.
*/
__scm_destroy(scm);
}
/* create file and install a new file descriptor */
int kdbus_memfd_new(int *fd)
{
struct kdbus_memfile *mf;
struct file *shmemfp;
struct file *fp;
int f;
int ret;
mf = kzalloc(sizeof(struct kdbus_memfile), GFP_KERNEL);
if (!mf)
return -ENOMEM;
mutex_init(&mf->lock);
/* allocate a new unlinked shmem file */
shmemfp = shmem_file_setup("kdbus-memfd", 0, 0);
if (IS_ERR(shmemfp)) {
ret = PTR_ERR(shmemfp);
goto exit;
}
mf->fp = shmemfp;
f = get_unused_fd_flags(O_CLOEXEC);
if (f < 0) {
ret = f;
goto exit_shmem;
}
/* The anonymous exported inode ops cannot reach the otherwise
* invisible shmem inode. We rely on the fact that nothing else
* can create a new file for the shmem inode, like by opening the
* fd in /proc/$PID/fd/ */
fp = anon_inode_getfile("[kdbus]", &kdbus_memfd_fops, mf, O_RDWR);
if (IS_ERR(fp)) {
ret = PTR_ERR(fp);
goto exit_fd;
}
fp->f_mode |= FMODE_LSEEK|FMODE_PREAD|FMODE_PWRITE;
fp->f_mapping = shmemfp->f_mapping;
fd_install(f, fp);
*fd = f;
return 0;
exit_fd:
put_unused_fd(f);
exit_shmem:
fput(shmemfp);
exit:
kfree(mf);
return ret;
}
asmlinkage long sys_open(const char * filename, int flags, int mode)
{
char * tmp;
int fd, error;
#if BITS_PER_LONG != 32
flags |= O_LARGEFILE;
#endif
tmp = getname(filename);
fd = PTR_ERR(tmp);
if (!IS_ERR(tmp)) {
fd = get_unused_fd();
if (fd >= 0) {
struct file *f = filp_open(tmp, flags, mode);
error = PTR_ERR(f);
/*
* ESTALE errors can be a pain. On some
* filesystems (e.g. NFS), ESTALE can often
* be resolved by retry, as the ESTALE resulted
* in a cache invalidation. We perform this
* retry here, once for every directory element
* in the path to avoid the case where the removal
* of the nth parent directory of the file we're
* trying to open results in n ESTALE errors.
*/
if (error == -ESTALE) {
int nretries = 1;
char *cp;
for (cp = tmp; *cp; cp++) {
if (*cp == '/')
nretries++;
}
do {
f = filp_open(tmp, flags, mode);
error = PTR_ERR(f);
} while (error == -ESTALE && --nretries > 0);
}
if (IS_ERR(f))
goto out_error;
fd_install(fd, f);
}
out:
putname(tmp);
}
return fd;
out_error:
put_unused_fd(fd);
fd = error;
goto out;
}
struct ib_ucontext *siw_alloc_ucontext(struct ib_device *ofa_dev,
struct ib_udata *udata)
{
struct siw_ucontext *ctx = NULL;
struct siw_dev *sdev = siw_dev_ofa2siw(ofa_dev);
int rv;
pr_debug(DBG_CM "(device=%s)\n", ofa_dev->name);
if (atomic_inc_return(&sdev->num_ctx) > SIW_MAX_CONTEXT) {
pr_debug(": Out of CONTEXT's\n");
rv = -ENOMEM;
goto err_out;
}
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (!ctx) {
rv = -ENOMEM;
goto err_out;
}
ctx->sdev = sdev;
if (udata) {
struct urdma_uresp_alloc_ctx uresp;
struct file *filp;
memset(&uresp, 0, sizeof uresp);
uresp.dev_id = sdev->attrs.vendor_part_id;
filp = siw_event_file_new(ctx, &uresp.event_fd);
if (IS_ERR(filp)) {
rv = PTR_ERR(filp);
goto err_out;
}
rv = ib_copy_to_udata(udata, &uresp, sizeof uresp);
if (rv) {
fput(filp);
kfree(ctx->event_file);
put_unused_fd(uresp.event_fd);
goto err_out;
}
fd_install(uresp.event_fd, filp);
}
return &ctx->ib_ucontext;
err_out:
if (ctx)
kfree(ctx);
atomic_dec(&sdev->num_ctx);
return ERR_PTR(rv);
}
static int
sgi_usema_attach (usattach_t * attach, struct irix_usema *usema)
{
int newfd;
newfd = get_unused_fd();
if (newfd < 0)
return newfd;
get_file(usema->filp);
fd_install(newfd, usema->filp);
/* Is that it? */
printk("UIOCATTACHSEMA: new usema fd is %d", newfd);
return newfd;
}
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
struct open_flags op;
int lookup = build_open_flags(flags, mode, &op);
char *tmp = getname(filename);
int fd = PTR_ERR(tmp);
#if IO_LOGGER_ENABLE
unsigned long long time1 = 0,timeoffset = 0;
bool add_trace_e = false;
#endif
if (!IS_ERR(tmp)) {
#if IO_LOGGER_ENABLE
if(unlikely(en_IOLogger())){
if(!memcmp(tmp,"/data",5)||!memcmp(tmp,"/system",7)){
add_trace_e = true;
time1 = sched_clock();
AddIOTrace(IO_LOGGER_MSG_VFS_OPEN_INTFS,do_sys_open,tmp);
}
}
#endif
fd = get_unused_fd_flags(flags);
if (fd >= 0) {
struct file *f = do_filp_open(dfd, tmp, &op, lookup);
if (IS_ERR(f)) {
put_unused_fd(fd);
fd = PTR_ERR(f);
} else {
fsnotify_open(f);
fd_install(fd, f);
}
}
#if IO_LOGGER_ENABLE
if(unlikely(en_IOLogger()) && add_trace_e){
timeoffset = sched_clock() - time1;
add_trace_e = false;
if(BEYOND_TRACE_LOG_TIME(timeoffset))
{
AddIOTrace(IO_LOGGER_MSG_VFS_OPEN_INTFS_END,do_sys_open,tmp,timeoffset);
if(BEYOND_DUMP_LOG_TIME(timeoffset))
DumpIOTrace(timeoffset);
}
}
#endif
putname(tmp);
}
return fd;
}
static int au_wbr_fd(struct path *path)
{
int err, fd;
aufs_bindex_t wbi, bindex, bend;
struct file *h_file;
struct super_block *sb;
struct dentry *root;
struct au_branch *wbr;
err = get_unused_fd();
if (unlikely(err < 0))
goto out;
fd = err;
wbi = 0;
sb = path->dentry->d_sb;
root = sb->s_root;
aufs_read_lock(root, AuLock_IR);
wbr = au_sbr(sb, wbi);
if (!(path->mnt->mnt_flags & MNT_READONLY)
&& !au_br_writable(wbr->br_perm)) {
bend = au_sbend(sb);
for (bindex = 1; bindex <= bend; bindex++) {
wbr = au_sbr(sb, bindex);
if (au_br_writable(wbr->br_perm)) {
wbi = bindex;
break;
}
}
wbr = au_sbr(sb, wbi);
}
AuDbg("wbi %d\n", wbi);
h_file = au_h_open(root, wbi, O_RDONLY | O_DIRECTORY | O_LARGEFILE,
NULL);
aufs_read_unlock(root, AuLock_IR);
err = PTR_ERR(h_file);
if (IS_ERR(h_file))
goto out_fd;
atomic_dec(&wbr->br_count); /* cf. au_h_open() */
fd_install(fd, h_file);
err = fd;
goto out; /* success */
out_fd:
put_unused_fd(fd);
out:
return err;
}
static int kni_sock_map_fd(struct socket *sock)
{
struct file *file;
int fd = get_unused_fd_flags(0);
if (fd < 0)
return fd;
file = sock_alloc_file(sock, 0, NULL);
if (IS_ERR(file)) {
put_unused_fd(fd);
return PTR_ERR(file);
}
fd_install(fd, file);
return fd;
}
static inline int turbotap_sock_map_fd(struct socket *sock, int flags)
{
struct file *newfile;
int fd = get_unused_fd_flags(flags);
if (unlikely(fd < 0))
return fd;
newfile = sock_alloc_file(sock, flags, NULL);
if (likely(!IS_ERR(newfile))) {
fd_install(fd, newfile);
return fd;
}
put_unused_fd(fd);
return PTR_ERR(newfile);
}
void create_dummy_file(struct w32process *process)
{
int fd;
if (process->dummyfd != -1)
return;
fd = get_unused_fd_flags(O_CLOEXEC);
if (fd >= 0) {
get_file(dummyfile);
fd_install(fd, dummyfile);
process->dummyfd = fd;
}
ktrace("process %p, dummyfd %d\n", process, process->dummyfd);
}
int cr_filp_chmod(struct file *filp, mode_t mode) {
int retval, fd;
retval = get_unused_fd();
if (retval < 0) {
goto out;
}
fd = retval;
get_file(filp);
fd_install(fd, filp);
retval = sys_fchmod(fd, mode);
(void)sys_close(fd);
out:
return retval;
}
void sys_open_term(char * name)
{
struct _fabdef * fab = kmalloc(sizeof(struct _fabdef), GFP_KERNEL);
struct _rabdef * rab = kmalloc(sizeof(struct _rabdef), GFP_KERNEL);
*fab = cc$rms_fab;
*rab = cc$rms_rab;
fab->fab$l_fna = name;
fab->fab$b_fns = strlen(fab->fab$l_fna);
exe$open(fab);
rab->rab$l_fab = fab;
exe$connect(rab);
int fd = get_unused_fd();
struct vms_fd * vms_fd = kmalloc(sizeof(struct vms_fd), GFP_KERNEL);
vms_fd->vfd$l_is_cmu = 0;
vms_fd->vfd$l_fd_p = rab;
vms_fd->vfd$l_refcnt = 1;
fd_install(fd, vms_fd);
}
