]>
Commit | Line | Data |
---|---|---|
929be906 | 1 | // SPDX-License-Identifier: LGPL-2.1 |
1da177e4 | 2 | /* |
1da177e4 LT |
3 | * |
4 | * vfs operations that deal with io control | |
5 | * | |
64a5cfa6 | 6 | * Copyright (C) International Business Machines Corp., 2005,2013 |
1da177e4 LT |
7 | * Author(s): Steve French (sfrench@us.ibm.com) |
8 | * | |
1da177e4 | 9 | */ |
f654bac2 | 10 | |
1da177e4 | 11 | #include <linux/fs.h> |
41c1358e SF |
12 | #include <linux/file.h> |
13 | #include <linux/mount.h> | |
14 | #include <linux/mm.h> | |
15 | #include <linux/pagemap.h> | |
1da177e4 LT |
16 | #include "cifspdu.h" |
17 | #include "cifsglob.h" | |
18 | #include "cifsproto.h" | |
19 | #include "cifs_debug.h" | |
c67593a0 | 20 | #include "cifsfs.h" |
0de1f4c6 | 21 | #include "cifs_ioctl.h" |
8d8b26e5 | 22 | #include "smb2proto.h" |
1bb56810 | 23 | #include "smb2glob.h" |
02b16665 | 24 | #include <linux/btrfs.h> |
1da177e4 | 25 | |
f5b05d62 RS |
26 | static long cifs_ioctl_query_info(unsigned int xid, struct file *filep, |
27 | unsigned long p) | |
28 | { | |
8d8b26e5 RS |
29 | struct inode *inode = file_inode(filep); |
30 | struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); | |
31 | struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); | |
32 | struct dentry *dentry = filep->f_path.dentry; | |
8e33cf20 | 33 | const unsigned char *path; |
f6a9bc33 | 34 | void *page = alloc_dentry_path(); |
8d8b26e5 RS |
35 | __le16 *utf16_path = NULL, root_path; |
36 | int rc = 0; | |
f5b05d62 | 37 | |
f6a9bc33 AV |
38 | path = build_path_from_dentry(dentry, page); |
39 | if (IS_ERR(path)) { | |
40 | free_dentry_path(page); | |
41 | return PTR_ERR(path); | |
42 | } | |
8d8b26e5 RS |
43 | |
44 | cifs_dbg(FYI, "%s %s\n", __func__, path); | |
45 | ||
46 | if (!path[0]) { | |
47 | root_path = 0; | |
48 | utf16_path = &root_path; | |
49 | } else { | |
50 | utf16_path = cifs_convert_path_to_utf16(path + 1, cifs_sb); | |
51 | if (!utf16_path) { | |
52 | rc = -ENOMEM; | |
53 | goto ici_exit; | |
54 | } | |
55 | } | |
f5b05d62 RS |
56 | |
57 | if (tcon->ses->server->ops->ioctl_query_info) | |
8d8b26e5 | 58 | rc = tcon->ses->server->ops->ioctl_query_info( |
0f060936 | 59 | xid, tcon, cifs_sb, utf16_path, |
8d8b26e5 | 60 | filep->private_data ? 0 : 1, p); |
f5b05d62 | 61 | else |
8d8b26e5 RS |
62 | rc = -EOPNOTSUPP; |
63 | ||
64 | ici_exit: | |
65 | if (utf16_path != &root_path) | |
66 | kfree(utf16_path); | |
f6a9bc33 | 67 | free_dentry_path(page); |
8d8b26e5 | 68 | return rc; |
f5b05d62 RS |
69 | } |
70 | ||
312bbc59 | 71 | static long cifs_ioctl_copychunk(unsigned int xid, struct file *dst_file, |
04b38d60 CH |
72 | unsigned long srcfd) |
73 | { | |
74 | int rc; | |
75 | struct fd src_file; | |
76 | struct inode *src_inode; | |
77 | ||
312bbc59 | 78 | cifs_dbg(FYI, "ioctl copychunk range\n"); |
04b38d60 CH |
79 | /* the destination must be opened for writing */ |
80 | if (!(dst_file->f_mode & FMODE_WRITE)) { | |
81 | cifs_dbg(FYI, "file target not open for write\n"); | |
82 | return -EINVAL; | |
83 | } | |
84 | ||
85 | /* check if target volume is readonly and take reference */ | |
86 | rc = mnt_want_write_file(dst_file); | |
87 | if (rc) { | |
88 | cifs_dbg(FYI, "mnt_want_write failed with rc %d\n", rc); | |
89 | return rc; | |
90 | } | |
91 | ||
92 | src_file = fdget(srcfd); | |
93 | if (!src_file.file) { | |
94 | rc = -EBADF; | |
95 | goto out_drop_write; | |
96 | } | |
97 | ||
98 | if (src_file.file->f_op->unlocked_ioctl != cifs_ioctl) { | |
99 | rc = -EBADF; | |
100 | cifs_dbg(VFS, "src file seems to be from a different filesystem type\n"); | |
101 | goto out_fput; | |
102 | } | |
103 | ||
104 | src_inode = file_inode(src_file.file); | |
105 | rc = -EINVAL; | |
106 | if (S_ISDIR(src_inode->i_mode)) | |
107 | goto out_fput; | |
108 | ||
620d8745 SP |
109 | rc = cifs_file_copychunk_range(xid, src_file.file, 0, dst_file, 0, |
110 | src_inode->i_size, 0); | |
7d0c234f SP |
111 | if (rc > 0) |
112 | rc = 0; | |
41c1358e SF |
113 | out_fput: |
114 | fdput(src_file); | |
115 | out_drop_write: | |
116 | mnt_drop_write_file(dst_file); | |
117 | return rc; | |
118 | } | |
119 | ||
0de1f4c6 SF |
120 | static long smb_mnt_get_fsinfo(unsigned int xid, struct cifs_tcon *tcon, |
121 | void __user *arg) | |
122 | { | |
123 | int rc = 0; | |
124 | struct smb_mnt_fs_info *fsinf; | |
125 | ||
126 | fsinf = kzalloc(sizeof(struct smb_mnt_fs_info), GFP_KERNEL); | |
127 | if (fsinf == NULL) | |
128 | return -ENOMEM; | |
129 | ||
130 | fsinf->version = 1; | |
131 | fsinf->protocol_id = tcon->ses->server->vals->protocol_id; | |
132 | fsinf->device_characteristics = | |
133 | le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics); | |
134 | fsinf->device_type = le32_to_cpu(tcon->fsDevInfo.DeviceType); | |
135 | fsinf->fs_attributes = le32_to_cpu(tcon->fsAttrInfo.Attributes); | |
136 | fsinf->max_path_component = | |
137 | le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength); | |
0de1f4c6 SF |
138 | fsinf->vol_serial_number = tcon->vol_serial_number; |
139 | fsinf->vol_create_time = le64_to_cpu(tcon->vol_create_time); | |
140 | fsinf->share_flags = tcon->share_flags; | |
141 | fsinf->share_caps = le32_to_cpu(tcon->capabilities); | |
142 | fsinf->sector_flags = tcon->ss_flags; | |
143 | fsinf->optimal_sector_size = tcon->perf_sector_size; | |
144 | fsinf->max_bytes_chunk = tcon->max_bytes_chunk; | |
145 | fsinf->maximal_access = tcon->maximal_access; | |
0de1f4c6 SF |
146 | fsinf->cifs_posix_caps = le64_to_cpu(tcon->fsUnixInfo.Capability); |
147 | ||
148 | if (copy_to_user(arg, fsinf, sizeof(struct smb_mnt_fs_info))) | |
149 | rc = -EFAULT; | |
150 | ||
151 | kfree(fsinf); | |
152 | return rc; | |
153 | } | |
154 | ||
087f757b SF |
155 | static int cifs_shutdown(struct super_block *sb, unsigned long arg) |
156 | { | |
157 | struct cifs_sb_info *sbi = CIFS_SB(sb); | |
158 | __u32 flags; | |
159 | ||
160 | if (!capable(CAP_SYS_ADMIN)) | |
161 | return -EPERM; | |
162 | ||
163 | if (get_user(flags, (__u32 __user *)arg)) | |
164 | return -EFAULT; | |
165 | ||
166 | if (flags > CIFS_GOING_FLAGS_NOLOGFLUSH) | |
167 | return -EINVAL; | |
168 | ||
169 | if (cifs_forced_shutdown(sbi)) | |
170 | return 0; | |
171 | ||
172 | cifs_dbg(VFS, "shut down requested (%d)", flags); | |
173 | /* trace_cifs_shutdown(sb, flags);*/ | |
174 | ||
175 | /* | |
176 | * see: | |
177 | * https://man7.org/linux/man-pages/man2/ioctl_xfs_goingdown.2.html | |
178 | * for more information and description of original intent of the flags | |
179 | */ | |
180 | switch (flags) { | |
181 | /* | |
182 | * We could add support later for default flag which requires: | |
183 | * "Flush all dirty data and metadata to disk" | |
184 | * would need to call syncfs or equivalent to flush page cache for | |
185 | * the mount and then issue fsync to server (if nostrictsync not set) | |
186 | */ | |
187 | case CIFS_GOING_FLAGS_DEFAULT: | |
188 | cifs_dbg(FYI, "shutdown with default flag not supported\n"); | |
189 | return -EINVAL; | |
190 | /* | |
191 | * FLAGS_LOGFLUSH is easy since it asks to write out metadata (not | |
192 | * data) but metadata writes are not cached on the client, so can treat | |
193 | * it similarly to NOLOGFLUSH | |
194 | */ | |
195 | case CIFS_GOING_FLAGS_LOGFLUSH: | |
196 | case CIFS_GOING_FLAGS_NOLOGFLUSH: | |
197 | sbi->mnt_cifs_flags |= CIFS_MOUNT_SHUTDOWN; | |
198 | return 0; | |
199 | default: | |
200 | return -EINVAL; | |
201 | } | |
202 | return 0; | |
203 | } | |
204 | ||
1bb56810 | 205 | static int cifs_dump_full_key(struct cifs_tcon *tcon, struct smb3_full_key_debug_info __user *in) |
7ba3d1cd | 206 | { |
1bb56810 | 207 | struct smb3_full_key_debug_info out; |
7ba3d1cd | 208 | struct cifs_ses *ses; |
1bb56810 | 209 | int rc = 0; |
7ba3d1cd | 210 | bool found = false; |
1bb56810 | 211 | u8 __user *end; |
7ba3d1cd | 212 | |
1bb56810 AA |
213 | if (!smb3_encryption_required(tcon)) { |
214 | rc = -EOPNOTSUPP; | |
215 | goto out; | |
216 | } | |
217 | ||
218 | /* copy user input into our output buffer */ | |
219 | if (copy_from_user(&out, in, sizeof(out))) { | |
220 | rc = -EINVAL; | |
221 | goto out; | |
222 | } | |
223 | ||
224 | if (!out.session_id) { | |
225 | /* if ses id is 0, use current user session */ | |
226 | ses = tcon->ses; | |
227 | } else { | |
228 | /* otherwise if a session id is given, look for it in all our sessions */ | |
229 | struct cifs_ses *ses_it = NULL; | |
230 | struct TCP_Server_Info *server_it = NULL; | |
7ba3d1cd | 231 | |
7ba3d1cd | 232 | spin_lock(&cifs_tcp_ses_lock); |
1bb56810 AA |
233 | list_for_each_entry(server_it, &cifs_tcp_ses_list, tcp_ses_list) { |
234 | list_for_each_entry(ses_it, &server_it->smb_ses_list, smb_ses_list) { | |
235 | if (ses_it->Suid == out.session_id) { | |
236 | ses = ses_it; | |
237 | /* | |
238 | * since we are using the session outside the crit | |
239 | * section, we need to make sure it won't be released | |
240 | * so increment its refcount | |
241 | */ | |
242 | ses->ses_count++; | |
243 | found = true; | |
244 | goto search_end; | |
245 | } | |
7ba3d1cd SF |
246 | } |
247 | } | |
1bb56810 | 248 | search_end: |
7ba3d1cd | 249 | spin_unlock(&cifs_tcp_ses_lock); |
1bb56810 AA |
250 | if (!found) { |
251 | rc = -ENOENT; | |
252 | goto out; | |
253 | } | |
254 | } | |
7ba3d1cd | 255 | |
1bb56810 AA |
256 | switch (ses->server->cipher_type) { |
257 | case SMB2_ENCRYPTION_AES128_CCM: | |
258 | case SMB2_ENCRYPTION_AES128_GCM: | |
259 | out.session_key_length = CIFS_SESS_KEY_SIZE; | |
260 | out.server_in_key_length = out.server_out_key_length = SMB3_GCM128_CRYPTKEY_SIZE; | |
261 | break; | |
262 | case SMB2_ENCRYPTION_AES256_CCM: | |
263 | case SMB2_ENCRYPTION_AES256_GCM: | |
264 | out.session_key_length = CIFS_SESS_KEY_SIZE; | |
265 | out.server_in_key_length = out.server_out_key_length = SMB3_GCM256_CRYPTKEY_SIZE; | |
266 | break; | |
267 | default: | |
268 | rc = -EOPNOTSUPP; | |
269 | goto out; | |
270 | } | |
271 | ||
272 | /* check if user buffer is big enough to store all the keys */ | |
273 | if (out.in_size < sizeof(out) + out.session_key_length + out.server_in_key_length | |
274 | + out.server_out_key_length) { | |
275 | rc = -ENOBUFS; | |
276 | goto out; | |
277 | } | |
278 | ||
279 | out.session_id = ses->Suid; | |
280 | out.cipher_type = le16_to_cpu(ses->server->cipher_type); | |
281 | ||
282 | /* overwrite user input with our output */ | |
283 | if (copy_to_user(in, &out, sizeof(out))) { | |
284 | rc = -EINVAL; | |
285 | goto out; | |
286 | } | |
287 | ||
288 | /* append all the keys at the end of the user buffer */ | |
289 | end = in->data; | |
290 | if (copy_to_user(end, ses->auth_key.response, out.session_key_length)) { | |
291 | rc = -EINVAL; | |
292 | goto out; | |
293 | } | |
294 | end += out.session_key_length; | |
295 | ||
296 | if (copy_to_user(end, ses->smb3encryptionkey, out.server_in_key_length)) { | |
297 | rc = -EINVAL; | |
298 | goto out; | |
299 | } | |
300 | end += out.server_in_key_length; | |
301 | ||
302 | if (copy_to_user(end, ses->smb3decryptionkey, out.server_out_key_length)) { | |
303 | rc = -EINVAL; | |
304 | goto out; | |
305 | } | |
306 | ||
307 | out: | |
308 | if (found) | |
309 | cifs_put_smb_ses(ses); | |
310 | return rc; | |
7ba3d1cd SF |
311 | } |
312 | ||
f9ddcca4 | 313 | long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg) |
1da177e4 | 314 | { |
496ad9aa | 315 | struct inode *inode = file_inode(filep); |
7e7db86c | 316 | struct smb3_key_debug_info pkey_inf; |
1da177e4 | 317 | int rc = -ENOTTY; /* strange error - but the precedent */ |
6d5786a3 | 318 | unsigned int xid; |
ba00ba64 | 319 | struct cifsFileInfo *pSMBFile = filep->private_data; |
96daf2b0 | 320 | struct cifs_tcon *tcon; |
a77592a7 | 321 | struct tcon_link *tlink; |
d26c2ddd | 322 | struct cifs_sb_info *cifs_sb; |
f654bac2 | 323 | __u64 ExtAttrBits = 0; |
61876395 | 324 | __u64 caps; |
f654bac2 | 325 | |
6d5786a3 | 326 | xid = get_xid(); |
f654bac2 | 327 | |
b0a752b5 | 328 | cifs_dbg(FYI, "cifs ioctl 0x%x\n", command); |
5fdae1f6 | 329 | switch (command) { |
36695673 | 330 | case FS_IOC_GETFLAGS: |
61876395 JL |
331 | if (pSMBFile == NULL) |
332 | break; | |
333 | tcon = tlink_tcon(pSMBFile->tlink); | |
334 | caps = le64_to_cpu(tcon->fsUnixInfo.Capability); | |
64a5cfa6 | 335 | #ifdef CONFIG_CIFS_POSIX |
fb157ed2 | 336 | #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY |
5fdae1f6 | 337 | if (CIFS_UNIX_EXTATTR_CAP & caps) { |
f10d9ba4 | 338 | __u64 ExtAttrMask = 0; |
4b4de76e PS |
339 | rc = CIFSGetExtAttr(xid, tcon, |
340 | pSMBFile->fid.netfid, | |
341 | &ExtAttrBits, &ExtAttrMask); | |
5fdae1f6 | 342 | if (rc == 0) |
f654bac2 | 343 | rc = put_user(ExtAttrBits & |
36695673 | 344 | FS_FL_USER_VISIBLE, |
f654bac2 | 345 | (int __user *)arg); |
64a5cfa6 SF |
346 | if (rc != EOPNOTSUPP) |
347 | break; | |
348 | } | |
fb157ed2 | 349 | #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ |
64a5cfa6 SF |
350 | #endif /* CONFIG_CIFS_POSIX */ |
351 | rc = 0; | |
352 | if (CIFS_I(inode)->cifsAttrs & ATTR_COMPRESSED) { | |
353 | /* add in the compressed bit */ | |
354 | ExtAttrBits = FS_COMPR_FL; | |
355 | rc = put_user(ExtAttrBits & FS_FL_USER_VISIBLE, | |
356 | (int __user *)arg); | |
f654bac2 SF |
357 | } |
358 | break; | |
36695673 | 359 | case FS_IOC_SETFLAGS: |
61876395 JL |
360 | if (pSMBFile == NULL) |
361 | break; | |
362 | tcon = tlink_tcon(pSMBFile->tlink); | |
4c51de1e | 363 | /* caps = le64_to_cpu(tcon->fsUnixInfo.Capability); */ |
64a5cfa6 SF |
364 | |
365 | if (get_user(ExtAttrBits, (int __user *)arg)) { | |
366 | rc = -EFAULT; | |
367 | break; | |
368 | } | |
369 | ||
370 | /* | |
371 | * if (CIFS_UNIX_EXTATTR_CAP & caps) | |
372 | * rc = CIFSSetExtAttr(xid, tcon, | |
373 | * pSMBFile->fid.netfid, | |
374 | * extAttrBits, | |
375 | * &ExtAttrMask); | |
376 | * if (rc != EOPNOTSUPP) | |
377 | * break; | |
378 | */ | |
379 | ||
380 | /* Currently only flag we can set is compressed flag */ | |
381 | if ((ExtAttrBits & FS_COMPR_FL) == 0) | |
382 | break; | |
383 | ||
384 | /* Try to set compress flag */ | |
385 | if (tcon->ses->server->ops->set_compression) { | |
386 | rc = tcon->ses->server->ops->set_compression( | |
387 | xid, tcon, pSMBFile); | |
388 | cifs_dbg(FYI, "set compress flag rc %d\n", rc); | |
f654bac2 | 389 | } |
f654bac2 | 390 | break; |
f19e84df | 391 | case CIFS_IOC_COPYCHUNK_FILE: |
312bbc59 | 392 | rc = cifs_ioctl_copychunk(xid, filep, arg); |
41c1358e | 393 | break; |
f5b05d62 RS |
394 | case CIFS_QUERY_INFO: |
395 | rc = cifs_ioctl_query_info(xid, filep, arg); | |
396 | break; | |
b3152e2c SF |
397 | case CIFS_IOC_SET_INTEGRITY: |
398 | if (pSMBFile == NULL) | |
399 | break; | |
400 | tcon = tlink_tcon(pSMBFile->tlink); | |
401 | if (tcon->ses->server->ops->set_integrity) | |
402 | rc = tcon->ses->server->ops->set_integrity(xid, | |
403 | tcon, pSMBFile); | |
404 | else | |
405 | rc = -EOPNOTSUPP; | |
406 | break; | |
0de1f4c6 | 407 | case CIFS_IOC_GET_MNT_INFO: |
d8a6e505 DD |
408 | if (pSMBFile == NULL) |
409 | break; | |
0de1f4c6 SF |
410 | tcon = tlink_tcon(pSMBFile->tlink); |
411 | rc = smb_mnt_get_fsinfo(xid, tcon, (void __user *)arg); | |
412 | break; | |
834170c8 | 413 | case CIFS_ENUMERATE_SNAPSHOTS: |
6026685d DD |
414 | if (pSMBFile == NULL) |
415 | break; | |
834170c8 SF |
416 | if (arg == 0) { |
417 | rc = -EINVAL; | |
418 | goto cifs_ioc_exit; | |
419 | } | |
420 | tcon = tlink_tcon(pSMBFile->tlink); | |
421 | if (tcon->ses->server->ops->enum_snapshots) | |
422 | rc = tcon->ses->server->ops->enum_snapshots(xid, tcon, | |
423 | pSMBFile, (void __user *)arg); | |
424 | else | |
425 | rc = -EOPNOTSUPP; | |
426 | break; | |
7e7db86c | 427 | case CIFS_DUMP_KEY: |
1bb56810 AA |
428 | /* |
429 | * Dump encryption keys. This is an old ioctl that only | |
430 | * handles AES-128-{CCM,GCM}. | |
431 | */ | |
7e7db86c SF |
432 | if (pSMBFile == NULL) |
433 | break; | |
434 | if (!capable(CAP_SYS_ADMIN)) { | |
435 | rc = -EACCES; | |
436 | break; | |
437 | } | |
438 | ||
439 | tcon = tlink_tcon(pSMBFile->tlink); | |
440 | if (!smb3_encryption_required(tcon)) { | |
441 | rc = -EOPNOTSUPP; | |
442 | break; | |
443 | } | |
444 | pkey_inf.cipher_type = | |
445 | le16_to_cpu(tcon->ses->server->cipher_type); | |
446 | pkey_inf.Suid = tcon->ses->Suid; | |
447 | memcpy(pkey_inf.auth_key, tcon->ses->auth_key.response, | |
448 | 16 /* SMB2_NTLMV2_SESSKEY_SIZE */); | |
449 | memcpy(pkey_inf.smb3decryptionkey, | |
450 | tcon->ses->smb3decryptionkey, SMB3_SIGN_KEY_SIZE); | |
451 | memcpy(pkey_inf.smb3encryptionkey, | |
452 | tcon->ses->smb3encryptionkey, SMB3_SIGN_KEY_SIZE); | |
453 | if (copy_to_user((void __user *)arg, &pkey_inf, | |
454 | sizeof(struct smb3_key_debug_info))) | |
455 | rc = -EFAULT; | |
456 | else | |
457 | rc = 0; | |
458 | break; | |
aa22ebc3 | 459 | case CIFS_DUMP_FULL_KEY: |
1bb56810 AA |
460 | /* |
461 | * Dump encryption keys (handles any key sizes) | |
462 | */ | |
aa22ebc3 SF |
463 | if (pSMBFile == NULL) |
464 | break; | |
465 | if (!capable(CAP_SYS_ADMIN)) { | |
466 | rc = -EACCES; | |
467 | break; | |
468 | } | |
aa22ebc3 | 469 | tcon = tlink_tcon(pSMBFile->tlink); |
1bb56810 | 470 | rc = cifs_dump_full_key(tcon, (void __user *)arg); |
aa22ebc3 | 471 | break; |
d26c2ddd SF |
472 | case CIFS_IOC_NOTIFY: |
473 | if (!S_ISDIR(inode->i_mode)) { | |
474 | /* Notify can only be done on directories */ | |
475 | rc = -EOPNOTSUPP; | |
476 | break; | |
477 | } | |
478 | cifs_sb = CIFS_SB(inode->i_sb); | |
a77592a7 RS |
479 | tlink = cifs_sb_tlink(cifs_sb); |
480 | if (IS_ERR(tlink)) { | |
481 | rc = PTR_ERR(tlink); | |
482 | break; | |
483 | } | |
484 | tcon = tlink_tcon(tlink); | |
d26c2ddd SF |
485 | if (tcon && tcon->ses->server->ops->notify) { |
486 | rc = tcon->ses->server->ops->notify(xid, | |
487 | filep, (void __user *)arg); | |
488 | cifs_dbg(FYI, "ioctl notify rc %d\n", rc); | |
489 | } else | |
490 | rc = -EOPNOTSUPP; | |
a77592a7 | 491 | cifs_put_tlink(tlink); |
d26c2ddd | 492 | break; |
087f757b SF |
493 | case CIFS_IOC_SHUTDOWN: |
494 | rc = cifs_shutdown(inode->i_sb, arg); | |
495 | break; | |
1da177e4 | 496 | default: |
f96637be | 497 | cifs_dbg(FYI, "unsupported ioctl\n"); |
f28ac91b | 498 | break; |
1da177e4 | 499 | } |
834170c8 | 500 | cifs_ioc_exit: |
6d5786a3 | 501 | free_xid(xid); |
1da177e4 | 502 | return rc; |
5fdae1f6 | 503 | } |