Merge tag 'x86-kaslr-2020-10-12' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / fs / cifs / smb2inode.c
1 /*
2  *   fs/cifs/smb2inode.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002, 2011
5  *                 Etersoft, 2012
6  *   Author(s): Pavel Shilovsky (pshilovsky@samba.org),
7  *              Steve French (sfrench@us.ibm.com)
8  *
9  *   This library is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU Lesser General Public License as published
11  *   by the Free Software Foundation; either version 2.1 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This library is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
17  *   the GNU Lesser General Public License for more details.
18  *
19  *   You should have received a copy of the GNU Lesser General Public License
20  *   along with this library; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  */
23 #include <linux/fs.h>
24 #include <linux/stat.h>
25 #include <linux/slab.h>
26 #include <linux/pagemap.h>
27 #include <asm/div64.h>
28 #include "cifsfs.h"
29 #include "cifspdu.h"
30 #include "cifsglob.h"
31 #include "cifsproto.h"
32 #include "cifs_debug.h"
33 #include "cifs_fs_sb.h"
34 #include "cifs_unicode.h"
35 #include "fscache.h"
36 #include "smb2glob.h"
37 #include "smb2pdu.h"
38 #include "smb2proto.h"
39
40 static void
41 free_set_inf_compound(struct smb_rqst *rqst)
42 {
43         if (rqst[1].rq_iov)
44                 SMB2_set_info_free(&rqst[1]);
45         if (rqst[2].rq_iov)
46                 SMB2_close_free(&rqst[2]);
47 }
48
49
50 struct cop_vars {
51         struct cifs_open_parms oparms;
52         struct kvec rsp_iov[3];
53         struct smb_rqst rqst[3];
54         struct kvec open_iov[SMB2_CREATE_IOV_SIZE];
55         struct kvec qi_iov[1];
56         struct kvec si_iov[SMB2_SET_INFO_IOV_SIZE];
57         struct kvec close_iov[1];
58         struct smb2_file_rename_info rename_info;
59         struct smb2_file_link_info link_info;
60 };
61
62 static int
63 smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
64                  struct cifs_sb_info *cifs_sb, const char *full_path,
65                  __u32 desired_access, __u32 create_disposition,
66                  __u32 create_options, umode_t mode, void *ptr, int command,
67                  struct cifsFileInfo *cfile)
68 {
69         struct cop_vars *vars = NULL;
70         struct kvec *rsp_iov;
71         struct smb_rqst *rqst;
72         int rc;
73         __le16 *utf16_path = NULL;
74         __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
75         struct cifs_fid fid;
76         struct cifs_ses *ses = tcon->ses;
77         struct TCP_Server_Info *server;
78         int num_rqst = 0;
79         int resp_buftype[3];
80         struct smb2_query_info_rsp *qi_rsp = NULL;
81         int flags = 0;
82         __u8 delete_pending[8] = {1, 0, 0, 0, 0, 0, 0, 0};
83         unsigned int size[2];
84         void *data[2];
85         int len;
86
87         vars = kzalloc(sizeof(*vars), GFP_ATOMIC);
88         if (vars == NULL)
89                 return -ENOMEM;
90         rqst = &vars->rqst[0];
91         rsp_iov = &vars->rsp_iov[0];
92
93         server = cifs_pick_channel(ses);
94
95         if (smb3_encryption_required(tcon))
96                 flags |= CIFS_TRANSFORM_REQ;
97
98         resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
99
100         /* We already have a handle so we can skip the open */
101         if (cfile)
102                 goto after_open;
103
104         /* Open */
105         utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
106         if (!utf16_path) {
107                 rc = -ENOMEM;
108                 goto finished;
109         }
110
111         vars->oparms.tcon = tcon;
112         vars->oparms.desired_access = desired_access;
113         vars->oparms.disposition = create_disposition;
114         vars->oparms.create_options = cifs_create_options(cifs_sb, create_options);
115         vars->oparms.fid = &fid;
116         vars->oparms.reconnect = false;
117         vars->oparms.mode = mode;
118         vars->oparms.cifs_sb = cifs_sb;
119
120         rqst[num_rqst].rq_iov = &vars->open_iov[0];
121         rqst[num_rqst].rq_nvec = SMB2_CREATE_IOV_SIZE;
122         rc = SMB2_open_init(tcon, server,
123                             &rqst[num_rqst], &oplock, &vars->oparms,
124                             utf16_path);
125         kfree(utf16_path);
126         if (rc)
127                 goto finished;
128
129         smb2_set_next_command(tcon, &rqst[num_rqst]);
130  after_open:
131         num_rqst++;
132         rc = 0;
133
134         /* Operation */
135         switch (command) {
136         case SMB2_OP_QUERY_INFO:
137                 rqst[num_rqst].rq_iov = &vars->qi_iov[0];
138                 rqst[num_rqst].rq_nvec = 1;
139
140                 if (cfile)
141                         rc = SMB2_query_info_init(tcon, server,
142                                 &rqst[num_rqst],
143                                 cfile->fid.persistent_fid,
144                                 cfile->fid.volatile_fid,
145                                 FILE_ALL_INFORMATION,
146                                 SMB2_O_INFO_FILE, 0,
147                                 sizeof(struct smb2_file_all_info) +
148                                           PATH_MAX * 2, 0, NULL);
149                 else {
150                         rc = SMB2_query_info_init(tcon, server,
151                                 &rqst[num_rqst],
152                                 COMPOUND_FID,
153                                 COMPOUND_FID,
154                                 FILE_ALL_INFORMATION,
155                                 SMB2_O_INFO_FILE, 0,
156                                 sizeof(struct smb2_file_all_info) +
157                                           PATH_MAX * 2, 0, NULL);
158                         if (!rc) {
159                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
160                                 smb2_set_related(&rqst[num_rqst]);
161                         }
162                 }
163
164                 if (rc)
165                         goto finished;
166                 num_rqst++;
167                 trace_smb3_query_info_compound_enter(xid, ses->Suid, tcon->tid,
168                                                      full_path);
169                 break;
170         case SMB2_OP_POSIX_QUERY_INFO:
171                 rqst[num_rqst].rq_iov = &vars->qi_iov[0];
172                 rqst[num_rqst].rq_nvec = 1;
173
174                 if (cfile)
175                         rc = SMB2_query_info_init(tcon, server,
176                                 &rqst[num_rqst],
177                                 cfile->fid.persistent_fid,
178                                 cfile->fid.volatile_fid,
179                                 SMB_FIND_FILE_POSIX_INFO,
180                                 SMB2_O_INFO_FILE, 0,
181                                 /* TBD: fix following to allow for longer SIDs */
182                                 sizeof(struct smb311_posix_qinfo *) + (PATH_MAX * 2) +
183                                 (sizeof(struct cifs_sid) * 2), 0, NULL);
184                 else {
185                         rc = SMB2_query_info_init(tcon, server,
186                                 &rqst[num_rqst],
187                                 COMPOUND_FID,
188                                 COMPOUND_FID,
189                                 SMB_FIND_FILE_POSIX_INFO,
190                                 SMB2_O_INFO_FILE, 0,
191                                 sizeof(struct smb311_posix_qinfo *) + (PATH_MAX * 2) +
192                                 (sizeof(struct cifs_sid) * 2), 0, NULL);
193                         if (!rc) {
194                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
195                                 smb2_set_related(&rqst[num_rqst]);
196                         }
197                 }
198
199                 if (rc)
200                         goto finished;
201                 num_rqst++;
202                 trace_smb3_posix_query_info_compound_enter(xid, ses->Suid, tcon->tid, full_path);
203                 break;
204         case SMB2_OP_DELETE:
205                 trace_smb3_delete_enter(xid, ses->Suid, tcon->tid, full_path);
206                 break;
207         case SMB2_OP_MKDIR:
208                 /*
209                  * Directories are created through parameters in the
210                  * SMB2_open() call.
211                  */
212                 trace_smb3_mkdir_enter(xid, ses->Suid, tcon->tid, full_path);
213                 break;
214         case SMB2_OP_RMDIR:
215                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
216                 rqst[num_rqst].rq_nvec = 1;
217
218                 size[0] = 1; /* sizeof __u8 See MS-FSCC section 2.4.11 */
219                 data[0] = &delete_pending[0];
220
221                 rc = SMB2_set_info_init(tcon, server,
222                                         &rqst[num_rqst], COMPOUND_FID,
223                                         COMPOUND_FID, current->tgid,
224                                         FILE_DISPOSITION_INFORMATION,
225                                         SMB2_O_INFO_FILE, 0, data, size);
226                 if (rc)
227                         goto finished;
228                 smb2_set_next_command(tcon, &rqst[num_rqst]);
229                 smb2_set_related(&rqst[num_rqst++]);
230                 trace_smb3_rmdir_enter(xid, ses->Suid, tcon->tid, full_path);
231                 break;
232         case SMB2_OP_SET_EOF:
233                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
234                 rqst[num_rqst].rq_nvec = 1;
235
236                 size[0] = 8; /* sizeof __le64 */
237                 data[0] = ptr;
238
239                 rc = SMB2_set_info_init(tcon, server,
240                                         &rqst[num_rqst], COMPOUND_FID,
241                                         COMPOUND_FID, current->tgid,
242                                         FILE_END_OF_FILE_INFORMATION,
243                                         SMB2_O_INFO_FILE, 0, data, size);
244                 if (rc)
245                         goto finished;
246                 smb2_set_next_command(tcon, &rqst[num_rqst]);
247                 smb2_set_related(&rqst[num_rqst++]);
248                 trace_smb3_set_eof_enter(xid, ses->Suid, tcon->tid, full_path);
249                 break;
250         case SMB2_OP_SET_INFO:
251                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
252                 rqst[num_rqst].rq_nvec = 1;
253
254
255                 size[0] = sizeof(FILE_BASIC_INFO);
256                 data[0] = ptr;
257
258                 if (cfile)
259                         rc = SMB2_set_info_init(tcon, server,
260                                 &rqst[num_rqst],
261                                 cfile->fid.persistent_fid,
262                                 cfile->fid.volatile_fid, current->tgid,
263                                 FILE_BASIC_INFORMATION,
264                                 SMB2_O_INFO_FILE, 0, data, size);
265                 else {
266                         rc = SMB2_set_info_init(tcon, server,
267                                 &rqst[num_rqst],
268                                 COMPOUND_FID,
269                                 COMPOUND_FID, current->tgid,
270                                 FILE_BASIC_INFORMATION,
271                                 SMB2_O_INFO_FILE, 0, data, size);
272                         if (!rc) {
273                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
274                                 smb2_set_related(&rqst[num_rqst]);
275                         }
276                 }
277
278                 if (rc)
279                         goto finished;
280                 num_rqst++;
281                 trace_smb3_set_info_compound_enter(xid, ses->Suid, tcon->tid,
282                                                    full_path);
283                 break;
284         case SMB2_OP_RENAME:
285                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
286                 rqst[num_rqst].rq_nvec = 2;
287
288                 len = (2 * UniStrnlen((wchar_t *)ptr, PATH_MAX));
289
290                 vars->rename_info.ReplaceIfExists = 1;
291                 vars->rename_info.RootDirectory = 0;
292                 vars->rename_info.FileNameLength = cpu_to_le32(len);
293
294                 size[0] = sizeof(struct smb2_file_rename_info);
295                 data[0] = &vars->rename_info;
296
297                 size[1] = len + 2 /* null */;
298                 data[1] = (__le16 *)ptr;
299
300                 if (cfile)
301                         rc = SMB2_set_info_init(tcon, server,
302                                                 &rqst[num_rqst],
303                                                 cfile->fid.persistent_fid,
304                                                 cfile->fid.volatile_fid,
305                                         current->tgid, FILE_RENAME_INFORMATION,
306                                         SMB2_O_INFO_FILE, 0, data, size);
307                 else {
308                         rc = SMB2_set_info_init(tcon, server,
309                                         &rqst[num_rqst],
310                                         COMPOUND_FID, COMPOUND_FID,
311                                         current->tgid, FILE_RENAME_INFORMATION,
312                                         SMB2_O_INFO_FILE, 0, data, size);
313                         if (!rc) {
314                                 smb2_set_next_command(tcon, &rqst[num_rqst]);
315                                 smb2_set_related(&rqst[num_rqst]);
316                         }
317                 }
318                 if (rc)
319                         goto finished;
320                 num_rqst++;
321                 trace_smb3_rename_enter(xid, ses->Suid, tcon->tid, full_path);
322                 break;
323         case SMB2_OP_HARDLINK:
324                 rqst[num_rqst].rq_iov = &vars->si_iov[0];
325                 rqst[num_rqst].rq_nvec = 2;
326
327                 len = (2 * UniStrnlen((wchar_t *)ptr, PATH_MAX));
328
329                 vars->link_info.ReplaceIfExists = 0;
330                 vars->link_info.RootDirectory = 0;
331                 vars->link_info.FileNameLength = cpu_to_le32(len);
332
333                 size[0] = sizeof(struct smb2_file_link_info);
334                 data[0] = &vars->link_info;
335
336                 size[1] = len + 2 /* null */;
337                 data[1] = (__le16 *)ptr;
338
339                 rc = SMB2_set_info_init(tcon, server,
340                                         &rqst[num_rqst], COMPOUND_FID,
341                                         COMPOUND_FID, current->tgid,
342                                         FILE_LINK_INFORMATION,
343                                         SMB2_O_INFO_FILE, 0, data, size);
344                 if (rc)
345                         goto finished;
346                 smb2_set_next_command(tcon, &rqst[num_rqst]);
347                 smb2_set_related(&rqst[num_rqst++]);
348                 trace_smb3_hardlink_enter(xid, ses->Suid, tcon->tid, full_path);
349                 break;
350         default:
351                 cifs_dbg(VFS, "Invalid command\n");
352                 rc = -EINVAL;
353         }
354         if (rc)
355                 goto finished;
356
357         /* We already have a handle so we can skip the close */
358         if (cfile)
359                 goto after_close;
360         /* Close */
361         rqst[num_rqst].rq_iov = &vars->close_iov[0];
362         rqst[num_rqst].rq_nvec = 1;
363         rc = SMB2_close_init(tcon, server,
364                              &rqst[num_rqst], COMPOUND_FID,
365                              COMPOUND_FID, false);
366         smb2_set_related(&rqst[num_rqst]);
367         if (rc)
368                 goto finished;
369  after_close:
370         num_rqst++;
371
372         if (cfile) {
373                 cifsFileInfo_put(cfile);
374                 cfile = NULL;
375                 rc = compound_send_recv(xid, ses, server,
376                                         flags, num_rqst - 2,
377                                         &rqst[1], &resp_buftype[1],
378                                         &rsp_iov[1]);
379         } else
380                 rc = compound_send_recv(xid, ses, server,
381                                         flags, num_rqst,
382                                         rqst, resp_buftype,
383                                         rsp_iov);
384
385  finished:
386         if (cfile)
387                 cifsFileInfo_put(cfile);
388
389         SMB2_open_free(&rqst[0]);
390         if (rc == -EREMCHG) {
391                 pr_warn_once("server share %s deleted\n", tcon->treeName);
392                 tcon->need_reconnect = true;
393         }
394
395         switch (command) {
396         case SMB2_OP_QUERY_INFO:
397                 if (rc == 0) {
398                         qi_rsp = (struct smb2_query_info_rsp *)
399                                 rsp_iov[1].iov_base;
400                         rc = smb2_validate_and_copy_iov(
401                                 le16_to_cpu(qi_rsp->OutputBufferOffset),
402                                 le32_to_cpu(qi_rsp->OutputBufferLength),
403                                 &rsp_iov[1], sizeof(struct smb2_file_all_info),
404                                 ptr);
405                 }
406                 if (rqst[1].rq_iov)
407                         SMB2_query_info_free(&rqst[1]);
408                 if (rqst[2].rq_iov)
409                         SMB2_close_free(&rqst[2]);
410                 if (rc)
411                         trace_smb3_query_info_compound_err(xid,  ses->Suid,
412                                                 tcon->tid, rc);
413                 else
414                         trace_smb3_query_info_compound_done(xid, ses->Suid,
415                                                 tcon->tid);
416                 break;
417         case SMB2_OP_POSIX_QUERY_INFO:
418                 if (rc == 0) {
419                         qi_rsp = (struct smb2_query_info_rsp *)
420                                 rsp_iov[1].iov_base;
421                         rc = smb2_validate_and_copy_iov(
422                                 le16_to_cpu(qi_rsp->OutputBufferOffset),
423                                 le32_to_cpu(qi_rsp->OutputBufferLength),
424                                 &rsp_iov[1], sizeof(struct smb311_posix_qinfo) /* add SIDs */, ptr);
425                 }
426                 if (rqst[1].rq_iov)
427                         SMB2_query_info_free(&rqst[1]);
428                 if (rqst[2].rq_iov)
429                         SMB2_close_free(&rqst[2]);
430                 if (rc)
431                         trace_smb3_posix_query_info_compound_err(xid,  ses->Suid, tcon->tid, rc);
432                 else
433                         trace_smb3_posix_query_info_compound_done(xid, ses->Suid, tcon->tid);
434                 break;
435         case SMB2_OP_DELETE:
436                 if (rc)
437                         trace_smb3_delete_err(xid,  ses->Suid, tcon->tid, rc);
438                 else
439                         trace_smb3_delete_done(xid, ses->Suid, tcon->tid);
440                 if (rqst[1].rq_iov)
441                         SMB2_close_free(&rqst[1]);
442                 break;
443         case SMB2_OP_MKDIR:
444                 if (rc)
445                         trace_smb3_mkdir_err(xid,  ses->Suid, tcon->tid, rc);
446                 else
447                         trace_smb3_mkdir_done(xid, ses->Suid, tcon->tid);
448                 if (rqst[1].rq_iov)
449                         SMB2_close_free(&rqst[1]);
450                 break;
451         case SMB2_OP_HARDLINK:
452                 if (rc)
453                         trace_smb3_hardlink_err(xid,  ses->Suid, tcon->tid, rc);
454                 else
455                         trace_smb3_hardlink_done(xid, ses->Suid, tcon->tid);
456                 free_set_inf_compound(rqst);
457                 break;
458         case SMB2_OP_RENAME:
459                 if (rc)
460                         trace_smb3_rename_err(xid,  ses->Suid, tcon->tid, rc);
461                 else
462                         trace_smb3_rename_done(xid, ses->Suid, tcon->tid);
463                 free_set_inf_compound(rqst);
464                 break;
465         case SMB2_OP_RMDIR:
466                 if (rc)
467                         trace_smb3_rmdir_err(xid,  ses->Suid, tcon->tid, rc);
468                 else
469                         trace_smb3_rmdir_done(xid, ses->Suid, tcon->tid);
470                 free_set_inf_compound(rqst);
471                 break;
472         case SMB2_OP_SET_EOF:
473                 if (rc)
474                         trace_smb3_set_eof_err(xid,  ses->Suid, tcon->tid, rc);
475                 else
476                         trace_smb3_set_eof_done(xid, ses->Suid, tcon->tid);
477                 free_set_inf_compound(rqst);
478                 break;
479         case SMB2_OP_SET_INFO:
480                 if (rc)
481                         trace_smb3_set_info_compound_err(xid,  ses->Suid,
482                                                 tcon->tid, rc);
483                 else
484                         trace_smb3_set_info_compound_done(xid, ses->Suid,
485                                                 tcon->tid);
486                 free_set_inf_compound(rqst);
487                 break;
488         }
489         free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base);
490         free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base);
491         free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base);
492         kfree(vars);
493         return rc;
494 }
495
496 void
497 move_smb2_info_to_cifs(FILE_ALL_INFO *dst, struct smb2_file_all_info *src)
498 {
499         memcpy(dst, src, (size_t)(&src->CurrentByteOffset) - (size_t)src);
500         dst->CurrentByteOffset = src->CurrentByteOffset;
501         dst->Mode = src->Mode;
502         dst->AlignmentRequirement = src->AlignmentRequirement;
503         dst->IndexNumber1 = 0; /* we don't use it */
504 }
505
506 int
507 smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
508                      struct cifs_sb_info *cifs_sb, const char *full_path,
509                      FILE_ALL_INFO *data, bool *adjust_tz, bool *symlink)
510 {
511         int rc;
512         struct smb2_file_all_info *smb2_data;
513         __u32 create_options = 0;
514         struct cifs_fid fid;
515         bool no_cached_open = tcon->nohandlecache;
516         struct cifsFileInfo *cfile;
517
518         *adjust_tz = false;
519         *symlink = false;
520
521         smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2,
522                             GFP_KERNEL);
523         if (smb2_data == NULL)
524                 return -ENOMEM;
525
526         /* If it is a root and its handle is cached then use it */
527         if (!strlen(full_path) && !no_cached_open) {
528                 rc = open_shroot(xid, tcon, cifs_sb, &fid);
529                 if (rc)
530                         goto out;
531
532                 if (tcon->crfid.file_all_info_is_valid) {
533                         move_smb2_info_to_cifs(data,
534                                                &tcon->crfid.file_all_info);
535                 } else {
536                         rc = SMB2_query_info(xid, tcon, fid.persistent_fid,
537                                              fid.volatile_fid, smb2_data);
538                         if (!rc)
539                                 move_smb2_info_to_cifs(data, smb2_data);
540                 }
541                 close_shroot(&tcon->crfid);
542                 goto out;
543         }
544
545         cifs_get_readable_path(tcon, full_path, &cfile);
546         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
547                               FILE_READ_ATTRIBUTES, FILE_OPEN, create_options,
548                               ACL_NO_MODE, smb2_data, SMB2_OP_QUERY_INFO, cfile);
549         if (rc == -EOPNOTSUPP) {
550                 *symlink = true;
551                 create_options |= OPEN_REPARSE_POINT;
552
553                 /* Failed on a symbolic link - query a reparse point info */
554                 rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
555                                       FILE_READ_ATTRIBUTES, FILE_OPEN,
556                                       create_options, ACL_NO_MODE,
557                                       smb2_data, SMB2_OP_QUERY_INFO, NULL);
558         }
559         if (rc)
560                 goto out;
561
562         move_smb2_info_to_cifs(data, smb2_data);
563 out:
564         kfree(smb2_data);
565         return rc;
566 }
567
568
569 int
570 smb311_posix_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
571                      struct cifs_sb_info *cifs_sb, const char *full_path,
572                      struct smb311_posix_qinfo *data, bool *adjust_tz, bool *symlink)
573 {
574         int rc;
575         __u32 create_options = 0;
576         struct cifsFileInfo *cfile;
577         struct smb311_posix_qinfo *smb2_data;
578
579         *adjust_tz = false;
580         *symlink = false;
581
582         /* BB TODO: Make struct larger when add support for parsing owner SIDs */
583         smb2_data = kzalloc(sizeof(struct smb311_posix_qinfo),
584                             GFP_KERNEL);
585         if (smb2_data == NULL)
586                 return -ENOMEM;
587
588         /*
589          * BB TODO: Add support for using the cached root handle.
590          * Create SMB2_query_posix_info worker function to do non-compounded query
591          * when we already have an open file handle for this. For now this is fast enough
592          * (always using the compounded version).
593          */
594
595         cifs_get_readable_path(tcon, full_path, &cfile);
596         rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
597                               FILE_READ_ATTRIBUTES, FILE_OPEN, create_options,
598                               ACL_NO_MODE, smb2_data, SMB2_OP_POSIX_QUERY_INFO, cfile);
599         if (rc == -EOPNOTSUPP) {
600                 /* BB TODO: When support for special files added to Samba re-verify this path */
601                 *symlink = true;
602                 create_options |= OPEN_REPARSE_POINT;
603
604                 /* Failed on a symbolic link - query a reparse point info */
605                 rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
606                                       FILE_READ_ATTRIBUTES, FILE_OPEN,
607                                       create_options, ACL_NO_MODE,
608                                       smb2_data, SMB2_OP_POSIX_QUERY_INFO, NULL);
609         }
610         if (rc)
611                 goto out;
612
613          /* TODO: will need to allow for the 2 SIDs when add support for getting owner UID/GID */
614         memcpy(data, smb2_data, sizeof(struct smb311_posix_qinfo));
615
616 out:
617         kfree(smb2_data);
618         return rc;
619 }
620
621 int
622 smb2_mkdir(const unsigned int xid, struct inode *parent_inode, umode_t mode,
623            struct cifs_tcon *tcon, const char *name,
624            struct cifs_sb_info *cifs_sb)
625 {
626         return smb2_compound_op(xid, tcon, cifs_sb, name,
627                                 FILE_WRITE_ATTRIBUTES, FILE_CREATE,
628                                 CREATE_NOT_FILE, mode, NULL, SMB2_OP_MKDIR,
629                                 NULL);
630 }
631
632 void
633 smb2_mkdir_setinfo(struct inode *inode, const char *name,
634                    struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon,
635                    const unsigned int xid)
636 {
637         FILE_BASIC_INFO data;
638         struct cifsInodeInfo *cifs_i;
639         struct cifsFileInfo *cfile;
640         u32 dosattrs;
641         int tmprc;
642
643         memset(&data, 0, sizeof(data));
644         cifs_i = CIFS_I(inode);
645         dosattrs = cifs_i->cifsAttrs | ATTR_READONLY;
646         data.Attributes = cpu_to_le32(dosattrs);
647         cifs_get_writable_path(tcon, name, FIND_WR_ANY, &cfile);
648         tmprc = smb2_compound_op(xid, tcon, cifs_sb, name,
649                                  FILE_WRITE_ATTRIBUTES, FILE_CREATE,
650                                  CREATE_NOT_FILE, ACL_NO_MODE,
651                                  &data, SMB2_OP_SET_INFO, cfile);
652         if (tmprc == 0)
653                 cifs_i->cifsAttrs = dosattrs;
654 }
655
656 int
657 smb2_rmdir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
658            struct cifs_sb_info *cifs_sb)
659 {
660         return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
661                                 CREATE_NOT_FILE, ACL_NO_MODE,
662                                 NULL, SMB2_OP_RMDIR, NULL);
663 }
664
665 int
666 smb2_unlink(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
667             struct cifs_sb_info *cifs_sb)
668 {
669         return smb2_compound_op(xid, tcon, cifs_sb, name, DELETE, FILE_OPEN,
670                                 CREATE_DELETE_ON_CLOSE | OPEN_REPARSE_POINT,
671                                 ACL_NO_MODE, NULL, SMB2_OP_DELETE, NULL);
672 }
673
674 static int
675 smb2_set_path_attr(const unsigned int xid, struct cifs_tcon *tcon,
676                    const char *from_name, const char *to_name,
677                    struct cifs_sb_info *cifs_sb, __u32 access, int command,
678                    struct cifsFileInfo *cfile)
679 {
680         __le16 *smb2_to_name = NULL;
681         int rc;
682
683         smb2_to_name = cifs_convert_path_to_utf16(to_name, cifs_sb);
684         if (smb2_to_name == NULL) {
685                 rc = -ENOMEM;
686                 goto smb2_rename_path;
687         }
688         rc = smb2_compound_op(xid, tcon, cifs_sb, from_name, access,
689                               FILE_OPEN, 0, ACL_NO_MODE, smb2_to_name,
690                               command, cfile);
691 smb2_rename_path:
692         kfree(smb2_to_name);
693         return rc;
694 }
695
696 int
697 smb2_rename_path(const unsigned int xid, struct cifs_tcon *tcon,
698                  const char *from_name, const char *to_name,
699                  struct cifs_sb_info *cifs_sb)
700 {
701         struct cifsFileInfo *cfile;
702
703         cifs_get_writable_path(tcon, from_name, FIND_WR_WITH_DELETE, &cfile);
704
705         return smb2_set_path_attr(xid, tcon, from_name, to_name,
706                                   cifs_sb, DELETE, SMB2_OP_RENAME, cfile);
707 }
708
709 int
710 smb2_create_hardlink(const unsigned int xid, struct cifs_tcon *tcon,
711                      const char *from_name, const char *to_name,
712                      struct cifs_sb_info *cifs_sb)
713 {
714         return smb2_set_path_attr(xid, tcon, from_name, to_name, cifs_sb,
715                                   FILE_READ_ATTRIBUTES, SMB2_OP_HARDLINK,
716                                   NULL);
717 }
718
719 int
720 smb2_set_path_size(const unsigned int xid, struct cifs_tcon *tcon,
721                    const char *full_path, __u64 size,
722                    struct cifs_sb_info *cifs_sb, bool set_alloc)
723 {
724         __le64 eof = cpu_to_le64(size);
725
726         return smb2_compound_op(xid, tcon, cifs_sb, full_path,
727                                 FILE_WRITE_DATA, FILE_OPEN, 0, ACL_NO_MODE,
728                                 &eof, SMB2_OP_SET_EOF, NULL);
729 }
730
731 int
732 smb2_set_file_info(struct inode *inode, const char *full_path,
733                    FILE_BASIC_INFO *buf, const unsigned int xid)
734 {
735         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
736         struct tcon_link *tlink;
737         int rc;
738
739         if ((buf->CreationTime == 0) && (buf->LastAccessTime == 0) &&
740             (buf->LastWriteTime == 0) && (buf->ChangeTime == 0) &&
741             (buf->Attributes == 0))
742                 return 0; /* would be a no op, no sense sending this */
743
744         tlink = cifs_sb_tlink(cifs_sb);
745         if (IS_ERR(tlink))
746                 return PTR_ERR(tlink);
747
748         rc = smb2_compound_op(xid, tlink_tcon(tlink), cifs_sb, full_path,
749                               FILE_WRITE_ATTRIBUTES, FILE_OPEN,
750                               0, ACL_NO_MODE, buf, SMB2_OP_SET_INFO, NULL);
751         cifs_put_tlink(tlink);
752         return rc;
753 }