fs/cifs/misc.c

   1 /*
   2  *   fs/cifs/misc.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2008
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21
  22 #include <linux/slab.h>
  23 #include <linux/ctype.h>
  24 #include <linux/mempool.h>
  25 #include "cifspdu.h"
  26 #include "cifsglob.h"
  27 #include "cifsproto.h"
  28 #include "cifs_debug.h"
  29 #include "smberr.h"
  30 #include "nterr.h"
  31 #include "cifs_unicode.h"
  32
  33 extern mempool_t *cifs_sm_req_poolp;
  34 extern mempool_t *cifs_req_poolp;
  35
  36 /* The xid serves as a useful identifier for each incoming vfs request,
  37    in a similar way to the mid which is useful to track each sent smb,
  38    and CurrentXid can also provide a running counter (although it
  39    will eventually wrap past zero) of the total vfs operations handled
  40    since the cifs fs was mounted */
  41
  42 unsigned int
  43 _GetXid(void)
  44 {
  45         unsigned int xid;
  46
  47         spin_lock(&GlobalMid_Lock);
  48         GlobalTotalActiveXid++;
  49
  50         /* keep high water mark for number of simultaneous ops in filesystem */
  51         if (GlobalTotalActiveXid > GlobalMaxActiveXid)
  52                 GlobalMaxActiveXid = GlobalTotalActiveXid;
  53         if (GlobalTotalActiveXid > 65000)
  54                 cFYI(1, "warning: more than 65000 requests active");
  55         xid = GlobalCurrentXid++;
  56         spin_unlock(&GlobalMid_Lock);
  57         return xid;
  58 }
  59
  60 void
  61 _FreeXid(unsigned int xid)
  62 {
  63         spin_lock(&GlobalMid_Lock);
  64         /* if (GlobalTotalActiveXid == 0)
  65                 BUG(); */
  66         GlobalTotalActiveXid--;
  67         spin_unlock(&GlobalMid_Lock);
  68 }
  69
  70 struct cifs_ses *
  71 sesInfoAlloc(void)
  72 {
  73         struct cifs_ses *ret_buf;
  74
  75         ret_buf = kzalloc(sizeof(struct cifs_ses), GFP_KERNEL);
  76         if (ret_buf) {
  77                 atomic_inc(&sesInfoAllocCount);
  78                 ret_buf->status = CifsNew;
  79                 ++ret_buf->ses_count;
  80                 INIT_LIST_HEAD(&ret_buf->smb_ses_list);
  81                 INIT_LIST_HEAD(&ret_buf->tcon_list);
  82                 mutex_init(&ret_buf->session_mutex);
  83         }
  84         return ret_buf;
  85 }
  86
  87 void
  88 sesInfoFree(struct cifs_ses *buf_to_free)
  89 {
  90         if (buf_to_free == NULL) {
  91                 cFYI(1, "Null buffer passed to sesInfoFree");
  92                 return;
  93         }
  94
  95         atomic_dec(&sesInfoAllocCount);
  96         kfree(buf_to_free->serverOS);
  97         kfree(buf_to_free->serverDomain);
  98         kfree(buf_to_free->serverNOS);
  99         if (buf_to_free->password) {
 100                 memset(buf_to_free->password, 0, strlen(buf_to_free->password));
 101                 kfree(buf_to_free->password);
 102         }
 103         kfree(buf_to_free->user_name);
 104         kfree(buf_to_free->domainName);
 105         kfree(buf_to_free);
 106 }
 107
 108 struct cifs_tcon *
 109 tconInfoAlloc(void)
 110 {
 111         struct cifs_tcon *ret_buf;
 112         ret_buf = kzalloc(sizeof(struct cifs_tcon), GFP_KERNEL);
 113         if (ret_buf) {
 114                 atomic_inc(&tconInfoAllocCount);
 115                 ret_buf->tidStatus = CifsNew;
 116                 ++ret_buf->tc_count;
 117                 INIT_LIST_HEAD(&ret_buf->openFileList);
 118                 INIT_LIST_HEAD(&ret_buf->tcon_list);
 119 #ifdef CONFIG_CIFS_STATS
 120                 spin_lock_init(&ret_buf->stat_lock);
 121 #endif
 122         }
 123         return ret_buf;
 124 }
 125
 126 void
 127 tconInfoFree(struct cifs_tcon *buf_to_free)
 128 {
 129         if (buf_to_free == NULL) {
 130                 cFYI(1, "Null buffer passed to tconInfoFree");
 131                 return;
 132         }
 133         atomic_dec(&tconInfoAllocCount);
 134         kfree(buf_to_free->nativeFileSystem);
 135         if (buf_to_free->password) {
 136                 memset(buf_to_free->password, 0, strlen(buf_to_free->password));
 137                 kfree(buf_to_free->password);
 138         }
 139         kfree(buf_to_free);
 140 }
 141
 142 struct smb_hdr *
 143 cifs_buf_get(void)
 144 {
 145         struct smb_hdr *ret_buf = NULL;
 146
 147 /* We could use negotiated size instead of max_msgsize -
 148    but it may be more efficient to always alloc same size
 149    albeit slightly larger than necessary and maxbuffersize
 150    defaults to this and can not be bigger */
 151         ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
 152
 153         /* clear the first few header bytes */
 154         /* for most paths, more is cleared in header_assemble */
 155         if (ret_buf) {
 156                 memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
 157                 atomic_inc(&bufAllocCount);
 158 #ifdef CONFIG_CIFS_STATS2
 159                 atomic_inc(&totBufAllocCount);
 160 #endif /* CONFIG_CIFS_STATS2 */
 161         }
 162
 163         return ret_buf;
 164 }
 165
 166 void
 167 cifs_buf_release(void *buf_to_free)
 168 {
 169         if (buf_to_free == NULL) {
 170                 /* cFYI(1, "Null buffer passed to cifs_buf_release");*/
 171                 return;
 172         }
 173         mempool_free(buf_to_free, cifs_req_poolp);
 174
 175         atomic_dec(&bufAllocCount);
 176         return;
 177 }
 178
 179 struct smb_hdr *
 180 cifs_small_buf_get(void)
 181 {
 182         struct smb_hdr *ret_buf = NULL;
 183
 184 /* We could use negotiated size instead of max_msgsize -
 185    but it may be more efficient to always alloc same size
 186    albeit slightly larger than necessary and maxbuffersize
 187    defaults to this and can not be bigger */
 188         ret_buf = mempool_alloc(cifs_sm_req_poolp, GFP_NOFS);
 189         if (ret_buf) {
 190         /* No need to clear memory here, cleared in header assemble */
 191         /*      memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
 192                 atomic_inc(&smBufAllocCount);
 193 #ifdef CONFIG_CIFS_STATS2
 194                 atomic_inc(&totSmBufAllocCount);
 195 #endif /* CONFIG_CIFS_STATS2 */
 196
 197         }
 198         return ret_buf;
 199 }
 200
 201 void
 202 cifs_small_buf_release(void *buf_to_free)
 203 {
 204
 205         if (buf_to_free == NULL) {
 206                 cFYI(1, "Null buffer passed to cifs_small_buf_release");
 207                 return;
 208         }
 209         mempool_free(buf_to_free, cifs_sm_req_poolp);
 210
 211         atomic_dec(&smBufAllocCount);
 212         return;
 213 }
 214
 215 /*
 216  * Find a free multiplex id (SMB mid). Otherwise there could be
 217  * mid collisions which might cause problems, demultiplexing the
 218  * wrong response to this request. Multiplex ids could collide if
 219  * one of a series requests takes much longer than the others, or
 220  * if a very large number of long lived requests (byte range
 221  * locks or FindNotify requests) are pending. No more than
 222  * 64K-1 requests can be outstanding at one time. If no
 223  * mids are available, return zero. A future optimization
 224  * could make the combination of mids and uid the key we use
 225  * to demultiplex on (rather than mid alone).
 226  * In addition to the above check, the cifs demultiplex
 227  * code already used the command code as a secondary
 228  * check of the frame and if signing is negotiated the
 229  * response would be discarded if the mid were the same
 230  * but the signature was wrong. Since the mid is not put in the
 231  * pending queue until later (when it is about to be dispatched)
 232  * we do have to limit the number of outstanding requests
 233  * to somewhat less than 64K-1 although it is hard to imagine
 234  * so many threads being in the vfs at one time.
 235  */
 236 __u64 GetNextMid(struct TCP_Server_Info *server)
 237 {
 238         __u64 mid = 0;
 239         __u16 last_mid, cur_mid;
 240         bool collision;
 241
 242         spin_lock(&GlobalMid_Lock);
 243
 244         /* mid is 16 bit only for CIFS/SMB */
 245         cur_mid = (__u16)((server->CurrentMid) & 0xffff);
 246         /* we do not want to loop forever */
 247         last_mid = cur_mid;
 248         cur_mid++;
 249
 250         /*
 251          * This nested loop looks more expensive than it is.
 252          * In practice the list of pending requests is short,
 253          * fewer than 50, and the mids are likely to be unique
 254          * on the first pass through the loop unless some request
 255          * takes longer than the 64 thousand requests before it
 256          * (and it would also have to have been a request that
 257          * did not time out).
 258          */
 259         while (cur_mid != last_mid) {
 260                 struct mid_q_entry *mid_entry;
 261                 unsigned int num_mids;
 262
 263                 collision = false;
 264                 if (cur_mid == 0)
 265                         cur_mid++;
 266
 267                 num_mids = 0;
 268                 list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {
 269                         ++num_mids;
 270                         if (mid_entry->mid == cur_mid &&
 271                             mid_entry->mid_state == MID_REQUEST_SUBMITTED) {
 272                                 /* This mid is in use, try a different one */
 273                                 collision = true;
 274                                 break;
 275                         }
 276                 }
 277
 278                 /*
 279                  * if we have more than 32k mids in the list, then something
 280                  * is very wrong. Possibly a local user is trying to DoS the
 281                  * box by issuing long-running calls and SIGKILL'ing them. If
 282                  * we get to 2^16 mids then we're in big trouble as this
 283                  * function could loop forever.
 284                  *
 285                  * Go ahead and assign out the mid in this situation, but force
 286                  * an eventual reconnect to clean out the pending_mid_q.
 287                  */
 288                 if (num_mids > 32768)
 289                         server->tcpStatus = CifsNeedReconnect;
 290
 291                 if (!collision) {
 292                         mid = (__u64)cur_mid;
 293                         server->CurrentMid = mid;
 294                         break;
 295                 }
 296                 cur_mid++;
 297         }
 298         spin_unlock(&GlobalMid_Lock);
 299         return mid;
 300 }
 301
 302 /* NB: MID can not be set if treeCon not passed in, in that
 303    case it is responsbility of caller to set the mid */
 304 void
 305 header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
 306                 const struct cifs_tcon *treeCon, int word_count
 307                 /* length of fixed section (word count) in two byte units  */)
 308 {
 309         char *temp = (char *) buffer;
 310
 311         memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
 312
 313         buffer->smb_buf_length = cpu_to_be32(
 314             (2 * word_count) + sizeof(struct smb_hdr) -
 315             4 /*  RFC 1001 length field does not count */  +
 316             2 /* for bcc field itself */) ;
 317
 318         buffer->Protocol[0] = 0xFF;
 319         buffer->Protocol[1] = 'S';
 320         buffer->Protocol[2] = 'M';
 321         buffer->Protocol[3] = 'B';
 322         buffer->Command = smb_command;
 323         buffer->Flags = 0x00;   /* case sensitive */
 324         buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
 325         buffer->Pid = cpu_to_le16((__u16)current->tgid);
 326         buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16));
 327         if (treeCon) {
 328                 buffer->Tid = treeCon->tid;
 329                 if (treeCon->ses) {
 330                         if (treeCon->ses->capabilities & CAP_UNICODE)
 331                                 buffer->Flags2 |= SMBFLG2_UNICODE;
 332                         if (treeCon->ses->capabilities & CAP_STATUS32)
 333                                 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
 334
 335                         /* Uid is not converted */
 336                         buffer->Uid = treeCon->ses->Suid;
 337                         buffer->Mid = GetNextMid(treeCon->ses->server);
 338                 }
 339                 if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
 340                         buffer->Flags2 |= SMBFLG2_DFS;
 341                 if (treeCon->nocase)
 342                         buffer->Flags  |= SMBFLG_CASELESS;
 343                 if ((treeCon->ses) && (treeCon->ses->server))
 344                         if (treeCon->ses->server->sec_mode &
 345                           (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 346                                 buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 347         }
 348
 349 /*  endian conversion of flags is now done just before sending */
 350         buffer->WordCount = (char) word_count;
 351         return;
 352 }
 353
 354 static int
 355 check_smb_hdr(struct smb_hdr *smb, __u16 mid)
 356 {
 357         /* does it have the right SMB "signature" ? */
 358         if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff)) {
 359                 cERROR(1, "Bad protocol string signature header 0x%x",
 360                         *(unsigned int *)smb->Protocol);
 361                 return 1;
 362         }
 363
 364         /* Make sure that message ids match */
 365         if (mid != smb->Mid) {
 366                 cERROR(1, "Mids do not match. received=%u expected=%u",
 367                         smb->Mid, mid);
 368                 return 1;
 369         }
 370
 371         /* if it's a response then accept */
 372         if (smb->Flags & SMBFLG_RESPONSE)
 373                 return 0;
 374
 375         /* only one valid case where server sends us request */
 376         if (smb->Command == SMB_COM_LOCKING_ANDX)
 377                 return 0;
 378
 379         cERROR(1, "Server sent request, not response. mid=%u", smb->Mid);
 380         return 1;
 381 }
 382
 383 int
 384 checkSMB(char *buf, unsigned int total_read)
 385 {
 386         struct smb_hdr *smb = (struct smb_hdr *)buf;
 387         __u16 mid = smb->Mid;
 388         __u32 rfclen = be32_to_cpu(smb->smb_buf_length);
 389         __u32 clc_len;  /* calculated length */
 390         cFYI(0, "checkSMB Length: 0x%x, smb_buf_length: 0x%x",
 391                 total_read, rfclen);
 392
 393         /* is this frame too small to even get to a BCC? */
 394         if (total_read < 2 + sizeof(struct smb_hdr)) {
 395                 if ((total_read >= sizeof(struct smb_hdr) - 1)
 396                             && (smb->Status.CifsError != 0)) {
 397                         /* it's an error return */
 398                         smb->WordCount = 0;
 399                         /* some error cases do not return wct and bcc */
 400                         return 0;
 401                 } else if ((total_read == sizeof(struct smb_hdr) + 1) &&
 402                                 (smb->WordCount == 0)) {
 403                         char *tmp = (char *)smb;
 404                         /* Need to work around a bug in two servers here */
 405                         /* First, check if the part of bcc they sent was zero */
 406                         if (tmp[sizeof(struct smb_hdr)] == 0) {
 407                                 /* some servers return only half of bcc
 408                                  * on simple responses (wct, bcc both zero)
 409                                  * in particular have seen this on
 410                                  * ulogoffX and FindClose. This leaves
 411                                  * one byte of bcc potentially unitialized
 412                                  */
 413                                 /* zero rest of bcc */
 414                                 tmp[sizeof(struct smb_hdr)+1] = 0;
 415                                 return 0;
 416                         }
 417                         cERROR(1, "rcvd invalid byte count (bcc)");
 418                 } else {
 419                         cERROR(1, "Length less than smb header size");
 420                 }
 421                 return -EIO;
 422         }
 423
 424         /* otherwise, there is enough to get to the BCC */
 425         if (check_smb_hdr(smb, mid))
 426                 return -EIO;
 427         clc_len = smbCalcSize(smb);
 428
 429         if (4 + rfclen != total_read) {
 430                 cERROR(1, "Length read does not match RFC1001 length %d",
 431                                 rfclen);
 432                 return -EIO;
 433         }
 434
 435         if (4 + rfclen != clc_len) {
 436                 /* check if bcc wrapped around for large read responses */
 437                 if ((rfclen > 64 * 1024) && (rfclen > clc_len)) {
 438                         /* check if lengths match mod 64K */
 439                         if (((4 + rfclen) & 0xFFFF) == (clc_len & 0xFFFF))
 440                                 return 0; /* bcc wrapped */
 441                 }
 442                 cFYI(1, "Calculated size %u vs length %u mismatch for mid=%u",
 443                                 clc_len, 4 + rfclen, smb->Mid);
 444
 445                 if (4 + rfclen < clc_len) {
 446                         cERROR(1, "RFC1001 size %u smaller than SMB for mid=%u",
 447                                         rfclen, smb->Mid);
 448                         return -EIO;
 449                 } else if (rfclen > clc_len + 512) {
 450                         /*
 451                          * Some servers (Windows XP in particular) send more
 452                          * data than the lengths in the SMB packet would
 453                          * indicate on certain calls (byte range locks and
 454                          * trans2 find first calls in particular). While the
 455                          * client can handle such a frame by ignoring the
 456                          * trailing data, we choose limit the amount of extra
 457                          * data to 512 bytes.
 458                          */
 459                         cERROR(1, "RFC1001 size %u more than 512 bytes larger "
 460                                   "than SMB for mid=%u", rfclen, smb->Mid);
 461                         return -EIO;
 462                 }
 463         }
 464         return 0;
 465 }
 466
 467 bool
 468 is_valid_oplock_break(char *buffer, struct TCP_Server_Info *srv)
 469 {
 470         struct smb_hdr *buf = (struct smb_hdr *)buffer;
 471         struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
 472         struct list_head *tmp, *tmp1, *tmp2;
 473         struct cifs_ses *ses;
 474         struct cifs_tcon *tcon;
 475         struct cifsInodeInfo *pCifsInode;
 476         struct cifsFileInfo *netfile;
 477
 478         cFYI(1, "Checking for oplock break or dnotify response");
 479         if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
 480            (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
 481                 struct smb_com_transaction_change_notify_rsp *pSMBr =
 482                         (struct smb_com_transaction_change_notify_rsp *)buf;
 483                 struct file_notify_information *pnotify;
 484                 __u32 data_offset = 0;
 485                 if (get_bcc(buf) > sizeof(struct file_notify_information)) {
 486                         data_offset = le32_to_cpu(pSMBr->DataOffset);
 487
 488                         pnotify = (struct file_notify_information *)
 489                                 ((char *)&pSMBr->hdr.Protocol + data_offset);
 490                         cFYI(1, "dnotify on %s Action: 0x%x",
 491                                  pnotify->FileName, pnotify->Action);
 492                         /*   cifs_dump_mem("Rcvd notify Data: ",buf,
 493                                 sizeof(struct smb_hdr)+60); */
 494                         return true;
 495                 }
 496                 if (pSMBr->hdr.Status.CifsError) {
 497                         cFYI(1, "notify err 0x%d",
 498                                 pSMBr->hdr.Status.CifsError);
 499                         return true;
 500                 }
 501                 return false;
 502         }
 503         if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
 504                 return false;
 505         if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
 506                 /* no sense logging error on invalid handle on oplock
 507                    break - harmless race between close request and oplock
 508                    break response is expected from time to time writing out
 509                    large dirty files cached on the client */
 510                 if ((NT_STATUS_INVALID_HANDLE) ==
 511                    le32_to_cpu(pSMB->hdr.Status.CifsError)) {
 512                         cFYI(1, "invalid handle on oplock break");
 513                         return true;
 514                 } else if (ERRbadfid ==
 515                    le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
 516                         return true;
 517                 } else {
 518                         return false; /* on valid oplock brk we get "request" */
 519                 }
 520         }
 521         if (pSMB->hdr.WordCount != 8)
 522                 return false;
 523
 524         cFYI(1, "oplock type 0x%d level 0x%d",
 525                  pSMB->LockType, pSMB->OplockLevel);
 526         if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
 527                 return false;
 528
 529         /* look up tcon based on tid & uid */
 530         spin_lock(&cifs_tcp_ses_lock);
 531         list_for_each(tmp, &srv->smb_ses_list) {
 532                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 533                 list_for_each(tmp1, &ses->tcon_list) {
 534                         tcon = list_entry(tmp1, struct cifs_tcon, tcon_list);
 535                         if (tcon->tid != buf->Tid)
 536                                 continue;
 537
 538                         cifs_stats_inc(&tcon->num_oplock_brks);
 539                         spin_lock(&cifs_file_list_lock);
 540                         list_for_each(tmp2, &tcon->openFileList) {
 541                                 netfile = list_entry(tmp2, struct cifsFileInfo,
 542                                                      tlist);
 543                                 if (pSMB->Fid != netfile->netfid)
 544                                         continue;
 545
 546                                 cFYI(1, "file id match, oplock break");
 547                                 pCifsInode = CIFS_I(netfile->dentry->d_inode);
 548
 549                                 cifs_set_oplock_level(pCifsInode,
 550                                         pSMB->OplockLevel ? OPLOCK_READ : 0);
 551                                 queue_work(cifsiod_wq,
 552                                            &netfile->oplock_break);
 553                                 netfile->oplock_break_cancelled = false;
 554
 555                                 spin_unlock(&cifs_file_list_lock);
 556                                 spin_unlock(&cifs_tcp_ses_lock);
 557                                 return true;
 558                         }
 559                         spin_unlock(&cifs_file_list_lock);
 560                         spin_unlock(&cifs_tcp_ses_lock);
 561                         cFYI(1, "No matching file for oplock break");
 562                         return true;
 563                 }
 564         }
 565         spin_unlock(&cifs_tcp_ses_lock);
 566         cFYI(1, "Can not process oplock break for non-existent connection");
 567         return true;
 568 }
 569
 570 void
 571 dump_smb(void *buf, int smb_buf_length)
 572 {
 573         int i, j;
 574         char debug_line[17];
 575         unsigned char *buffer = buf;
 576
 577         if (traceSMB == 0)
 578                 return;
 579
 580         for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
 581                 if (i % 8 == 0) {
 582                         /* have reached the beginning of line */
 583                         printk(KERN_DEBUG "| ");
 584                         j = 0;
 585                 }
 586                 printk("%0#4x ", buffer[i]);
 587                 debug_line[2 * j] = ' ';
 588                 if (isprint(buffer[i]))
 589                         debug_line[1 + (2 * j)] = buffer[i];
 590                 else
 591                         debug_line[1 + (2 * j)] = '_';
 592
 593                 if (i % 8 == 7) {
 594                         /* reached end of line, time to print ascii */
 595                         debug_line[16] = 0;
 596                         printk(" | %s\n", debug_line);
 597                 }
 598         }
 599         for (; j < 8; j++) {
 600                 printk("     ");
 601                 debug_line[2 * j] = ' ';
 602                 debug_line[1 + (2 * j)] = ' ';
 603         }
 604         printk(" | %s\n", debug_line);
 605         return;
 606 }
 607
 608 void
 609 cifs_autodisable_serverino(struct cifs_sb_info *cifs_sb)
 610 {
 611         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 612                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
 613                 cERROR(1, "Autodisabling the use of server inode numbers on "
 614                            "%s. This server doesn't seem to support them "
 615                            "properly. Hardlinks will not be recognized on this "
 616                            "mount. Consider mounting with the \"noserverino\" "
 617                            "option to silence this message.",
 618                            cifs_sb_master_tcon(cifs_sb)->treeName);
 619         }
 620 }
 621
 622 void cifs_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock)
 623 {
 624         oplock &= 0xF;
 625
 626         if (oplock == OPLOCK_EXCLUSIVE) {
 627                 cinode->clientCanCacheAll = true;
 628                 cinode->clientCanCacheRead = true;
 629                 cFYI(1, "Exclusive Oplock granted on inode %p",
 630                      &cinode->vfs_inode);
 631         } else if (oplock == OPLOCK_READ) {
 632                 cinode->clientCanCacheAll = false;
 633                 cinode->clientCanCacheRead = true;
 634                 cFYI(1, "Level II Oplock granted on inode %p",
 635                     &cinode->vfs_inode);
 636         } else {
 637                 cinode->clientCanCacheAll = false;
 638                 cinode->clientCanCacheRead = false;
 639         }
 640 }
 641
 642 bool
 643 backup_cred(struct cifs_sb_info *cifs_sb)
 644 {
 645         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPUID) {
 646                 if (cifs_sb->mnt_backupuid == current_fsuid())
 647                         return true;
 648         }
 649         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_BACKUPGID) {
 650                 if (in_group_p(cifs_sb->mnt_backupgid))
 651                         return true;
 652         }
 653
 654         return false;
 655 }