Root/
1 | #include <linux/syscalls.h> |
2 | #include <linux/slab.h> |
3 | #include <linux/fs.h> |
4 | #include <linux/file.h> |
5 | #include <linux/mount.h> |
6 | #include <linux/namei.h> |
7 | #include <linux/exportfs.h> |
8 | #include <linux/fs_struct.h> |
9 | #include <linux/fsnotify.h> |
10 | #include <linux/personality.h> |
11 | #include <asm/uaccess.h> |
12 | #include "internal.h" |
13 | |
14 | static long do_sys_name_to_handle(struct path *path, |
15 | struct file_handle __user *ufh, |
16 | int __user *mnt_id) |
17 | { |
18 | long retval; |
19 | struct file_handle f_handle; |
20 | int handle_dwords, handle_bytes; |
21 | struct file_handle *handle = NULL; |
22 | |
23 | /* |
24 | * We need t make sure wether the file system |
25 | * support decoding of the file handle |
26 | */ |
27 | if (!path->mnt->mnt_sb->s_export_op || |
28 | !path->mnt->mnt_sb->s_export_op->fh_to_dentry) |
29 | return -EOPNOTSUPP; |
30 | |
31 | if (copy_from_user(&f_handle, ufh, sizeof(struct file_handle))) |
32 | return -EFAULT; |
33 | |
34 | if (f_handle.handle_bytes > MAX_HANDLE_SZ) |
35 | return -EINVAL; |
36 | |
37 | handle = kmalloc(sizeof(struct file_handle) + f_handle.handle_bytes, |
38 | GFP_KERNEL); |
39 | if (!handle) |
40 | return -ENOMEM; |
41 | |
42 | /* convert handle size to multiple of sizeof(u32) */ |
43 | handle_dwords = f_handle.handle_bytes >> 2; |
44 | |
45 | /* we ask for a non connected handle */ |
46 | retval = exportfs_encode_fh(path->dentry, |
47 | (struct fid *)handle->f_handle, |
48 | &handle_dwords, 0); |
49 | handle->handle_type = retval; |
50 | /* convert handle size to bytes */ |
51 | handle_bytes = handle_dwords * sizeof(u32); |
52 | handle->handle_bytes = handle_bytes; |
53 | if ((handle->handle_bytes > f_handle.handle_bytes) || |
54 | (retval == 255) || (retval == -ENOSPC)) { |
55 | /* As per old exportfs_encode_fh documentation |
56 | * we could return ENOSPC to indicate overflow |
57 | * But file system returned 255 always. So handle |
58 | * both the values |
59 | */ |
60 | /* |
61 | * set the handle size to zero so we copy only |
62 | * non variable part of the file_handle |
63 | */ |
64 | handle_bytes = 0; |
65 | retval = -EOVERFLOW; |
66 | } else |
67 | retval = 0; |
68 | /* copy the mount id */ |
69 | if (copy_to_user(mnt_id, &path->mnt->mnt_id, sizeof(*mnt_id)) || |
70 | copy_to_user(ufh, handle, |
71 | sizeof(struct file_handle) + handle_bytes)) |
72 | retval = -EFAULT; |
73 | kfree(handle); |
74 | return retval; |
75 | } |
76 | |
77 | /** |
78 | * sys_name_to_handle_at: convert name to handle |
79 | * @dfd: directory relative to which name is interpreted if not absolute |
80 | * @name: name that should be converted to handle. |
81 | * @handle: resulting file handle |
82 | * @mnt_id: mount id of the file system containing the file |
83 | * @flag: flag value to indicate whether to follow symlink or not |
84 | * |
85 | * @handle->handle_size indicate the space available to store the |
86 | * variable part of the file handle in bytes. If there is not |
87 | * enough space, the field is updated to return the minimum |
88 | * value required. |
89 | */ |
90 | SYSCALL_DEFINE5(name_to_handle_at, int, dfd, const char __user *, name, |
91 | struct file_handle __user *, handle, int __user *, mnt_id, |
92 | int, flag) |
93 | { |
94 | struct path path; |
95 | int lookup_flags; |
96 | int err; |
97 | |
98 | if ((flag & ~(AT_SYMLINK_FOLLOW | AT_EMPTY_PATH)) != 0) |
99 | return -EINVAL; |
100 | |
101 | lookup_flags = (flag & AT_SYMLINK_FOLLOW) ? LOOKUP_FOLLOW : 0; |
102 | if (flag & AT_EMPTY_PATH) |
103 | lookup_flags |= LOOKUP_EMPTY; |
104 | err = user_path_at(dfd, name, lookup_flags, &path); |
105 | if (!err) { |
106 | err = do_sys_name_to_handle(&path, handle, mnt_id); |
107 | path_put(&path); |
108 | } |
109 | return err; |
110 | } |
111 | |
112 | static struct vfsmount *get_vfsmount_from_fd(int fd) |
113 | { |
114 | struct path path; |
115 | |
116 | if (fd == AT_FDCWD) { |
117 | struct fs_struct *fs = current->fs; |
118 | spin_lock(&fs->lock); |
119 | path = fs->pwd; |
120 | mntget(path.mnt); |
121 | spin_unlock(&fs->lock); |
122 | } else { |
123 | int fput_needed; |
124 | struct file *file = fget_light(fd, &fput_needed); |
125 | if (!file) |
126 | return ERR_PTR(-EBADF); |
127 | path = file->f_path; |
128 | mntget(path.mnt); |
129 | fput_light(file, fput_needed); |
130 | } |
131 | return path.mnt; |
132 | } |
133 | |
134 | static int vfs_dentry_acceptable(void *context, struct dentry *dentry) |
135 | { |
136 | return 1; |
137 | } |
138 | |
139 | static int do_handle_to_path(int mountdirfd, struct file_handle *handle, |
140 | struct path *path) |
141 | { |
142 | int retval = 0; |
143 | int handle_dwords; |
144 | |
145 | path->mnt = get_vfsmount_from_fd(mountdirfd); |
146 | if (IS_ERR(path->mnt)) { |
147 | retval = PTR_ERR(path->mnt); |
148 | goto out_err; |
149 | } |
150 | /* change the handle size to multiple of sizeof(u32) */ |
151 | handle_dwords = handle->handle_bytes >> 2; |
152 | path->dentry = exportfs_decode_fh(path->mnt, |
153 | (struct fid *)handle->f_handle, |
154 | handle_dwords, handle->handle_type, |
155 | vfs_dentry_acceptable, NULL); |
156 | if (IS_ERR(path->dentry)) { |
157 | retval = PTR_ERR(path->dentry); |
158 | goto out_mnt; |
159 | } |
160 | return 0; |
161 | out_mnt: |
162 | mntput(path->mnt); |
163 | out_err: |
164 | return retval; |
165 | } |
166 | |
167 | static int handle_to_path(int mountdirfd, struct file_handle __user *ufh, |
168 | struct path *path) |
169 | { |
170 | int retval = 0; |
171 | struct file_handle f_handle; |
172 | struct file_handle *handle = NULL; |
173 | |
174 | /* |
175 | * With handle we don't look at the execute bit on the |
176 | * the directory. Ideally we would like CAP_DAC_SEARCH. |
177 | * But we don't have that |
178 | */ |
179 | if (!capable(CAP_DAC_READ_SEARCH)) { |
180 | retval = -EPERM; |
181 | goto out_err; |
182 | } |
183 | if (copy_from_user(&f_handle, ufh, sizeof(struct file_handle))) { |
184 | retval = -EFAULT; |
185 | goto out_err; |
186 | } |
187 | if ((f_handle.handle_bytes > MAX_HANDLE_SZ) || |
188 | (f_handle.handle_bytes == 0)) { |
189 | retval = -EINVAL; |
190 | goto out_err; |
191 | } |
192 | handle = kmalloc(sizeof(struct file_handle) + f_handle.handle_bytes, |
193 | GFP_KERNEL); |
194 | if (!handle) { |
195 | retval = -ENOMEM; |
196 | goto out_err; |
197 | } |
198 | /* copy the full handle */ |
199 | if (copy_from_user(handle, ufh, |
200 | sizeof(struct file_handle) + |
201 | f_handle.handle_bytes)) { |
202 | retval = -EFAULT; |
203 | goto out_handle; |
204 | } |
205 | |
206 | retval = do_handle_to_path(mountdirfd, handle, path); |
207 | |
208 | out_handle: |
209 | kfree(handle); |
210 | out_err: |
211 | return retval; |
212 | } |
213 | |
214 | long do_handle_open(int mountdirfd, |
215 | struct file_handle __user *ufh, int open_flag) |
216 | { |
217 | long retval = 0; |
218 | struct path path; |
219 | struct file *file; |
220 | int fd; |
221 | |
222 | retval = handle_to_path(mountdirfd, ufh, &path); |
223 | if (retval) |
224 | return retval; |
225 | |
226 | fd = get_unused_fd_flags(open_flag); |
227 | if (fd < 0) { |
228 | path_put(&path); |
229 | return fd; |
230 | } |
231 | file = file_open_root(path.dentry, path.mnt, "", open_flag); |
232 | if (IS_ERR(file)) { |
233 | put_unused_fd(fd); |
234 | retval = PTR_ERR(file); |
235 | } else { |
236 | retval = fd; |
237 | fsnotify_open(file); |
238 | fd_install(fd, file); |
239 | } |
240 | path_put(&path); |
241 | return retval; |
242 | } |
243 | |
244 | /** |
245 | * sys_open_by_handle_at: Open the file handle |
246 | * @mountdirfd: directory file descriptor |
247 | * @handle: file handle to be opened |
248 | * @flag: open flags. |
249 | * |
250 | * @mountdirfd indicate the directory file descriptor |
251 | * of the mount point. file handle is decoded relative |
252 | * to the vfsmount pointed by the @mountdirfd. @flags |
253 | * value is same as the open(2) flags. |
254 | */ |
255 | SYSCALL_DEFINE3(open_by_handle_at, int, mountdirfd, |
256 | struct file_handle __user *, handle, |
257 | int, flags) |
258 | { |
259 | long ret; |
260 | |
261 | if (force_o_largefile()) |
262 | flags |= O_LARGEFILE; |
263 | |
264 | ret = do_handle_open(mountdirfd, handle, flags); |
265 | return ret; |
266 | } |
267 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9