1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * SMB1 (CIFS) version specific operations
4 *
5 * Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
6 */
7
8 #include <linux/pagemap.h>
9 #include <linux/vfs.h>
10 #include <uapi/linux/magic.h>
11 #include "cifsglob.h"
12 #include "cifsproto.h"
13 #include "cifs_debug.h"
14 #include "cifspdu.h"
15 #include "cifs_unicode.h"
16 #include "fs_context.h"
17
18 /*
19 * An NT cancel request header looks just like the original request except:
20 *
21 * The Command is SMB_COM_NT_CANCEL
22 * The WordCount is zeroed out
23 * The ByteCount is zeroed out
24 *
25 * This function mangles an existing request buffer into a
26 * SMB_COM_NT_CANCEL request and then sends it.
27 */
28 static int
29 send_nt_cancel(struct TCP_Server_Info *server, struct smb_rqst *rqst,
30 struct mid_q_entry *mid)
31 {
32 int rc = 0;
33 struct smb_hdr *in_buf = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
34
35 /* -4 for RFC1001 length and +2 for BCC field */
36 in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2);
37 in_buf->Command = SMB_COM_NT_CANCEL;
38 in_buf->WordCount = 0;
39 put_bcc(0, in_buf);
40
41 cifs_server_lock(server);
42 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
43 if (rc) {
44 cifs_server_unlock(server);
45 return rc;
46 }
47
48 /*
49 * The response to this call was already factored into the sequence
50 * number when the call went out, so we must adjust it back downward
51 * after signing here.
52 */
53 --server->sequence_number;
54 rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
55 if (rc < 0)
56 server->sequence_number--;
57
58 cifs_server_unlock(server);
59
60 cifs_dbg(FYI, "issued NT_CANCEL for mid %u, rc = %d\n",
61 get_mid(in_buf), rc);
62
63 return rc;
64 }
65
66 static bool
67 cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
68 {
69 return ob1->fid.netfid == ob2->fid.netfid;
70 }
71
72 static unsigned int
73 cifs_read_data_offset(char *buf)
74 {
75 READ_RSP *rsp = (READ_RSP *)buf;
76 return le16_to_cpu(rsp->DataOffset);
77 }
78
79 static unsigned int
80 cifs_read_data_length(char *buf, bool in_remaining)
81 {
82 READ_RSP *rsp = (READ_RSP *)buf;
83 /* It's a bug reading remaining data for SMB1 packets */
84 WARN_ON(in_remaining);
85 return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
86 le16_to_cpu(rsp->DataLength);
87 }
88
89 static struct mid_q_entry *
90 cifs_find_mid(struct TCP_Server_Info *server, char *buffer)
91 {
92 struct smb_hdr *buf = (struct smb_hdr *)buffer;
93 struct mid_q_entry *mid;
94
95 spin_lock(&server->mid_lock);
96 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
97 if (compare_mid(mid->mid, buf) &&
98 mid->mid_state == MID_REQUEST_SUBMITTED &&
99 le16_to_cpu(mid->command) == buf->Command) {
100 kref_get(&mid->refcount);
101 spin_unlock(&server->mid_lock);
102 return mid;
103 }
104 }
105 spin_unlock(&server->mid_lock);
106 return NULL;
107 }
108
109 static void
110 cifs_add_credits(struct TCP_Server_Info *server,
111 struct cifs_credits *credits, const int optype)
112 {
113 spin_lock(&server->req_lock);
114 server->credits += credits->value;
115 server->in_flight--;
116 spin_unlock(&server->req_lock);
117 wake_up(&server->request_q);
118 }
119
120 static void
121 cifs_set_credits(struct TCP_Server_Info *server, const int val)
122 {
123 spin_lock(&server->req_lock);
124 server->credits = val;
125 server->oplocks = val > 1 ? enable_oplocks : false;
126 spin_unlock(&server->req_lock);
127 }
128
129 static int *
130 cifs_get_credits_field(struct TCP_Server_Info *server, const int optype)
131 {
132 return &server->credits;
133 }
134
135 static unsigned int
136 cifs_get_credits(struct mid_q_entry *mid)
137 {
138 return 1;
139 }
140
141 /*
142 * Find a free multiplex id (SMB mid). Otherwise there could be
143 * mid collisions which might cause problems, demultiplexing the
144 * wrong response to this request. Multiplex ids could collide if
145 * one of a series requests takes much longer than the others, or
146 * if a very large number of long lived requests (byte range
147 * locks or FindNotify requests) are pending. No more than
148 * 64K-1 requests can be outstanding at one time. If no
149 * mids are available, return zero. A future optimization
150 * could make the combination of mids and uid the key we use
151 * to demultiplex on (rather than mid alone).
152 * In addition to the above check, the cifs demultiplex
153 * code already used the command code as a secondary
154 * check of the frame and if signing is negotiated the
155 * response would be discarded if the mid were the same
156 * but the signature was wrong. Since the mid is not put in the
157 * pending queue until later (when it is about to be dispatched)
158 * we do have to limit the number of outstanding requests
159 * to somewhat less than 64K-1 although it is hard to imagine
160 * so many threads being in the vfs at one time.
161 */
162 static __u64
163 cifs_get_next_mid(struct TCP_Server_Info *server)
164 {
165 __u64 mid = 0;
166 __u16 last_mid, cur_mid;
167 bool collision, reconnect = false;
168
169 spin_lock(&server->mid_lock);
170
171 /* mid is 16 bit only for CIFS/SMB */
172 cur_mid = (__u16)((server->CurrentMid) & 0xffff);
173 /* we do not want to loop forever */
174 last_mid = cur_mid;
175 cur_mid++;
176 /* avoid 0xFFFF MID */
177 if (cur_mid == 0xffff)
178 cur_mid++;
179
180 /*
181 * This nested loop looks more expensive than it is.
182 * In practice the list of pending requests is short,
183 * fewer than 50, and the mids are likely to be unique
184 * on the first pass through the loop unless some request
185 * takes longer than the 64 thousand requests before it
186 * (and it would also have to have been a request that
187 * did not time out).
188 */
189 while (cur_mid != last_mid) {
190 struct mid_q_entry *mid_entry;
191 unsigned int num_mids;
192
193 collision = false;
194 if (cur_mid == 0)
195 cur_mid++;
196
197 num_mids = 0;
198 list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {
199 ++num_mids;
200 if (mid_entry->mid == cur_mid &&
201 mid_entry->mid_state == MID_REQUEST_SUBMITTED) {
202 /* This mid is in use, try a different one */
203 collision = true;
204 break;
205 }
206 }
207
208 /*
209 * if we have more than 32k mids in the list, then something
210 * is very wrong. Possibly a local user is trying to DoS the
211 * box by issuing long-running calls and SIGKILL'ing them. If
212 * we get to 2^16 mids then we're in big trouble as this
213 * function could loop forever.
214 *
215 * Go ahead and assign out the mid in this situation, but force
216 * an eventual reconnect to clean out the pending_mid_q.
217 */
218 if (num_mids > 32768)
219 reconnect = true;
220
221 if (!collision) {
222 mid = (__u64)cur_mid;
223 server->CurrentMid = mid;
224 break;
225 }
226 cur_mid++;
227 }
228 spin_unlock(&server->mid_lock);
229
230 if (reconnect) {
231 cifs_signal_cifsd_for_reconnect(server, false);
232 }
233
234 return mid;
235 }
236
237 /*
238 return codes:
239 0 not a transact2, or all data present
240 >0 transact2 with that much data missing
241 -EINVAL invalid transact2
242 */
243 static int
244 check2ndT2(char *buf)
245 {
246 struct smb_hdr *pSMB = (struct smb_hdr *)buf;
247 struct smb_t2_rsp *pSMBt;
248 int remaining;
249 __u16 total_data_size, data_in_this_rsp;
250
251 if (pSMB->Command != SMB_COM_TRANSACTION2)
252 return 0;
253
254 /* check for plausible wct, bcc and t2 data and parm sizes */
255 /* check for parm and data offset going beyond end of smb */
256 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
257 cifs_dbg(FYI, "Invalid transact2 word count\n");
258 return -EINVAL;
259 }
260
261 pSMBt = (struct smb_t2_rsp *)pSMB;
262
263 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
264 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
265
266 if (total_data_size == data_in_this_rsp)
267 return 0;
268 else if (total_data_size < data_in_this_rsp) {
269 cifs_dbg(FYI, "total data %d smaller than data in frame %d\n",
270 total_data_size, data_in_this_rsp);
271 return -EINVAL;
272 }
273
274 remaining = total_data_size - data_in_this_rsp;
275
276 cifs_dbg(FYI, "missing %d bytes from transact2, check next response\n",
277 remaining);
278 if (total_data_size > CIFSMaxBufSize) {
279 cifs_dbg(VFS, "TotalDataSize %d is over maximum buffer %d\n",
280 total_data_size, CIFSMaxBufSize);
281 return -EINVAL;
282 }
283 return remaining;
284 }
285
286 static int
287 coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
288 {
289 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
290 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)target_hdr;
291 char *data_area_of_tgt;
292 char *data_area_of_src;
293 int remaining;
294 unsigned int byte_count, total_in_tgt;
295 __u16 tgt_total_cnt, src_total_cnt, total_in_src;
296
297 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
298 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
299
300 if (tgt_total_cnt != src_total_cnt)
301 cifs_dbg(FYI, "total data count of primary and secondary t2 differ source=%hu target=%hu\n",
302 src_total_cnt, tgt_total_cnt);
303
304 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
305
306 remaining = tgt_total_cnt - total_in_tgt;
307
308 if (remaining < 0) {
309 cifs_dbg(FYI, "Server sent too much data. tgt_total_cnt=%hu total_in_tgt=%u\n",
310 tgt_total_cnt, total_in_tgt);
311 return -EPROTO;
312 }
313
314 if (remaining == 0) {
315 /* nothing to do, ignore */
316 cifs_dbg(FYI, "no more data remains\n");
317 return 0;
318 }
319
320 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
321 if (remaining < total_in_src)
322 cifs_dbg(FYI, "transact2 2nd response contains too much data\n");
323
324 /* find end of first SMB data area */
325 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
326 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
327
328 /* validate target area */
329 data_area_of_src = (char *)&pSMBs->hdr.Protocol +
330 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
331
332 data_area_of_tgt += total_in_tgt;
333
334 total_in_tgt += total_in_src;
335 /* is the result too big for the field? */
336 if (total_in_tgt > USHRT_MAX) {
337 cifs_dbg(FYI, "coalesced DataCount too large (%u)\n",
338 total_in_tgt);
339 return -EPROTO;
340 }
341 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
342
343 /* fix up the BCC */
344 byte_count = get_bcc(target_hdr);
345 byte_count += total_in_src;
346 /* is the result too big for the field? */
347 if (byte_count > USHRT_MAX) {
348 cifs_dbg(FYI, "coalesced BCC too large (%u)\n", byte_count);
349 return -EPROTO;
350 }
351 put_bcc(byte_count, target_hdr);
352
353 byte_count = be32_to_cpu(target_hdr->smb_buf_length);
354 byte_count += total_in_src;
355 /* don't allow buffer to overflow */
356 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
357 cifs_dbg(FYI, "coalesced BCC exceeds buffer size (%u)\n",
358 byte_count);
359 return -ENOBUFS;
360 }
361 target_hdr->smb_buf_length = cpu_to_be32(byte_count);
362
363 /* copy second buffer into end of first buffer */
364 memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
365
366 if (remaining != total_in_src) {
367 /* more responses to go */
368 cifs_dbg(FYI, "waiting for more secondary responses\n");
369 return 1;
370 }
371
372 /* we are done */
373 cifs_dbg(FYI, "found the last secondary response\n");
374 return 0;
375 }
376
377 static void
378 cifs_downgrade_oplock(struct TCP_Server_Info *server,
379 struct cifsInodeInfo *cinode, __u32 oplock,
380 unsigned int epoch, bool *purge_cache)
381 {
382 cifs_set_oplock_level(cinode, oplock);
383 }
384
385 static bool
386 cifs_check_trans2(struct mid_q_entry *mid, struct TCP_Server_Info *server,
387 char *buf, int malformed)
388 {
389 if (malformed)
390 return false;
391 if (check2ndT2(buf) <= 0)
392 return false;
393 mid->multiRsp = true;
394 if (mid->resp_buf) {
395 /* merge response - fix up 1st*/
396 malformed = coalesce_t2(buf, mid->resp_buf);
397 if (malformed > 0)
398 return true;
399 /* All parts received or packet is malformed. */
400 mid->multiEnd = true;
401 dequeue_mid(mid, malformed);
402 return true;
403 }
404 if (!server->large_buf) {
405 /*FIXME: switch to already allocated largebuf?*/
406 cifs_dbg(VFS, "1st trans2 resp needs bigbuf\n");
407 } else {
408 /* Have first buffer */
409 mid->resp_buf = buf;
410 mid->large_buf = true;
411 server->bigbuf = NULL;
412 }
413 return true;
414 }
415
416 static bool
417 cifs_need_neg(struct TCP_Server_Info *server)
418 {
419 return server->maxBuf == 0;
420 }
421
422 static int
423 cifs_negotiate(const unsigned int xid,
424 struct cifs_ses *ses,
425 struct TCP_Server_Info *server)
426 {
427 int rc;
428 rc = CIFSSMBNegotiate(xid, ses, server);
429 if (rc == -EAGAIN) {
430 /* retry only once on 1st time connection */
431 set_credits(server, 1);
432 rc = CIFSSMBNegotiate(xid, ses, server);
433 if (rc == -EAGAIN)
434 rc = -EHOSTDOWN;
435 }
436 return rc;
437 }
438
439 static unsigned int
440 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
441 {
442 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
443 struct TCP_Server_Info *server = tcon->ses->server;
444 unsigned int wsize;
445
446 /* start with specified wsize, or default */
447 if (ctx->wsize)
448 wsize = ctx->wsize;
449 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
450 wsize = CIFS_DEFAULT_IOSIZE;
451 else
452 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
453
454 /* can server support 24-bit write sizes? (via UNIX extensions) */
455 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
456 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
457
458 /*
459 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
460 * Limit it to max buffer offered by the server, minus the size of the
461 * WRITEX header, not including the 4 byte RFC1001 length.
462 */
463 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
464 (!(server->capabilities & CAP_UNIX) && server->sign))
465 wsize = min_t(unsigned int, wsize,
466 server->maxBuf - sizeof(WRITE_REQ) + 4);
467
468 /* hard limit of CIFS_MAX_WSIZE */
469 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
470
471 return wsize;
472 }
473
474 static unsigned int
475 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
476 {
477 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
478 struct TCP_Server_Info *server = tcon->ses->server;
479 unsigned int rsize, defsize;
480
481 /*
482 * Set default value...
483 *
484 * HACK alert! Ancient servers have very small buffers. Even though
485 * MS-CIFS indicates that servers are only limited by the client's
486 * bufsize for reads, testing against win98se shows that it throws
487 * INVALID_PARAMETER errors if you try to request too large a read.
488 * OS/2 just sends back short reads.
489 *
490 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
491 * it can't handle a read request larger than its MaxBufferSize either.
492 */
493 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
494 defsize = CIFS_DEFAULT_IOSIZE;
495 else if (server->capabilities & CAP_LARGE_READ_X)
496 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
497 else
498 defsize = server->maxBuf - sizeof(READ_RSP);
499
500 rsize = ctx->rsize ? ctx->rsize : defsize;
501
502 /*
503 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
504 * the client's MaxBufferSize.
505 */
506 if (!(server->capabilities & CAP_LARGE_READ_X))
507 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
508
509 /* hard limit of CIFS_MAX_RSIZE */
510 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
511
512 return rsize;
513 }
514
515 static void
516 cifs_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon,
517 struct cifs_sb_info *cifs_sb)
518 {
519 CIFSSMBQFSDeviceInfo(xid, tcon);
520 CIFSSMBQFSAttributeInfo(xid, tcon);
521 }
522
523 static int
524 cifs_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
525 struct cifs_sb_info *cifs_sb, const char *full_path)
526 {
527 int rc;
528 FILE_ALL_INFO *file_info;
529
530 file_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
531 if (file_info == NULL)
532 return -ENOMEM;
533
534 rc = CIFSSMBQPathInfo(xid, tcon, full_path, file_info,
535 0 /* not legacy */, cifs_sb->local_nls,
536 cifs_remap(cifs_sb));
537
538 if (rc == -EOPNOTSUPP || rc == -EINVAL)
539 rc = SMBQueryInformation(xid, tcon, full_path, file_info,
540 cifs_sb->local_nls, cifs_remap(cifs_sb));
541 kfree(file_info);
542 return rc;
543 }
544
545 static int cifs_query_path_info(const unsigned int xid,
546 struct cifs_tcon *tcon,
547 struct cifs_sb_info *cifs_sb,
548 const char *full_path,
549 struct cifs_open_info_data *data)
550 {
551 int rc;
552 FILE_ALL_INFO fi = {};
553
554 data->symlink = false;
555 data->adjust_tz = false;
556
557 /* could do find first instead but this returns more info */
558 rc = CIFSSMBQPathInfo(xid, tcon, full_path, &fi, 0 /* not legacy */, cifs_sb->local_nls,
559 cifs_remap(cifs_sb));
560 /*
561 * BB optimize code so we do not make the above call when server claims
562 * no NT SMB support and the above call failed at least once - set flag
563 * in tcon or mount.
564 */
565 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
566 rc = SMBQueryInformation(xid, tcon, full_path, &fi, cifs_sb->local_nls,
567 cifs_remap(cifs_sb));
568 data->adjust_tz = true;
569 }
570
571 if (!rc) {
572 int tmprc;
573 int oplock = 0;
574 struct cifs_fid fid;
575 struct cifs_open_parms oparms;
576
577 move_cifs_info_to_smb2(&data->fi, &fi);
578
579 if (!(le32_to_cpu(fi.Attributes) & ATTR_REPARSE))
580 return 0;
581
582 oparms = (struct cifs_open_parms) {
583 .tcon = tcon,
584 .cifs_sb = cifs_sb,
585 .desired_access = FILE_READ_ATTRIBUTES,
586 .create_options = cifs_create_options(cifs_sb, 0),
587 .disposition = FILE_OPEN,
588 .path = full_path,
589 .fid = &fid,
590 };
591
592 /* Need to check if this is a symbolic link or not */
593 tmprc = CIFS_open(xid, &oparms, &oplock, NULL);
594 if (tmprc == -EOPNOTSUPP)
595 data->symlink = true;
596 else if (tmprc == 0)
597 CIFSSMBClose(xid, tcon, fid.netfid);
598 }
599
600 return rc;
601 }
602
603 static int cifs_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
604 struct cifs_sb_info *cifs_sb, const char *full_path,
605 u64 *uniqueid, struct cifs_open_info_data *unused)
606 {
607 /*
608 * We can not use the IndexNumber field by default from Windows or
609 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
610 * CIFS spec claims that this value is unique within the scope of a
611 * share, and the windows docs hint that it's actually unique
612 * per-machine.
613 *
614 * There may be higher info levels that work but are there Windows
615 * server or network appliances for which IndexNumber field is not
616 * guaranteed unique?
617 */
618 return CIFSGetSrvInodeNumber(xid, tcon, full_path, uniqueid,
619 cifs_sb->local_nls,
620 cifs_remap(cifs_sb));
621 }
622
623 static int cifs_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
624 struct cifsFileInfo *cfile, struct cifs_open_info_data *data)
625 {
626 int rc;
627 FILE_ALL_INFO fi = {};
628
629 if (cfile->symlink_target) {
630 data->symlink_target = kstrdup(cfile->symlink_target, GFP_KERNEL);
631 if (!data->symlink_target)
632 return -ENOMEM;
633 }
634
635 rc = CIFSSMBQFileInfo(xid, tcon, cfile->fid.netfid, &fi);
636 if (!rc)
637 move_cifs_info_to_smb2(&data->fi, &fi);
638 return rc;
639 }
640
641 static void
642 cifs_clear_stats(struct cifs_tcon *tcon)
643 {
644 atomic_set(&tcon->stats.cifs_stats.num_writes, 0);
645 atomic_set(&tcon->stats.cifs_stats.num_reads, 0);
646 atomic_set(&tcon->stats.cifs_stats.num_flushes, 0);
647 atomic_set(&tcon->stats.cifs_stats.num_oplock_brks, 0);
648 atomic_set(&tcon->stats.cifs_stats.num_opens, 0);
649 atomic_set(&tcon->stats.cifs_stats.num_posixopens, 0);
650 atomic_set(&tcon->stats.cifs_stats.num_posixmkdirs, 0);
651 atomic_set(&tcon->stats.cifs_stats.num_closes, 0);
652 atomic_set(&tcon->stats.cifs_stats.num_deletes, 0);
653 atomic_set(&tcon->stats.cifs_stats.num_mkdirs, 0);
654 atomic_set(&tcon->stats.cifs_stats.num_rmdirs, 0);
655 atomic_set(&tcon->stats.cifs_stats.num_renames, 0);
656 atomic_set(&tcon->stats.cifs_stats.num_t2renames, 0);
657 atomic_set(&tcon->stats.cifs_stats.num_ffirst, 0);
658 atomic_set(&tcon->stats.cifs_stats.num_fnext, 0);
659 atomic_set(&tcon->stats.cifs_stats.num_fclose, 0);
660 atomic_set(&tcon->stats.cifs_stats.num_hardlinks, 0);
661 atomic_set(&tcon->stats.cifs_stats.num_symlinks, 0);
662 atomic_set(&tcon->stats.cifs_stats.num_locks, 0);
663 atomic_set(&tcon->stats.cifs_stats.num_acl_get, 0);
664 atomic_set(&tcon->stats.cifs_stats.num_acl_set, 0);
665 }
666
667 static void
668 cifs_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
669 {
670 seq_printf(m, " Oplocks breaks: %d",
671 atomic_read(&tcon->stats.cifs_stats.num_oplock_brks));
672 seq_printf(m, "\nReads: %d Bytes: %llu",
673 atomic_read(&tcon->stats.cifs_stats.num_reads),
674 (long long)(tcon->bytes_read));
675 seq_printf(m, "\nWrites: %d Bytes: %llu",
676 atomic_read(&tcon->stats.cifs_stats.num_writes),
677 (long long)(tcon->bytes_written));
678 seq_printf(m, "\nFlushes: %d",
679 atomic_read(&tcon->stats.cifs_stats.num_flushes));
680 seq_printf(m, "\nLocks: %d HardLinks: %d Symlinks: %d",
681 atomic_read(&tcon->stats.cifs_stats.num_locks),
682 atomic_read(&tcon->stats.cifs_stats.num_hardlinks),
683 atomic_read(&tcon->stats.cifs_stats.num_symlinks));
684 seq_printf(m, "\nOpens: %d Closes: %d Deletes: %d",
685 atomic_read(&tcon->stats.cifs_stats.num_opens),
686 atomic_read(&tcon->stats.cifs_stats.num_closes),
687 atomic_read(&tcon->stats.cifs_stats.num_deletes));
688 seq_printf(m, "\nPosix Opens: %d Posix Mkdirs: %d",
689 atomic_read(&tcon->stats.cifs_stats.num_posixopens),
690 atomic_read(&tcon->stats.cifs_stats.num_posixmkdirs));
691 seq_printf(m, "\nMkdirs: %d Rmdirs: %d",
692 atomic_read(&tcon->stats.cifs_stats.num_mkdirs),
693 atomic_read(&tcon->stats.cifs_stats.num_rmdirs));
694 seq_printf(m, "\nRenames: %d T2 Renames %d",
695 atomic_read(&tcon->stats.cifs_stats.num_renames),
696 atomic_read(&tcon->stats.cifs_stats.num_t2renames));
697 seq_printf(m, "\nFindFirst: %d FNext %d FClose %d",
698 atomic_read(&tcon->stats.cifs_stats.num_ffirst),
699 atomic_read(&tcon->stats.cifs_stats.num_fnext),
700 atomic_read(&tcon->stats.cifs_stats.num_fclose));
701 }
702
703 static void
704 cifs_mkdir_setinfo(struct inode *inode, const char *full_path,
705 struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon,
706 const unsigned int xid)
707 {
708 FILE_BASIC_INFO info;
709 struct cifsInodeInfo *cifsInode;
710 u32 dosattrs;
711 int rc;
712
713 memset(&info, 0, sizeof(info));
714 cifsInode = CIFS_I(inode);
715 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
716 info.Attributes = cpu_to_le32(dosattrs);
717 rc = CIFSSMBSetPathInfo(xid, tcon, full_path, &info, cifs_sb->local_nls,
718 cifs_sb);
719 if (rc == 0)
720 cifsInode->cifsAttrs = dosattrs;
721 }
722
723 static int cifs_open_file(const unsigned int xid, struct cifs_open_parms *oparms, __u32 *oplock,
724 void *buf)
725 {
726 struct cifs_open_info_data *data = buf;
727 FILE_ALL_INFO fi = {};
728 int rc;
729
730 if (!(oparms->tcon->ses->capabilities & CAP_NT_SMBS))
731 rc = SMBLegacyOpen(xid, oparms->tcon, oparms->path,
732 oparms->disposition,
733 oparms->desired_access,
734 oparms->create_options,
735 &oparms->fid->netfid, oplock, &fi,
736 oparms->cifs_sb->local_nls,
737 cifs_remap(oparms->cifs_sb));
738 else
739 rc = CIFS_open(xid, oparms, oplock, &fi);
740
741 if (!rc && data)
742 move_cifs_info_to_smb2(&data->fi, &fi);
743
744 return rc;
745 }
746
747 static void
748 cifs_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
749 {
750 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
751 cfile->fid.netfid = fid->netfid;
752 cifs_set_oplock_level(cinode, oplock);
753 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
754 }
755
756 static int
757 cifs_close_file(const unsigned int xid, struct cifs_tcon *tcon,
758 struct cifs_fid *fid)
759 {
760 return CIFSSMBClose(xid, tcon, fid->netfid);
761 }
762
763 static int
764 cifs_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
765 struct cifs_fid *fid)
766 {
767 return CIFSSMBFlush(xid, tcon, fid->netfid);
768 }
769
770 static int
771 cifs_sync_read(const unsigned int xid, struct cifs_fid *pfid,
772 struct cifs_io_parms *parms, unsigned int *bytes_read,
773 char **buf, int *buf_type)
774 {
775 parms->netfid = pfid->netfid;
776 return CIFSSMBRead(xid, parms, bytes_read, buf, buf_type);
777 }
778
779 static int
780 cifs_sync_write(const unsigned int xid, struct cifs_fid *pfid,
781 struct cifs_io_parms *parms, unsigned int *written,
782 struct kvec *iov, unsigned long nr_segs)
783 {
784
785 parms->netfid = pfid->netfid;
786 return CIFSSMBWrite2(xid, parms, written, iov, nr_segs);
787 }
788
789 static int
790 smb_set_file_info(struct inode *inode, const char *full_path,
791 FILE_BASIC_INFO *buf, const unsigned int xid)
792 {
793 int oplock = 0;
794 int rc;
795 __u32 netpid;
796 struct cifs_fid fid;
797 struct cifs_open_parms oparms;
798 struct cifsFileInfo *open_file;
799 struct cifsInodeInfo *cinode = CIFS_I(inode);
800 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
801 struct tcon_link *tlink = NULL;
802 struct cifs_tcon *tcon;
803
804 /* if the file is already open for write, just use that fileid */
805 open_file = find_writable_file(cinode, FIND_WR_FSUID_ONLY);
806 if (open_file) {
807 fid.netfid = open_file->fid.netfid;
808 netpid = open_file->pid;
809 tcon = tlink_tcon(open_file->tlink);
810 goto set_via_filehandle;
811 }
812
813 tlink = cifs_sb_tlink(cifs_sb);
814 if (IS_ERR(tlink)) {
815 rc = PTR_ERR(tlink);
816 tlink = NULL;
817 goto out;
818 }
819 tcon = tlink_tcon(tlink);
820
821 rc = CIFSSMBSetPathInfo(xid, tcon, full_path, buf, cifs_sb->local_nls,
822 cifs_sb);
823 if (rc == 0) {
824 cinode->cifsAttrs = le32_to_cpu(buf->Attributes);
825 goto out;
826 } else if (rc != -EOPNOTSUPP && rc != -EINVAL) {
827 goto out;
828 }
829
830 oparms = (struct cifs_open_parms) {
831 .tcon = tcon,
832 .cifs_sb = cifs_sb,
833 .desired_access = SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
834 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
835 .disposition = FILE_OPEN,
836 .path = full_path,
837 .fid = &fid,
838 };
839
840 cifs_dbg(FYI, "calling SetFileInfo since SetPathInfo for times not supported by this server\n");
841 rc = CIFS_open(xid, &oparms, &oplock, NULL);
842 if (rc != 0) {
843 if (rc == -EIO)
844 rc = -EINVAL;
845 goto out;
846 }
847
848 netpid = current->tgid;
849
850 set_via_filehandle:
851 rc = CIFSSMBSetFileInfo(xid, tcon, buf, fid.netfid, netpid);
852 if (!rc)
853 cinode->cifsAttrs = le32_to_cpu(buf->Attributes);
854
855 if (open_file == NULL)
856 CIFSSMBClose(xid, tcon, fid.netfid);
857 else
858 cifsFileInfo_put(open_file);
859 out:
860 if (tlink != NULL)
861 cifs_put_tlink(tlink);
862 return rc;
863 }
864
865 static int
866 cifs_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
867 struct cifsFileInfo *cfile)
868 {
869 return CIFSSMB_set_compression(xid, tcon, cfile->fid.netfid);
870 }
871
872 static int
873 cifs_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
874 const char *path, struct cifs_sb_info *cifs_sb,
875 struct cifs_fid *fid, __u16 search_flags,
876 struct cifs_search_info *srch_inf)
877 {
878 int rc;
879
880 rc = CIFSFindFirst(xid, tcon, path, cifs_sb,
881 &fid->netfid, search_flags, srch_inf, true);
882 if (rc)
883 cifs_dbg(FYI, "find first failed=%d\n", rc);
884 return rc;
885 }
886
887 static int
888 cifs_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon,
889 struct cifs_fid *fid, __u16 search_flags,
890 struct cifs_search_info *srch_inf)
891 {
892 return CIFSFindNext(xid, tcon, fid->netfid, search_flags, srch_inf);
893 }
894
895 static int
896 cifs_close_dir(const unsigned int xid, struct cifs_tcon *tcon,
897 struct cifs_fid *fid)
898 {
899 return CIFSFindClose(xid, tcon, fid->netfid);
900 }
901
902 static int
903 cifs_oplock_response(struct cifs_tcon *tcon, __u64 persistent_fid,
904 __u64 volatile_fid, __u16 net_fid, struct cifsInodeInfo *cinode)
905 {
906 return CIFSSMBLock(0, tcon, net_fid, current->tgid, 0, 0, 0, 0,
907 LOCKING_ANDX_OPLOCK_RELEASE, false, CIFS_CACHE_READ(cinode) ? 1 : 0);
908 }
909
910 static int
911 cifs_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
912 const char *path, struct cifs_sb_info *cifs_sb, struct kstatfs *buf)
913 {
914 int rc = -EOPNOTSUPP;
915
916 buf->f_type = CIFS_SUPER_MAGIC;
917
918 /*
919 * We could add a second check for a QFS Unix capability bit
920 */
921 if ((tcon->ses->capabilities & CAP_UNIX) &&
922 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
923 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
924
925 /*
926 * Only need to call the old QFSInfo if failed on newer one,
927 * e.g. by OS/2.
928 **/
929 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
930 rc = CIFSSMBQFSInfo(xid, tcon, buf);
931
932 /*
933 * Some old Windows servers also do not support level 103, retry with
934 * older level one if old server failed the previous call or we
935 * bypassed it because we detected that this was an older LANMAN sess
936 */
937 if (rc)
938 rc = SMBOldQFSInfo(xid, tcon, buf);
939 return rc;
940 }
941
942 static int
943 cifs_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
944 __u64 length, __u32 type, int lock, int unlock, bool wait)
945 {
946 return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->fid.netfid,
947 current->tgid, length, offset, unlock, lock,
948 (__u8)type, wait, 0);
949 }
950
951 static int
952 cifs_unix_dfs_readlink(const unsigned int xid, struct cifs_tcon *tcon,
953 const unsigned char *searchName, char **symlinkinfo,
954 const struct nls_table *nls_codepage)
955 {
956 #ifdef CONFIG_CIFS_DFS_UPCALL
957 int rc;
958 struct dfs_info3_param referral = {0};
959
960 rc = get_dfs_path(xid, tcon->ses, searchName, nls_codepage, &referral,
961 0);
962
963 if (!rc) {
964 *symlinkinfo = kstrdup(referral.node_name, GFP_KERNEL);
965 free_dfs_info_param(&referral);
966 if (!*symlinkinfo)
967 rc = -ENOMEM;
968 }
969 return rc;
970 #else /* No DFS support */
971 return -EREMOTE;
972 #endif
973 }
974
975 static int cifs_query_symlink(const unsigned int xid,
976 struct cifs_tcon *tcon,
977 struct cifs_sb_info *cifs_sb,
978 const char *full_path,
979 char **target_path)
980 {
981 int rc;
982
983 cifs_tcon_dbg(FYI, "%s: path=%s\n", __func__, full_path);
984
985 if (!cap_unix(tcon->ses))
986 return -EOPNOTSUPP;
987
988 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, target_path,
989 cifs_sb->local_nls, cifs_remap(cifs_sb));
990 if (rc == -EREMOTE)
991 rc = cifs_unix_dfs_readlink(xid, tcon, full_path,
992 target_path, cifs_sb->local_nls);
993 return rc;
994 }
995
996 static int cifs_parse_reparse_point(struct cifs_sb_info *cifs_sb,
997 struct kvec *rsp_iov,
998 struct cifs_open_info_data *data)
999 {
1000 struct reparse_data_buffer *buf;
1001 TRANSACT_IOCTL_RSP *io = rsp_iov->iov_base;
1002 bool unicode = !!(io->hdr.Flags2 & SMBFLG2_UNICODE);
1003 u32 plen = le16_to_cpu(io->ByteCount);
1004
1005 buf = (struct reparse_data_buffer *)((__u8 *)&io->hdr.Protocol +
1006 le32_to_cpu(io->DataOffset));
1007 return parse_reparse_point(buf, plen, cifs_sb, unicode, data);
1008 }
1009
1010 static bool
1011 cifs_is_read_op(__u32 oplock)
1012 {
1013 return oplock == OPLOCK_READ;
1014 }
1015
1016 static unsigned int
1017 cifs_wp_retry_size(struct inode *inode)
1018 {
1019 return CIFS_SB(inode->i_sb)->ctx->wsize;
1020 }
1021
1022 static bool
1023 cifs_dir_needs_close(struct cifsFileInfo *cfile)
1024 {
1025 return !cfile->srch_inf.endOfSearch && !cfile->invalidHandle;
1026 }
1027
1028 static bool
1029 cifs_can_echo(struct TCP_Server_Info *server)
1030 {
1031 if (server->tcpStatus == CifsGood)
1032 return true;
1033
1034 return false;
1035 }
1036
1037 static int
1038 cifs_make_node(unsigned int xid, struct inode *inode,
1039 struct dentry *dentry, struct cifs_tcon *tcon,
1040 const char *full_path, umode_t mode, dev_t dev)
1041 {
1042 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1043 struct inode *newinode = NULL;
1044 int rc;
1045
1046 if (tcon->unix_ext) {
1047 /*
1048 * SMB1 Unix Extensions: requires server support but
1049 * works with all special files
1050 */
1051 struct cifs_unix_set_info_args args = {
1052 .mode = mode & ~current_umask(),
1053 .ctime = NO_CHANGE_64,
1054 .atime = NO_CHANGE_64,
1055 .mtime = NO_CHANGE_64,
1056 .device = dev,
1057 };
1058 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1059 args.uid = current_fsuid();
1060 args.gid = current_fsgid();
1061 } else {
1062 args.uid = INVALID_UID; /* no change */
1063 args.gid = INVALID_GID; /* no change */
1064 }
1065 rc = CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1066 cifs_sb->local_nls,
1067 cifs_remap(cifs_sb));
1068 if (rc)
1069 return rc;
1070
1071 rc = cifs_get_inode_info_unix(&newinode, full_path,
1072 inode->i_sb, xid);
1073
1074 if (rc == 0)
1075 d_instantiate(dentry, newinode);
1076 return rc;
1077 }
1078 /*
1079 * Check if mounted with mount parm 'sfu' mount parm.
1080 * SFU emulation should work with all servers, but only
1081 * supports block and char device (no socket & fifo),
1082 * and was used by default in earlier versions of Windows
1083 */
1084 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
1085 return -EPERM;
1086 return cifs_sfu_make_node(xid, inode, dentry, tcon,
1087 full_path, mode, dev);
1088 }
1089
1090 struct smb_version_operations smb1_operations = {
1091 .send_cancel = send_nt_cancel,
1092 .compare_fids = cifs_compare_fids,
1093 .setup_request = cifs_setup_request,
1094 .setup_async_request = cifs_setup_async_request,
1095 .check_receive = cifs_check_receive,
1096 .add_credits = cifs_add_credits,
1097 .set_credits = cifs_set_credits,
1098 .get_credits_field = cifs_get_credits_field,
1099 .get_credits = cifs_get_credits,
1100 .wait_mtu_credits = cifs_wait_mtu_credits,
1101 .get_next_mid = cifs_get_next_mid,
1102 .read_data_offset = cifs_read_data_offset,
1103 .read_data_length = cifs_read_data_length,
1104 .map_error = map_smb_to_linux_error,
1105 .find_mid = cifs_find_mid,
1106 .check_message = checkSMB,
1107 .dump_detail = cifs_dump_detail,
1108 .clear_stats = cifs_clear_stats,
1109 .print_stats = cifs_print_stats,
1110 .is_oplock_break = is_valid_oplock_break,
1111 .downgrade_oplock = cifs_downgrade_oplock,
1112 .check_trans2 = cifs_check_trans2,
1113 .need_neg = cifs_need_neg,
1114 .negotiate = cifs_negotiate,
1115 .negotiate_wsize = cifs_negotiate_wsize,
1116 .negotiate_rsize = cifs_negotiate_rsize,
1117 .sess_setup = CIFS_SessSetup,
1118 .logoff = CIFSSMBLogoff,
1119 .tree_connect = CIFSTCon,
1120 .tree_disconnect = CIFSSMBTDis,
1121 .get_dfs_refer = CIFSGetDFSRefer,
1122 .qfs_tcon = cifs_qfs_tcon,
1123 .is_path_accessible = cifs_is_path_accessible,
1124 .can_echo = cifs_can_echo,
1125 .query_path_info = cifs_query_path_info,
1126 .query_reparse_point = cifs_query_reparse_point,
1127 .query_file_info = cifs_query_file_info,
1128 .get_srv_inum = cifs_get_srv_inum,
1129 .set_path_size = CIFSSMBSetEOF,
1130 .set_file_size = CIFSSMBSetFileSize,
1131 .set_file_info = smb_set_file_info,
1132 .set_compression = cifs_set_compression,
1133 .echo = CIFSSMBEcho,
1134 .mkdir = CIFSSMBMkDir,
1135 .mkdir_setinfo = cifs_mkdir_setinfo,
1136 .rmdir = CIFSSMBRmDir,
1137 .unlink = CIFSSMBDelFile,
1138 .rename_pending_delete = cifs_rename_pending_delete,
1139 .rename = CIFSSMBRename,
1140 .create_hardlink = CIFSCreateHardLink,
1141 .query_symlink = cifs_query_symlink,
1142 .parse_reparse_point = cifs_parse_reparse_point,
1143 .open = cifs_open_file,
1144 .set_fid = cifs_set_fid,
1145 .close = cifs_close_file,
1146 .flush = cifs_flush_file,
1147 .async_readv = cifs_async_readv,
1148 .async_writev = cifs_async_writev,
1149 .sync_read = cifs_sync_read,
1150 .sync_write = cifs_sync_write,
1151 .query_dir_first = cifs_query_dir_first,
1152 .query_dir_next = cifs_query_dir_next,
1153 .close_dir = cifs_close_dir,
1154 .calc_smb_size = smbCalcSize,
1155 .oplock_response = cifs_oplock_response,
1156 .queryfs = cifs_queryfs,
1157 .mand_lock = cifs_mand_lock,
1158 .mand_unlock_range = cifs_unlock_range,
1159 .push_mand_locks = cifs_push_mandatory_locks,
1160 .query_mf_symlink = cifs_query_mf_symlink,
1161 .create_mf_symlink = cifs_create_mf_symlink,
1162 .is_read_op = cifs_is_read_op,
1163 .wp_retry_size = cifs_wp_retry_size,
1164 .dir_needs_close = cifs_dir_needs_close,
1165 .select_sectype = cifs_select_sectype,
1166 #ifdef CONFIG_CIFS_XATTR
1167 .query_all_EAs = CIFSSMBQAllEAs,
1168 .set_EA = CIFSSMBSetEA,
1169 #endif /* CIFS_XATTR */
1170 .get_acl = get_cifs_acl,
1171 .get_acl_by_fid = get_cifs_acl_by_fid,
1172 .set_acl = set_cifs_acl,
1173 .make_node = cifs_make_node,
1174 };
1175
1176 struct smb_version_values smb1_values = {
1177 .version_string = SMB1_VERSION_STRING,
1178 .protocol_id = SMB10_PROT_ID,
1179 .large_lock_type = LOCKING_ANDX_LARGE_FILES,
1180 .exclusive_lock_type = 0,
1181 .shared_lock_type = LOCKING_ANDX_SHARED_LOCK,
1182 .unlock_lock_type = 0,
1183 .header_preamble_size = 4,
1184 .header_size = sizeof(struct smb_hdr),
1185 .max_header_size = MAX_CIFS_HDR_SIZE,
1186 .read_rsp_size = sizeof(READ_RSP),
1187 .lock_cmd = cpu_to_le16(SMB_COM_LOCKING_ANDX),
1188 .cap_unix = CAP_UNIX,
1189 .cap_nt_find = CAP_NT_SMBS | CAP_NT_FIND,
1190 .cap_large_files = CAP_LARGE_FILES,
1191 .signing_enabled = SECMODE_SIGN_ENABLED,
1192 .signing_required = SECMODE_SIGN_REQUIRED,
1193 };
1194
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.