2021-06-18 13:31:49 +08:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1 */
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
*
|
2008-01-25 18:12:41 +08:00
|
|
|
* Copyright (c) International Business Machines Corp., 2002,2008
|
2005-04-17 06:20:36 +08:00
|
|
|
* Author(s): Steve French (sfrench@us.ibm.com)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#ifndef _CIFSPROTO_H
|
|
|
|
#define _CIFSPROTO_H
|
|
|
|
#include <linux/nls.h>
|
2023-04-24 10:26:51 +08:00
|
|
|
#include <linux/ctype.h>
|
2018-05-19 15:28:53 +08:00
|
|
|
#include "trace.h"
|
2018-11-15 02:24:03 +08:00
|
|
|
#ifdef CONFIG_CIFS_DFS_UPCALL
|
|
|
|
#include "dfs_cache.h"
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
struct statfs;
|
2012-09-19 07:20:34 +08:00
|
|
|
struct smb_rqst;
|
2020-12-10 13:07:12 +08:00
|
|
|
struct smb3_fs_context;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
*****************************************************************
|
|
|
|
* All Prototypes
|
|
|
|
*****************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
extern struct smb_hdr *cifs_buf_get(void);
|
|
|
|
extern void cifs_buf_release(void *);
|
|
|
|
extern struct smb_hdr *cifs_small_buf_get(void);
|
|
|
|
extern void cifs_small_buf_release(void *);
|
2014-06-16 22:35:24 +08:00
|
|
|
extern void free_rsp_buf(int, void *);
|
2008-12-31 01:39:16 +08:00
|
|
|
extern int smb_send(struct TCP_Server_Info *, struct smb_hdr *,
|
|
|
|
unsigned int /* length */);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern unsigned int _get_xid(void);
|
|
|
|
extern void _free_xid(unsigned int);
|
2020-04-15 13:42:53 +08:00
|
|
|
#define get_xid() \
|
|
|
|
({ \
|
2012-06-20 15:21:16 +08:00
|
|
|
unsigned int __xid = _get_xid(); \
|
2020-04-15 13:42:53 +08:00
|
|
|
cifs_dbg(FYI, "VFS: in %s as Xid: %u with uid: %d\n", \
|
2013-05-05 11:12:25 +08:00
|
|
|
__func__, __xid, \
|
|
|
|
from_kuid(&init_user_ns, current_fsuid())); \
|
2020-04-15 13:42:53 +08:00
|
|
|
trace_smb3_enter(__xid, __func__); \
|
|
|
|
__xid; \
|
2010-04-21 11:50:45 +08:00
|
|
|
})
|
|
|
|
|
2020-04-15 13:42:53 +08:00
|
|
|
#define free_xid(curr_xid) \
|
|
|
|
do { \
|
|
|
|
_free_xid(curr_xid); \
|
|
|
|
cifs_dbg(FYI, "VFS: leaving %s (xid = %u) rc = %d\n", \
|
|
|
|
__func__, curr_xid, (int)rc); \
|
|
|
|
if (rc) \
|
2018-05-19 15:28:53 +08:00
|
|
|
trace_smb3_exit_err(curr_xid, __func__, (int)rc); \
|
2020-04-15 13:42:53 +08:00
|
|
|
else \
|
|
|
|
trace_smb3_exit_done(curr_xid, __func__); \
|
2010-04-21 11:50:45 +08:00
|
|
|
} while (0)
|
2011-04-28 12:34:35 +08:00
|
|
|
extern int init_cifs_idmap(void);
|
|
|
|
extern void exit_cifs_idmap(void);
|
2016-05-18 07:20:13 +08:00
|
|
|
extern int init_cifs_spnego(void);
|
|
|
|
extern void exit_cifs_spnego(void);
|
2021-03-06 06:36:04 +08:00
|
|
|
extern const char *build_path_from_dentry(struct dentry *, void *);
|
2022-12-19 01:37:32 +08:00
|
|
|
char *__build_path_from_dentry_optional_prefix(struct dentry *direntry, void *page,
|
|
|
|
const char *tree, int tree_len,
|
|
|
|
bool prefix);
|
2017-02-13 23:14:17 +08:00
|
|
|
extern char *build_path_from_dentry_optional_prefix(struct dentry *direntry,
|
2021-03-06 06:36:04 +08:00
|
|
|
void *page, bool prefix);
|
|
|
|
static inline void *alloc_dentry_path(void)
|
|
|
|
{
|
|
|
|
return __getname();
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void free_dentry_path(void *page)
|
|
|
|
{
|
|
|
|
if (page)
|
|
|
|
__putname(page);
|
|
|
|
}
|
|
|
|
|
2020-12-10 13:07:12 +08:00
|
|
|
extern char *cifs_build_path_to_root(struct smb3_fs_context *ctx,
|
2012-11-29 12:34:41 +08:00
|
|
|
struct cifs_sb_info *cifs_sb,
|
2016-12-15 15:01:19 +08:00
|
|
|
struct cifs_tcon *tcon,
|
|
|
|
int add_treename);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern char *build_wildcard_path_from_dentry(struct dentry *direntry);
|
2022-10-05 05:41:27 +08:00
|
|
|
char *cifs_build_devname(char *nodename, const char *prepath);
|
2022-08-05 22:47:38 +08:00
|
|
|
extern void delete_mid(struct mid_q_entry *mid);
|
|
|
|
extern void release_mid(struct mid_q_entry *mid);
|
2011-12-27 02:53:34 +08:00
|
|
|
extern void cifs_wake_up_task(struct mid_q_entry *mid);
|
2016-11-18 07:24:46 +08:00
|
|
|
extern int cifs_handle_standard(struct TCP_Server_Info *server,
|
|
|
|
struct mid_q_entry *mid);
|
2023-06-28 08:24:47 +08:00
|
|
|
extern char *smb3_fs_context_fullpath(const struct smb3_fs_context *ctx,
|
|
|
|
char dirsep);
|
2020-11-05 11:58:14 +08:00
|
|
|
extern int smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx);
|
2021-01-29 11:35:10 +08:00
|
|
|
extern int smb3_parse_opt(const char *options, const char *key, char **val);
|
2023-06-10 01:46:59 +08:00
|
|
|
extern int cifs_ipaddr_cmp(struct sockaddr *srcaddr, struct sockaddr *rhs);
|
2020-05-20 02:38:28 +08:00
|
|
|
extern bool cifs_match_ipaddr(struct sockaddr *srcaddr, struct sockaddr *rhs);
|
2017-04-11 01:31:33 +08:00
|
|
|
extern int cifs_discard_remaining_data(struct TCP_Server_Info *server);
|
2012-09-19 07:20:35 +08:00
|
|
|
extern int cifs_call_async(struct TCP_Server_Info *server,
|
|
|
|
struct smb_rqst *rqst,
|
|
|
|
mid_receive_t *receive, mid_callback_t *callback,
|
2019-01-16 07:52:29 +08:00
|
|
|
mid_handle_t *handle, void *cbdata, const int flags,
|
|
|
|
const struct cifs_credits *exist_credits);
|
2020-04-22 21:58:57 +08:00
|
|
|
extern struct TCP_Server_Info *cifs_pick_channel(struct cifs_ses *ses);
|
2016-11-24 07:31:54 +08:00
|
|
|
extern int cifs_send_recv(const unsigned int xid, struct cifs_ses *ses,
|
2020-06-01 01:38:22 +08:00
|
|
|
struct TCP_Server_Info *server,
|
2016-11-24 07:31:54 +08:00
|
|
|
struct smb_rqst *rqst, int *resp_buf_type,
|
|
|
|
const int flags, struct kvec *resp_iov);
|
2018-08-01 07:26:13 +08:00
|
|
|
extern int compound_send_recv(const unsigned int xid, struct cifs_ses *ses,
|
2020-06-01 01:38:22 +08:00
|
|
|
struct TCP_Server_Info *server,
|
2018-08-01 07:26:13 +08:00
|
|
|
const int flags, const int num_rqst,
|
|
|
|
struct smb_rqst *rqst, int *resp_buf_type,
|
|
|
|
struct kvec *resp_iov);
|
2011-05-27 12:34:02 +08:00
|
|
|
extern int SendReceive(const unsigned int /* xid */ , struct cifs_ses *,
|
2005-04-17 06:20:36 +08:00
|
|
|
struct smb_hdr * /* input */ ,
|
|
|
|
struct smb_hdr * /* out */ ,
|
2012-05-23 20:14:34 +08:00
|
|
|
int * /* bytes returned */ , const int);
|
2011-05-27 12:34:02 +08:00
|
|
|
extern int SendReceiveNoRsp(const unsigned int xid, struct cifs_ses *ses,
|
2012-03-24 02:28:02 +08:00
|
|
|
char *in_buf, int flags);
|
2012-09-19 07:20:35 +08:00
|
|
|
extern struct mid_q_entry *cifs_setup_request(struct cifs_ses *,
|
2019-09-20 12:08:34 +08:00
|
|
|
struct TCP_Server_Info *,
|
2012-09-19 07:20:35 +08:00
|
|
|
struct smb_rqst *);
|
|
|
|
extern struct mid_q_entry *cifs_setup_async_request(struct TCP_Server_Info *,
|
|
|
|
struct smb_rqst *);
|
2011-05-20 04:22:52 +08:00
|
|
|
extern int cifs_check_receive(struct mid_q_entry *mid,
|
|
|
|
struct TCP_Server_Info *server, bool log_error);
|
2014-06-05 23:03:27 +08:00
|
|
|
extern int cifs_wait_mtu_credits(struct TCP_Server_Info *server,
|
|
|
|
unsigned int size, unsigned int *num,
|
2019-01-17 03:12:41 +08:00
|
|
|
struct cifs_credits *credits);
|
2011-05-27 12:34:02 +08:00
|
|
|
extern int SendReceive2(const unsigned int /* xid */ , struct cifs_ses *,
|
2007-06-29 03:44:13 +08:00
|
|
|
struct kvec *, int /* nvec to send */,
|
2016-10-26 02:38:47 +08:00
|
|
|
int * /* type of buf returned */, const int flags,
|
|
|
|
struct kvec * /* resp vec */);
|
2008-02-08 07:25:02 +08:00
|
|
|
extern int SendReceiveBlockingLock(const unsigned int xid,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_tcon *ptcon,
|
2022-12-10 06:55:51 +08:00
|
|
|
struct smb_hdr *in_buf,
|
2008-02-08 07:25:02 +08:00
|
|
|
struct smb_hdr *out_buf,
|
|
|
|
int *bytes_returned);
|
2022-01-17 15:15:02 +08:00
|
|
|
void
|
2022-02-15 21:55:40 +08:00
|
|
|
cifs_signal_cifsd_for_reconnect(struct TCP_Server_Info *server,
|
|
|
|
bool all_channels);
|
|
|
|
void
|
2022-01-17 15:15:02 +08:00
|
|
|
cifs_mark_tcp_ses_conns_for_reconnect(struct TCP_Server_Info *server,
|
|
|
|
bool mark_smb_session);
|
2021-07-19 22:14:46 +08:00
|
|
|
extern int cifs_reconnect(struct TCP_Server_Info *server,
|
|
|
|
bool mark_smb_session);
|
2015-12-19 03:05:30 +08:00
|
|
|
extern int checkSMB(char *buf, unsigned int len, struct TCP_Server_Info *srvr);
|
2012-03-24 02:28:02 +08:00
|
|
|
extern bool is_valid_oplock_break(char *, struct TCP_Server_Info *);
|
2011-09-26 22:56:44 +08:00
|
|
|
extern bool backup_cred(struct cifs_sb_info *);
|
2008-04-29 08:06:05 +08:00
|
|
|
extern bool is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
|
2011-01-25 03:16:35 +08:00
|
|
|
extern void cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
|
|
|
|
unsigned int bytes_written);
|
cifs: fix rename() by ensuring source handle opened with DELETE bit
To rename a file in SMB2 we open it with the DELETE access and do a
special SetInfo on it. If the handle is missing the DELETE bit the
server will fail the SetInfo with STATUS_ACCESS_DENIED.
We currently try to reuse any existing opened handle we have with
cifs_get_writable_path(). That function looks for handles with WRITE
access but doesn't check for DELETE, making rename() fail if it finds
a handle to reuse. Simple reproducer below.
To select handles with the DELETE bit, this patch adds a flag argument
to cifs_get_writable_path() and find_writable_file() and the existing
'bool fsuid_only' argument is converted to a flag.
The cifsFileInfo struct only stores the UNIX open mode but not the
original SMB access flags. Since the DELETE bit is not mapped in that
mode, this patch stores the access mask in cifs_fid on file open,
which is accessible from cifsFileInfo.
Simple reproducer:
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define E(s) perror(s), exit(1)
int main(int argc, char *argv[])
{
int fd, ret;
if (argc != 3) {
fprintf(stderr, "Usage: %s A B\n"
"create&open A in write mode, "
"rename A to B, close A\n", argv[0]);
return 0;
}
fd = openat(AT_FDCWD, argv[1], O_WRONLY|O_CREAT|O_SYNC, 0666);
if (fd == -1) E("openat()");
ret = rename(argv[1], argv[2]);
if (ret) E("rename()");
ret = close(fd);
if (ret) E("close()");
return ret;
}
$ gcc -o bugrename bugrename.c
$ ./bugrename /mnt/a /mnt/b
rename(): Permission denied
Fixes: 8de9e86c67ba ("cifs: create a helper to find a writeable handle by path name")
CC: Stable <stable@vger.kernel.org>
Signed-off-by: Aurelien Aptel <aaptel@suse.com>
Signed-off-by: Steve French <stfrench@microsoft.com>
Reviewed-by: Pavel Shilovsky <pshilov@microsoft.com>
Reviewed-by: Paulo Alcantara (SUSE) <pc@cjr.nz>
2020-02-21 18:19:06 +08:00
|
|
|
extern struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *, int);
|
2019-01-30 04:15:11 +08:00
|
|
|
extern int cifs_get_writable_file(struct cifsInodeInfo *cifs_inode,
|
cifs: fix rename() by ensuring source handle opened with DELETE bit
To rename a file in SMB2 we open it with the DELETE access and do a
special SetInfo on it. If the handle is missing the DELETE bit the
server will fail the SetInfo with STATUS_ACCESS_DENIED.
We currently try to reuse any existing opened handle we have with
cifs_get_writable_path(). That function looks for handles with WRITE
access but doesn't check for DELETE, making rename() fail if it finds
a handle to reuse. Simple reproducer below.
To select handles with the DELETE bit, this patch adds a flag argument
to cifs_get_writable_path() and find_writable_file() and the existing
'bool fsuid_only' argument is converted to a flag.
The cifsFileInfo struct only stores the UNIX open mode but not the
original SMB access flags. Since the DELETE bit is not mapped in that
mode, this patch stores the access mask in cifs_fid on file open,
which is accessible from cifsFileInfo.
Simple reproducer:
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define E(s) perror(s), exit(1)
int main(int argc, char *argv[])
{
int fd, ret;
if (argc != 3) {
fprintf(stderr, "Usage: %s A B\n"
"create&open A in write mode, "
"rename A to B, close A\n", argv[0]);
return 0;
}
fd = openat(AT_FDCWD, argv[1], O_WRONLY|O_CREAT|O_SYNC, 0666);
if (fd == -1) E("openat()");
ret = rename(argv[1], argv[2]);
if (ret) E("rename()");
ret = close(fd);
if (ret) E("close()");
return ret;
}
$ gcc -o bugrename bugrename.c
$ ./bugrename /mnt/a /mnt/b
rename(): Permission denied
Fixes: 8de9e86c67ba ("cifs: create a helper to find a writeable handle by path name")
CC: Stable <stable@vger.kernel.org>
Signed-off-by: Aurelien Aptel <aaptel@suse.com>
Signed-off-by: Steve French <stfrench@microsoft.com>
Reviewed-by: Pavel Shilovsky <pshilov@microsoft.com>
Reviewed-by: Paulo Alcantara (SUSE) <pc@cjr.nz>
2020-02-21 18:19:06 +08:00
|
|
|
int flags,
|
2019-01-30 04:15:11 +08:00
|
|
|
struct cifsFileInfo **ret_file);
|
2019-08-30 06:25:46 +08:00
|
|
|
extern int cifs_get_writable_path(struct cifs_tcon *tcon, const char *name,
|
cifs: fix rename() by ensuring source handle opened with DELETE bit
To rename a file in SMB2 we open it with the DELETE access and do a
special SetInfo on it. If the handle is missing the DELETE bit the
server will fail the SetInfo with STATUS_ACCESS_DENIED.
We currently try to reuse any existing opened handle we have with
cifs_get_writable_path(). That function looks for handles with WRITE
access but doesn't check for DELETE, making rename() fail if it finds
a handle to reuse. Simple reproducer below.
To select handles with the DELETE bit, this patch adds a flag argument
to cifs_get_writable_path() and find_writable_file() and the existing
'bool fsuid_only' argument is converted to a flag.
The cifsFileInfo struct only stores the UNIX open mode but not the
original SMB access flags. Since the DELETE bit is not mapped in that
mode, this patch stores the access mask in cifs_fid on file open,
which is accessible from cifsFileInfo.
Simple reproducer:
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define E(s) perror(s), exit(1)
int main(int argc, char *argv[])
{
int fd, ret;
if (argc != 3) {
fprintf(stderr, "Usage: %s A B\n"
"create&open A in write mode, "
"rename A to B, close A\n", argv[0]);
return 0;
}
fd = openat(AT_FDCWD, argv[1], O_WRONLY|O_CREAT|O_SYNC, 0666);
if (fd == -1) E("openat()");
ret = rename(argv[1], argv[2]);
if (ret) E("rename()");
ret = close(fd);
if (ret) E("close()");
return ret;
}
$ gcc -o bugrename bugrename.c
$ ./bugrename /mnt/a /mnt/b
rename(): Permission denied
Fixes: 8de9e86c67ba ("cifs: create a helper to find a writeable handle by path name")
CC: Stable <stable@vger.kernel.org>
Signed-off-by: Aurelien Aptel <aaptel@suse.com>
Signed-off-by: Steve French <stfrench@microsoft.com>
Reviewed-by: Pavel Shilovsky <pshilov@microsoft.com>
Reviewed-by: Paulo Alcantara (SUSE) <pc@cjr.nz>
2020-02-21 18:19:06 +08:00
|
|
|
int flags,
|
2019-08-30 06:25:46 +08:00
|
|
|
struct cifsFileInfo **ret_file);
|
2010-09-30 07:51:11 +08:00
|
|
|
extern struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *, bool);
|
2019-09-09 13:30:00 +08:00
|
|
|
extern int cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,
|
|
|
|
struct cifsFileInfo **ret_file);
|
2022-08-18 01:14:02 +08:00
|
|
|
extern unsigned int smbCalcSize(void *buf);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern int decode_negTokenInit(unsigned char *security_blob, int length,
|
2010-04-24 19:57:49 +08:00
|
|
|
struct TCP_Server_Info *server);
|
2010-07-23 01:33:01 +08:00
|
|
|
extern int cifs_convert_address(struct sockaddr *dst, const char *src, int len);
|
2012-11-27 00:09:55 +08:00
|
|
|
extern void cifs_set_port(struct sockaddr *addr, const unsigned short int port);
|
2012-03-24 02:28:03 +08:00
|
|
|
extern int map_smb_to_linux_error(char *buf, bool logErr);
|
2020-07-03 17:29:32 +08:00
|
|
|
extern int map_and_check_smb_error(struct mid_q_entry *mid, bool logErr);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void header_assemble(struct smb_hdr *, char /* command */ ,
|
2011-05-27 12:34:02 +08:00
|
|
|
const struct cifs_tcon *, int /* length of
|
2005-08-18 03:38:22 +08:00
|
|
|
fixed section (word count) in two byte units */);
|
2006-02-14 09:36:20 +08:00
|
|
|
extern int small_smb_init_no_tc(const int smb_cmd, const int wct,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_ses *ses,
|
2007-07-13 08:33:32 +08:00
|
|
|
void **request_buf);
|
2013-06-13 08:52:14 +08:00
|
|
|
extern enum securityEnum select_sectype(struct TCP_Server_Info *server,
|
|
|
|
enum securityEnum requested);
|
2012-05-25 14:54:49 +08:00
|
|
|
extern int CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
|
2021-07-19 21:54:16 +08:00
|
|
|
struct TCP_Server_Info *server,
|
2012-05-25 14:54:49 +08:00
|
|
|
const struct nls_table *nls_cp);
|
2018-06-19 23:27:58 +08:00
|
|
|
extern struct timespec64 cifs_NTtimeToUnix(__le64 utc_nanoseconds_since_1601);
|
|
|
|
extern u64 cifs_UnixTimeToNT(struct timespec64);
|
|
|
|
extern struct timespec64 cnvrtDosUnixTm(__le16 le_date, __le16 le_time,
|
2009-05-27 21:37:33 +08:00
|
|
|
int offset);
|
2010-11-03 15:58:57 +08:00
|
|
|
extern void cifs_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock);
|
2014-03-12 00:11:47 +08:00
|
|
|
extern int cifs_get_writer(struct cifsInodeInfo *cinode);
|
|
|
|
extern void cifs_put_writer(struct cifsInodeInfo *cinode);
|
|
|
|
extern void cifs_done_oplock_break(struct cifsInodeInfo *cinode);
|
2012-09-19 21:22:43 +08:00
|
|
|
extern int cifs_unlock_range(struct cifsFileInfo *cfile,
|
|
|
|
struct file_lock *flock, const unsigned int xid);
|
|
|
|
extern int cifs_push_mandatory_locks(struct cifsFileInfo *cfile);
|
2006-09-28 11:35:57 +08:00
|
|
|
|
2019-10-23 17:02:33 +08:00
|
|
|
extern void cifs_down_write(struct rw_semaphore *sem);
|
2022-10-04 05:43:50 +08:00
|
|
|
struct cifsFileInfo *cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
|
|
|
|
struct tcon_link *tlink, __u32 oplock,
|
|
|
|
const char *symlink_target);
|
2021-03-19 03:44:05 +08:00
|
|
|
extern int cifs_posix_open(const char *full_path, struct inode **inode,
|
2012-06-20 15:21:16 +08:00
|
|
|
struct super_block *sb, int mode,
|
|
|
|
unsigned int f_flags, __u32 *oplock, __u16 *netfid,
|
|
|
|
unsigned int xid);
|
2010-05-17 19:18:58 +08:00
|
|
|
void cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr);
|
2009-06-25 12:56:52 +08:00
|
|
|
extern void cifs_unix_basic_to_fattr(struct cifs_fattr *fattr,
|
|
|
|
FILE_UNIX_BASIC_INFO *info,
|
|
|
|
struct cifs_sb_info *cifs_sb);
|
2012-09-29 01:21:14 +08:00
|
|
|
extern void cifs_dir_info_to_fattr(struct cifs_fattr *, FILE_DIRECTORY_INFO *,
|
|
|
|
struct cifs_sb_info *);
|
2021-02-11 10:23:04 +08:00
|
|
|
extern int cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr);
|
2009-06-25 12:56:52 +08:00
|
|
|
extern struct inode *cifs_iget(struct super_block *sb,
|
|
|
|
struct cifs_fattr *fattr);
|
|
|
|
|
2022-10-04 05:43:50 +08:00
|
|
|
int cifs_get_inode_info(struct inode **inode, const char *full_path,
|
|
|
|
struct cifs_open_info_data *data, struct super_block *sb, int xid,
|
|
|
|
const struct cifs_fid *fid);
|
2023-08-17 23:34:06 +08:00
|
|
|
bool cifs_reparse_point_to_fattr(struct cifs_sb_info *cifs_sb,
|
|
|
|
struct cifs_fattr *fattr,
|
|
|
|
u32 tag);
|
2020-06-12 08:25:47 +08:00
|
|
|
extern int smb311_posix_get_inode_info(struct inode **pinode, const char *search_path,
|
|
|
|
struct super_block *sb, unsigned int xid);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern int cifs_get_inode_info_unix(struct inode **pinode,
|
|
|
|
const unsigned char *search_path,
|
2012-06-20 15:21:16 +08:00
|
|
|
struct super_block *sb, unsigned int xid);
|
2012-09-19 07:20:25 +08:00
|
|
|
extern int cifs_set_file_info(struct inode *inode, struct iattr *attrs,
|
2021-03-19 03:44:05 +08:00
|
|
|
unsigned int xid, const char *full_path, __u32 dosattr);
|
2012-09-19 07:20:25 +08:00
|
|
|
extern int cifs_rename_pending_delete(const char *full_path,
|
|
|
|
struct dentry *dentry,
|
|
|
|
const unsigned int xid);
|
2020-10-20 15:02:02 +08:00
|
|
|
extern int sid_to_id(struct cifs_sb_info *cifs_sb, struct cifs_sid *psid,
|
|
|
|
struct cifs_fattr *fattr, uint sidtype);
|
2010-11-10 21:50:35 +08:00
|
|
|
extern int cifs_acl_to_fattr(struct cifs_sb_info *cifs_sb,
|
2009-07-09 13:46:37 +08:00
|
|
|
struct cifs_fattr *fattr, struct inode *inode,
|
2019-07-19 14:30:07 +08:00
|
|
|
bool get_mode_from_special_sid,
|
2014-02-11 04:08:16 +08:00
|
|
|
const char *path, const struct cifs_fid *pfid);
|
cifs: Fix unix perm bits to cifsacl conversion for "other" bits.
With the "cifsacl" mount option, the mode bits set on the file/dir
is converted to corresponding ACEs in DACL. However, only the
ALLOWED ACEs were being set for "owner" and "group" SIDs. Since
owner is a subset of group, and group is a subset of
everyone/world SID, in order to properly emulate unix perm groups,
we need to add DENIED ACEs. If we don't do that, "owner" and "group"
SIDs could get more access rights than they should. Which is what
was happening. This fixes it.
We try to keep the "preferred" order of ACEs, i.e. DENYs followed
by ALLOWs. However, for a small subset of cases we cannot
maintain the preferred order. In that case, we'll end up with the
DENY ACE for group after the ALLOW for the owner.
If owner SID == group SID, use the more restrictive
among the two perm bits and convert them to ACEs.
Also, for reverse mapping, i.e. to convert ACL to unix perm bits,
for the "others" bits, we needed to add the masked bits of the
owner and group masks to others mask.
Updated version of patch fixes a problem noted by the kernel
test robot.
Reported-by: kernel test robot <lkp@intel.com>
Signed-off-by: Shyam Prasad N <sprasad@microsoft.com>
Signed-off-by: Steve French <stfrench@microsoft.com>
2020-08-17 18:23:12 +08:00
|
|
|
extern int id_mode_to_cifs_acl(struct inode *inode, const char *path, __u64 *pnmode,
|
|
|
|
kuid_t uid, kgid_t gid);
|
2010-11-28 01:37:54 +08:00
|
|
|
extern struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *, struct inode *,
|
2020-12-19 01:30:12 +08:00
|
|
|
const char *, u32 *, u32);
|
2014-02-11 04:08:16 +08:00
|
|
|
extern struct cifs_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *,
|
2020-12-19 01:30:12 +08:00
|
|
|
const struct cifs_fid *, u32 *, u32);
|
2023-01-13 19:49:19 +08:00
|
|
|
extern struct posix_acl *cifs_get_acl(struct mnt_idmap *idmap,
|
2022-09-22 23:17:02 +08:00
|
|
|
struct dentry *dentry, int type);
|
2023-01-13 19:49:20 +08:00
|
|
|
extern int cifs_set_acl(struct mnt_idmap *idmap,
|
2022-09-22 23:17:03 +08:00
|
|
|
struct dentry *dentry, struct posix_acl *acl, int type);
|
2011-04-20 02:27:10 +08:00
|
|
|
extern int set_cifs_acl(struct cifs_ntsd *, __u32, struct inode *,
|
2011-10-13 23:26:03 +08:00
|
|
|
const char *, int);
|
2020-01-17 09:55:33 +08:00
|
|
|
extern unsigned int setup_authusers_ACE(struct cifs_ace *pace);
|
2019-12-06 16:02:38 +08:00
|
|
|
extern unsigned int setup_special_mode_ACE(struct cifs_ace *pace, __u64 nmode);
|
2020-06-12 22:25:21 +08:00
|
|
|
extern unsigned int setup_special_user_owner_ACE(struct cifs_ace *pace);
|
2007-10-31 12:54:42 +08:00
|
|
|
|
2011-10-20 03:30:07 +08:00
|
|
|
extern void dequeue_mid(struct mid_q_entry *mid, bool malformed);
|
|
|
|
extern int cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
|
2016-01-10 08:54:50 +08:00
|
|
|
unsigned int to_read);
|
2021-02-04 14:15:21 +08:00
|
|
|
extern ssize_t cifs_discard_from_socket(struct TCP_Server_Info *server,
|
|
|
|
size_t to_read);
|
2016-01-10 08:54:50 +08:00
|
|
|
extern int cifs_read_page_from_socket(struct TCP_Server_Info *server,
|
2018-05-31 03:47:55 +08:00
|
|
|
struct page *page,
|
|
|
|
unsigned int page_offset,
|
|
|
|
unsigned int to_read);
|
2022-04-07 04:09:08 +08:00
|
|
|
int cifs_read_iter_from_socket(struct TCP_Server_Info *server,
|
|
|
|
struct iov_iter *iter,
|
|
|
|
unsigned int to_read);
|
2020-12-14 14:40:24 +08:00
|
|
|
extern int cifs_setup_cifs_sb(struct cifs_sb_info *cifs_sb);
|
2022-11-18 00:23:49 +08:00
|
|
|
void cifs_mount_put_conns(struct cifs_mount_ctx *mnt_ctx);
|
2022-10-12 05:16:07 +08:00
|
|
|
int cifs_mount_get_session(struct cifs_mount_ctx *mnt_ctx);
|
2022-11-18 00:23:49 +08:00
|
|
|
int cifs_is_path_remote(struct cifs_mount_ctx *mnt_ctx);
|
2022-10-12 05:16:07 +08:00
|
|
|
int cifs_mount_get_tcon(struct cifs_mount_ctx *mnt_ctx);
|
2011-05-05 17:55:12 +08:00
|
|
|
extern int cifs_match_super(struct super_block *, void *);
|
2020-12-10 13:07:12 +08:00
|
|
|
extern int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb3_fs_context *ctx);
|
2011-06-17 21:27:16 +08:00
|
|
|
extern void cifs_umount(struct cifs_sb_info *);
|
2011-12-27 20:23:34 +08:00
|
|
|
extern void cifs_mark_open_files_invalid(struct cifs_tcon *tcon);
|
2016-09-23 08:23:56 +08:00
|
|
|
extern void cifs_reopen_persistent_handles(struct cifs_tcon *tcon);
|
|
|
|
|
2012-09-19 21:22:44 +08:00
|
|
|
extern bool cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
|
2018-10-04 07:24:38 +08:00
|
|
|
__u64 length, __u8 type, __u16 flags,
|
2012-09-19 21:22:44 +08:00
|
|
|
struct cifsLockInfo **conf_lock,
|
2012-11-27 22:38:53 +08:00
|
|
|
int rw_check);
|
2012-09-19 21:22:45 +08:00
|
|
|
extern void cifs_add_pending_open(struct cifs_fid *fid,
|
|
|
|
struct tcon_link *tlink,
|
|
|
|
struct cifs_pending_open *open);
|
|
|
|
extern void cifs_add_pending_open_locked(struct cifs_fid *fid,
|
|
|
|
struct tcon_link *tlink,
|
|
|
|
struct cifs_pending_open *open);
|
|
|
|
extern void cifs_del_pending_open(struct cifs_pending_open *open);
|
2021-04-13 13:26:42 +08:00
|
|
|
|
|
|
|
extern bool cifs_is_deferred_close(struct cifsFileInfo *cfile,
|
|
|
|
struct cifs_deferred_close **dclose);
|
|
|
|
|
|
|
|
extern void cifs_add_deferred_close(struct cifsFileInfo *cfile,
|
|
|
|
struct cifs_deferred_close *dclose);
|
|
|
|
|
|
|
|
extern void cifs_del_deferred_close(struct cifsFileInfo *cfile);
|
|
|
|
|
|
|
|
extern void cifs_close_deferred_file(struct cifsInodeInfo *cifs_inode);
|
|
|
|
|
2021-04-20 03:02:03 +08:00
|
|
|
extern void cifs_close_all_deferred_files(struct cifs_tcon *cifs_tcon);
|
|
|
|
|
2021-09-18 02:14:26 +08:00
|
|
|
extern void cifs_close_deferred_file_under_dentry(struct cifs_tcon *cifs_tcon,
|
|
|
|
const char *path);
|
2021-07-19 19:26:24 +08:00
|
|
|
extern struct TCP_Server_Info *
|
|
|
|
cifs_get_tcp_session(struct smb3_fs_context *ctx,
|
|
|
|
struct TCP_Server_Info *primary_server);
|
2016-11-05 02:50:31 +08:00
|
|
|
extern void cifs_put_tcp_session(struct TCP_Server_Info *server,
|
|
|
|
int from_reconnect);
|
|
|
|
extern void cifs_put_tcon(struct cifs_tcon *tcon);
|
2012-03-21 18:27:54 +08:00
|
|
|
|
2023-08-17 23:34:04 +08:00
|
|
|
extern void cifs_release_automount_timer(void);
|
2012-03-21 18:27:54 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void cifs_proc_init(void);
|
|
|
|
void cifs_proc_clean(void);
|
|
|
|
|
2012-09-19 21:22:43 +08:00
|
|
|
extern void cifs_move_llist(struct list_head *source, struct list_head *dest);
|
|
|
|
extern void cifs_free_llist(struct list_head *llist);
|
|
|
|
extern void cifs_del_lock_waiters(struct cifsLockInfo *lock);
|
|
|
|
|
2020-07-21 20:36:38 +08:00
|
|
|
extern int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
const struct nls_table *nlsc);
|
|
|
|
|
2012-05-25 14:43:58 +08:00
|
|
|
extern int cifs_negotiate_protocol(const unsigned int xid,
|
2021-07-19 21:54:16 +08:00
|
|
|
struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
2012-05-25 14:54:49 +08:00
|
|
|
extern int cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
|
2021-07-19 21:54:16 +08:00
|
|
|
struct TCP_Server_Info *server,
|
2012-05-25 14:54:49 +08:00
|
|
|
struct nls_table *nls_info);
|
2013-05-26 19:01:00 +08:00
|
|
|
extern int cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required);
|
2021-07-19 21:54:16 +08:00
|
|
|
extern int CIFSSMBNegotiate(const unsigned int xid,
|
|
|
|
struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-05-25 15:11:39 +08:00
|
|
|
extern int CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
|
|
|
|
const char *tree, struct cifs_tcon *tcon,
|
|
|
|
const struct nls_table *);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-09-29 01:21:14 +08:00
|
|
|
const char *searchName, struct cifs_sb_info *cifs_sb,
|
2012-05-15 23:19:16 +08:00
|
|
|
__u16 *searchHandle, __u16 search_flags,
|
|
|
|
struct cifs_search_info *psrch_inf,
|
2012-09-29 01:21:14 +08:00
|
|
|
bool msearch);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-05-15 23:19:16 +08:00
|
|
|
__u16 searchHandle, __u16 search_flags,
|
|
|
|
struct cifs_search_info *psrch_inf);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
|
2005-04-17 06:20:36 +08:00
|
|
|
const __u16 search_handle);
|
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2010-02-12 20:44:16 +08:00
|
|
|
u16 netfid, FILE_ALL_INFO *pFindData);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-05-25 18:40:22 +08:00
|
|
|
const char *search_Name, FILE_ALL_INFO *data,
|
|
|
|
int legacy /* whether to use old info level */,
|
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-05-25 18:40:22 +08:00
|
|
|
const char *search_name, FILE_ALL_INFO *data,
|
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2010-02-12 20:44:17 +08:00
|
|
|
u16 netfid, FILE_UNIX_BASIC_INFO *pFindData);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBUnixQPathInfo(const unsigned int xid,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_tcon *tcon,
|
2005-04-17 06:20:36 +08:00
|
|
|
const unsigned char *searchName,
|
2008-05-13 12:54:12 +08:00
|
|
|
FILE_UNIX_BASIC_INFO *pFindData,
|
2005-04-29 13:41:06 +08:00
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
|
2012-05-28 00:21:53 +08:00
|
|
|
const char *search_name,
|
|
|
|
struct dfs_info3_param **target_nodes,
|
|
|
|
unsigned int *num_of_nodes,
|
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-02-13 23:03:47 +08:00
|
|
|
extern int parse_dfs_referrals(struct get_dfs_referral_rsp *rsp, u32 rsp_size,
|
|
|
|
unsigned int *num_of_nodes,
|
|
|
|
struct dfs_info3_param **target_nodes,
|
|
|
|
const struct nls_table *nls_codepage, int remap,
|
|
|
|
const char *searchName, bool is_unicode);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
|
2011-06-17 21:05:48 +08:00
|
|
|
struct cifs_sb_info *cifs_sb,
|
2020-12-10 13:07:12 +08:00
|
|
|
struct smb3_fs_context *ctx);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2005-04-29 13:41:06 +08:00
|
|
|
struct kstatfs *FSData);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2005-09-22 13:05:57 +08:00
|
|
|
struct kstatfs *FSData);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2005-06-23 08:26:35 +08:00
|
|
|
__u64 cap);
|
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBQFSAttributeInfo(const unsigned int xid,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_tcon *tcon);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon);
|
|
|
|
extern int CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon);
|
|
|
|
extern int CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2005-04-29 13:41:06 +08:00
|
|
|
struct kstatfs *FSData);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2008-02-08 07:25:02 +08:00
|
|
|
const char *fileName, const FILE_BASIC_INFO *data,
|
2005-04-29 13:41:06 +08:00
|
|
|
const struct nls_table *nls_codepage,
|
2020-07-15 06:18:05 +08:00
|
|
|
struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
|
2008-08-02 19:26:12 +08:00
|
|
|
const FILE_BASIC_INFO *data, __u16 fid,
|
|
|
|
__u32 pid_of_opener);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBSetFileDisposition(const unsigned int xid,
|
|
|
|
struct cifs_tcon *tcon,
|
|
|
|
bool delete_file, __u16 fid,
|
|
|
|
__u32 pid_of_opener);
|
|
|
|
extern int CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-09-19 07:20:31 +08:00
|
|
|
const char *file_name, __u64 size,
|
|
|
|
struct cifs_sb_info *cifs_sb, bool set_allocation);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-09-19 07:20:31 +08:00
|
|
|
struct cifsFileInfo *cfile, __u64 size,
|
|
|
|
bool set_allocation);
|
2008-08-02 19:26:12 +08:00
|
|
|
|
|
|
|
struct cifs_unix_set_info_args {
|
|
|
|
__u64 ctime;
|
|
|
|
__u64 atime;
|
|
|
|
__u64 mtime;
|
|
|
|
__u64 mode;
|
2013-02-06 16:57:56 +08:00
|
|
|
kuid_t uid;
|
|
|
|
kgid_t gid;
|
2008-08-02 19:26:12 +08:00
|
|
|
dev_t device;
|
|
|
|
};
|
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBUnixSetFileInfo(const unsigned int xid,
|
|
|
|
struct cifs_tcon *tcon,
|
2009-07-10 08:02:50 +08:00
|
|
|
const struct cifs_unix_set_info_args *args,
|
|
|
|
u16 fid, u32 pid_of_opener);
|
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBUnixSetPathInfo(const unsigned int xid,
|
2012-07-13 18:04:46 +08:00
|
|
|
struct cifs_tcon *tcon, const char *file_name,
|
2012-06-20 15:21:16 +08:00
|
|
|
const struct cifs_unix_set_info_args *args,
|
|
|
|
const struct nls_table *nls_codepage,
|
2012-07-13 18:04:46 +08:00
|
|
|
int remap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-09-25 13:32:13 +08:00
|
|
|
extern int CIFSSMBMkDir(const unsigned int xid, struct inode *inode,
|
|
|
|
umode_t mode, struct cifs_tcon *tcon,
|
2012-03-17 16:41:12 +08:00
|
|
|
const char *name, struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-07-10 20:14:18 +08:00
|
|
|
const char *name, struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
|
2007-07-15 09:48:57 +08:00
|
|
|
const char *name, __u16 type,
|
|
|
|
const struct nls_table *nls_codepage,
|
|
|
|
int remap_special_chars);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-09-19 07:20:25 +08:00
|
|
|
const char *name, struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-09-19 07:20:30 +08:00
|
|
|
const char *from_name, const char *to_name,
|
|
|
|
struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
int netfid, const char *target_name,
|
|
|
|
const struct nls_table *nls_codepage,
|
|
|
|
int remap_special_chars);
|
2012-09-19 07:20:31 +08:00
|
|
|
extern int CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
const char *from_name, const char *to_name,
|
|
|
|
struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSUnixCreateHardLink(const unsigned int xid,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_tcon *tcon,
|
2005-04-17 06:20:36 +08:00
|
|
|
const char *fromName, const char *toName,
|
2007-06-29 03:44:13 +08:00
|
|
|
const struct nls_table *nls_codepage,
|
2005-04-29 13:41:06 +08:00
|
|
|
int remap_special_chars);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSUnixCreateSymLink(const unsigned int xid,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_tcon *tcon,
|
2005-04-17 06:20:36 +08:00
|
|
|
const char *fromName, const char *toName,
|
2015-02-13 14:35:58 +08:00
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBUnixQuerySymLink(const unsigned int xid,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_tcon *tcon,
|
2009-04-30 19:17:56 +08:00
|
|
|
const unsigned char *searchName, char **syminfo,
|
2015-02-13 14:35:58 +08:00
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2013-08-14 23:25:22 +08:00
|
|
|
extern int CIFSSMBQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
__u16 fid, char **symlinkinfo,
|
|
|
|
const struct nls_table *nls_codepage);
|
2013-10-15 04:27:32 +08:00
|
|
|
extern int CIFSSMB_set_compression(const unsigned int xid,
|
|
|
|
struct cifs_tcon *tcon, __u16 fid);
|
2014-01-16 19:53:36 +08:00
|
|
|
extern int CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms,
|
|
|
|
int *oplock, FILE_ALL_INFO *buf);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
|
2005-08-25 14:06:05 +08:00
|
|
|
const char *fileName, const int disposition,
|
|
|
|
const int access_flags, const int omode,
|
2007-11-17 07:05:52 +08:00
|
|
|
__u16 *netfid, int *pOplock, FILE_ALL_INFO *,
|
2005-08-25 14:06:05 +08:00
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
|
2007-11-17 07:05:52 +08:00
|
|
|
u32 posix_flags, __u64 mode, __u16 *netfid,
|
2007-04-24 06:07:35 +08:00
|
|
|
FILE_UNIX_BASIC_INFO *pRetData,
|
|
|
|
__u32 *pOplock, const char *name,
|
2007-06-29 03:44:13 +08:00
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon,
|
2005-04-17 06:20:36 +08:00
|
|
|
const int smb_file_id);
|
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon,
|
2009-02-22 05:17:43 +08:00
|
|
|
const int smb_file_id);
|
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
|
2011-05-26 14:02:00 +08:00
|
|
|
unsigned int *nbytes, char **buf,
|
2007-06-29 03:44:13 +08:00
|
|
|
int *return_buf_type);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
|
2016-09-06 05:53:43 +08:00
|
|
|
unsigned int *nbytes, const char *buf);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
|
2012-09-19 07:20:30 +08:00
|
|
|
unsigned int *nbytes, struct kvec *iov, const int nvec);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
|
2012-05-27 21:34:43 +08:00
|
|
|
const char *search_name, __u64 *inode_number,
|
|
|
|
const struct nls_table *nls_codepage,
|
|
|
|
int remap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
const __u16 netfid, const __u8 lock_type,
|
|
|
|
const __u32 num_unlock, const __u32 num_lock,
|
|
|
|
LOCKING_ANDX_RANGE *buf);
|
|
|
|
extern int CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
|
2010-08-17 15:26:00 +08:00
|
|
|
const __u16 netfid, const __u32 netpid, const __u64 len,
|
2005-04-17 06:20:36 +08:00
|
|
|
const __u64 offset, const __u32 numUnlock,
|
|
|
|
const __u32 numLock, const __u8 lockType,
|
2011-01-18 01:15:44 +08:00
|
|
|
const bool waitFlag, const __u8 oplock_level);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
|
2011-10-22 19:33:30 +08:00
|
|
|
const __u16 smb_file_id, const __u32 netpid,
|
2012-07-24 01:28:37 +08:00
|
|
|
const loff_t start_offset, const __u64 len,
|
|
|
|
struct file_lock *, const __u16 lock_type,
|
|
|
|
const bool waitFlag);
|
2012-05-25 15:11:39 +08:00
|
|
|
extern int CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon);
|
2011-01-11 20:24:21 +08:00
|
|
|
extern int CIFSSMBEcho(struct TCP_Server_Info *server);
|
2012-05-25 14:54:49 +08:00
|
|
|
extern int CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-05-27 12:34:02 +08:00
|
|
|
extern struct cifs_ses *sesInfoAlloc(void);
|
|
|
|
extern void sesInfoFree(struct cifs_ses *);
|
2023-09-20 00:35:53 +08:00
|
|
|
extern struct cifs_tcon *tcon_info_alloc(bool dir_leases_enabled);
|
2011-05-27 12:34:02 +08:00
|
|
|
extern void tconInfoFree(struct cifs_tcon *);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-09-19 07:20:34 +08:00
|
|
|
extern int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
|
|
|
|
__u32 *pexpected_response_sequence_number);
|
2012-07-24 01:28:38 +08:00
|
|
|
extern int cifs_sign_smbv(struct kvec *iov, int n_vec, struct TCP_Server_Info *,
|
2005-12-03 05:32:45 +08:00
|
|
|
__u32 *);
|
2012-09-19 07:20:34 +08:00
|
|
|
extern int cifs_sign_smb(struct smb_hdr *, struct TCP_Server_Info *, __u32 *);
|
|
|
|
extern int cifs_verify_signature(struct smb_rqst *rqst,
|
2010-10-21 19:42:55 +08:00
|
|
|
struct TCP_Server_Info *server,
|
2007-07-09 15:55:14 +08:00
|
|
|
__u32 expected_sequence_number);
|
2011-05-27 12:34:02 +08:00
|
|
|
extern int setup_ntlmv2_rsp(struct cifs_ses *, const struct nls_table *);
|
2016-11-04 07:47:37 +08:00
|
|
|
extern void cifs_crypto_secmech_release(struct TCP_Server_Info *server);
|
2011-05-27 12:34:02 +08:00
|
|
|
extern int calc_seckey(struct cifs_ses *);
|
2021-07-19 21:54:16 +08:00
|
|
|
extern int generate_smb30signingkey(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
extern int generate_smb311signingkey(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
2010-10-22 03:25:08 +08:00
|
|
|
|
2022-08-02 00:17:46 +08:00
|
|
|
#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBCopy(unsigned int xid,
|
2011-05-27 12:34:02 +08:00
|
|
|
struct cifs_tcon *source_tcon,
|
2005-04-17 06:20:36 +08:00
|
|
|
const char *fromName,
|
|
|
|
const __u16 target_tid,
|
|
|
|
const char *toName, const int flags,
|
2007-07-13 08:33:32 +08:00
|
|
|
const struct nls_table *nls_codepage,
|
2005-04-29 13:41:06 +08:00
|
|
|
int remap_special_chars);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern ssize_t CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
|
2010-02-11 05:18:26 +08:00
|
|
|
const unsigned char *searchName,
|
|
|
|
const unsigned char *ea_name, char *EAData,
|
2017-05-13 09:59:10 +08:00
|
|
|
size_t bufsize, struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
|
2007-06-29 03:44:13 +08:00
|
|
|
const char *fileName, const char *ea_name,
|
|
|
|
const void *ea_value, const __u16 ea_value_len,
|
2017-08-24 09:24:56 +08:00
|
|
|
const struct nls_table *nls_codepage,
|
|
|
|
struct cifs_sb_info *cifs_sb);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon,
|
2007-10-26 05:17:17 +08:00
|
|
|
__u16 fid, struct cifs_ntsd **acl_inf, __u32 *buflen);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSSMBSetCIFSACL(const unsigned int, struct cifs_tcon *, __u16,
|
2011-10-13 23:26:03 +08:00
|
|
|
struct cifs_ntsd *, __u32, int);
|
2022-09-22 23:17:02 +08:00
|
|
|
extern int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
const unsigned char *searchName,
|
|
|
|
struct posix_acl **acl, const int acl_type,
|
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2022-09-22 23:17:03 +08:00
|
|
|
extern int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
const unsigned char *fileName,
|
|
|
|
const struct posix_acl *acl, const int acl_type,
|
|
|
|
const struct nls_table *nls_codepage, int remap);
|
2012-06-20 15:21:16 +08:00
|
|
|
extern int CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
|
2007-11-17 07:05:52 +08:00
|
|
|
const int netfid, __u64 *pExtAttrBits, __u64 *pMask);
|
2022-08-02 00:17:46 +08:00
|
|
|
#endif /* CIFS_ALLOW_INSECURE_LEGACY */
|
2009-11-07 03:18:29 +08:00
|
|
|
extern void cifs_autodisable_serverino(struct cifs_sb_info *cifs_sb);
|
2013-11-26 01:09:50 +08:00
|
|
|
extern bool couldbe_mf_symlink(const struct cifs_fattr *fattr);
|
|
|
|
extern int check_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
|
2013-11-26 01:09:48 +08:00
|
|
|
struct cifs_sb_info *cifs_sb,
|
|
|
|
struct cifs_fattr *fattr,
|
|
|
|
const unsigned char *path);
|
2011-10-21 02:21:59 +08:00
|
|
|
extern int E_md4hash(const unsigned char *passwd, unsigned char *p16,
|
|
|
|
const struct nls_table *codepage);
|
2019-03-20 03:54:29 +08:00
|
|
|
|
2018-11-15 02:01:21 +08:00
|
|
|
extern struct TCP_Server_Info *
|
2020-12-10 13:07:12 +08:00
|
|
|
cifs_find_tcp_session(struct smb3_fs_context *ctx);
|
2018-11-15 02:01:21 +08:00
|
|
|
|
2023-04-24 10:26:51 +08:00
|
|
|
void __cifs_put_smb_ses(struct cifs_ses *ses);
|
2019-03-20 03:54:29 +08:00
|
|
|
|
|
|
|
extern struct cifs_ses *
|
2020-12-10 13:07:12 +08:00
|
|
|
cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb3_fs_context *ctx);
|
2019-03-20 03:54:29 +08:00
|
|
|
|
2012-05-16 19:13:17 +08:00
|
|
|
void cifs_readdata_release(struct kref *refcount);
|
2011-10-20 03:30:07 +08:00
|
|
|
int cifs_async_readv(struct cifs_readdata *rdata);
|
2012-09-19 07:20:29 +08:00
|
|
|
int cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid);
|
2011-10-20 03:30:07 +08:00
|
|
|
|
2014-02-08 10:45:12 +08:00
|
|
|
int cifs_async_writev(struct cifs_writedata *wdata,
|
|
|
|
void (*release)(struct kref *kref));
|
2012-03-24 02:40:55 +08:00
|
|
|
void cifs_writev_complete(struct work_struct *work);
|
cifs: Change the I/O paths to use an iterator rather than a page list
Currently, the cifs I/O paths hand lists of pages from the VM interface
routines at the top all the way through the intervening layers to the
socket interface at the bottom.
This is a problem, however, for interfacing with netfslib which passes an
iterator through to the ->issue_read() method (and will pass an iterator
through to the ->issue_write() method in future). Netfslib takes over
bounce buffering for direct I/O, async I/O and encrypted content, so cifs
doesn't need to do that. Netfslib also converts IOVEC-type iterators into
BVEC-type iterators if necessary.
Further, cifs needs foliating - and folios may come in a variety of sizes,
so a page list pointing to an array of heterogeneous pages may cause
problems in places such as where crypto is done.
Change the cifs I/O paths to hand iov_iter iterators all the way through
instead.
Notes:
(1) Some old routines are #if'd out to be removed in a follow up patch so
as to avoid confusing diff, thereby making the diff output easier to
follow. I've removed functions that don't overlap with anything
added.
(2) struct smb_rqst loses rq_pages, rq_offset, rq_npages, rq_pagesz and
rq_tailsz which describe the pages forming the buffer; instead there's
an rq_iter describing the source buffer and an rq_buffer which is used
to hold the buffer for encryption.
(3) struct cifs_readdata and cifs_writedata are similarly modified to
smb_rqst. The ->read_into_pages() and ->copy_into_pages() are then
replaced with passing the iterator directly to the socket.
The iterators are stored in these structs so that they are persistent
and don't get deallocated when the function returns (unlike if they
were stack variables).
(4) Buffered writeback is overhauled, borrowing the code from the afs
filesystem to gather up contiguous runs of folios. The XARRAY-type
iterator is then used to refer directly to the pagecache and can be
passed to the socket to transmit data directly from there.
This includes:
cifs_extend_writeback()
cifs_write_back_from_locked_folio()
cifs_writepages_region()
cifs_writepages()
(5) Pages are converted to folios.
(6) Direct I/O uses netfs_extract_user_iter() to create a BVEC-type
iterator from an IOBUF/UBUF-type source iterator.
(7) smb2_get_aead_req() uses netfs_extract_iter_to_sg() to extract page
fragments from the iterator into the scatterlists that the crypto
layer prefers.
(8) smb2_init_transform_rq() attached pages to smb_rqst::rq_buffer, an
xarray, to use as a bounce buffer for encryption. An XARRAY-type
iterator can then be used to pass the bounce buffer to lower layers.
Signed-off-by: David Howells <dhowells@redhat.com>
cc: Steve French <sfrench@samba.org>
cc: Shyam Prasad N <nspmangalore@gmail.com>
cc: Rohith Surabattula <rohiths.msft@gmail.com>
cc: Paulo Alcantara <pc@cjr.nz>
cc: Jeff Layton <jlayton@kernel.org>
cc: linux-cifs@vger.kernel.org
Link: https://lore.kernel.org/r/164311907995.2806745.400147335497304099.stgit@warthog.procyon.org.uk/ # rfc
Link: https://lore.kernel.org/r/164928620163.457102.11602306234438271112.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/165211420279.3154751.15923591172438186144.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/165348880385.2106726.3220789453472800240.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/165364827111.3334034.934805882842932881.stgit@warthog.procyon.org.uk/ # v3
Link: https://lore.kernel.org/r/166126396180.708021.271013668175370826.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/166697259595.61150.5982032408321852414.stgit@warthog.procyon.org.uk/ # rfc
Link: https://lore.kernel.org/r/166732031756.3186319.12528413619888902872.stgit@warthog.procyon.org.uk/ # rfc
Signed-off-by: Steve French <stfrench@microsoft.com>
2022-01-25 05:13:24 +08:00
|
|
|
struct cifs_writedata *cifs_writedata_alloc(work_func_t complete);
|
2011-05-20 04:22:56 +08:00
|
|
|
void cifs_writedata_release(struct kref *refcount);
|
2013-11-26 01:09:49 +08:00
|
|
|
int cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
struct cifs_sb_info *cifs_sb,
|
|
|
|
const unsigned char *path, char *pbuf,
|
|
|
|
unsigned int *pbytes_read);
|
2013-11-26 01:09:52 +08:00
|
|
|
int cifs_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
|
|
|
|
struct cifs_sb_info *cifs_sb,
|
|
|
|
const unsigned char *path, char *pbuf,
|
|
|
|
unsigned int *pbytes_written);
|
2018-06-12 06:00:58 +08:00
|
|
|
int __cifs_calc_signature(struct smb_rqst *rqst,
|
2015-11-13 11:46:49 +08:00
|
|
|
struct TCP_Server_Info *server, char *signature,
|
|
|
|
struct shash_desc *shash);
|
2017-01-18 18:05:57 +08:00
|
|
|
enum securityEnum cifs_select_sectype(struct TCP_Server_Info *,
|
|
|
|
enum securityEnum);
|
2017-04-26 02:52:29 +08:00
|
|
|
struct cifs_aio_ctx *cifs_aio_ctx_alloc(void);
|
|
|
|
void cifs_aio_ctx_release(struct kref *refcount);
|
2018-02-17 02:19:27 +08:00
|
|
|
|
2022-09-30 04:36:50 +08:00
|
|
|
int cifs_alloc_hash(const char *name, struct shash_desc **sdesc);
|
|
|
|
void cifs_free_hash(struct shash_desc **sdesc);
|
2018-02-17 02:19:27 +08:00
|
|
|
|
2020-04-24 22:55:31 +08:00
|
|
|
struct cifs_chan *
|
|
|
|
cifs_ses_find_chan(struct cifs_ses *ses, struct TCP_Server_Info *server);
|
2020-12-14 14:40:20 +08:00
|
|
|
int cifs_try_adding_channels(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses);
|
2019-09-20 12:31:10 +08:00
|
|
|
bool is_server_using_iface(struct TCP_Server_Info *server,
|
|
|
|
struct cifs_server_iface *iface);
|
|
|
|
bool is_ses_using_iface(struct cifs_ses *ses, struct cifs_server_iface *iface);
|
2021-11-17 00:38:58 +08:00
|
|
|
void cifs_ses_mark_for_reconnect(struct cifs_ses *ses);
|
2018-05-31 03:47:58 +08:00
|
|
|
|
2021-07-19 20:46:53 +08:00
|
|
|
unsigned int
|
|
|
|
cifs_ses_get_chan_index(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
void
|
2022-04-08 21:31:37 +08:00
|
|
|
cifs_chan_set_in_reconnect(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
void
|
|
|
|
cifs_chan_clear_in_reconnect(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
bool
|
|
|
|
cifs_chan_in_reconnect(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
void
|
2021-07-19 20:46:53 +08:00
|
|
|
cifs_chan_set_need_reconnect(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
void
|
|
|
|
cifs_chan_clear_need_reconnect(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
bool
|
|
|
|
cifs_chan_needs_reconnect(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
2022-01-03 16:47:30 +08:00
|
|
|
bool
|
|
|
|
cifs_chan_is_iface_active(struct cifs_ses *ses,
|
|
|
|
struct TCP_Server_Info *server);
|
|
|
|
int
|
|
|
|
cifs_chan_update_iface(struct cifs_ses *ses, struct TCP_Server_Info *server);
|
2022-06-06 17:17:56 +08:00
|
|
|
int
|
2022-10-02 00:44:08 +08:00
|
|
|
SMB3_request_interfaces(const unsigned int xid, struct cifs_tcon *tcon, bool in_mount);
|
2021-07-19 20:46:53 +08:00
|
|
|
|
2018-11-15 03:20:31 +08:00
|
|
|
void extract_unc_hostname(const char *unc, const char **h, size_t *len);
|
2019-08-27 07:30:14 +08:00
|
|
|
int copy_path_name(char *dst, const char *src);
|
2020-01-08 11:08:06 +08:00
|
|
|
int smb2_parse_query_directory(struct cifs_tcon *tcon, struct kvec *rsp_iov,
|
|
|
|
int resp_buftype,
|
|
|
|
struct cifs_search_info *srch_inf);
|
2018-11-15 03:20:31 +08:00
|
|
|
|
2023-06-27 03:04:17 +08:00
|
|
|
struct super_block *cifs_get_dfs_tcon_super(struct cifs_tcon *tcon);
|
2020-02-21 06:49:34 +08:00
|
|
|
void cifs_put_tcp_super(struct super_block *sb);
|
2021-11-04 00:53:29 +08:00
|
|
|
int cifs_update_super_prepath(struct cifs_sb_info *cifs_sb, char *prefix);
|
2020-12-01 02:02:47 +08:00
|
|
|
char *extract_hostname(const char *unc);
|
2020-12-01 02:02:48 +08:00
|
|
|
char *extract_sharename(const char *unc);
|
2020-02-21 06:49:34 +08:00
|
|
|
|
2018-11-15 02:24:03 +08:00
|
|
|
#ifdef CONFIG_CIFS_DFS_UPCALL
|
|
|
|
static inline int get_dfs_path(const unsigned int xid, struct cifs_ses *ses,
|
|
|
|
const char *old_path,
|
|
|
|
const struct nls_table *nls_codepage,
|
|
|
|
struct dfs_info3_param *referral, int remap)
|
|
|
|
{
|
|
|
|
return dfs_cache_find(xid, ses, nls_codepage, remap, old_path,
|
|
|
|
referral, NULL);
|
|
|
|
}
|
2020-05-20 02:38:28 +08:00
|
|
|
|
|
|
|
int match_target_ip(struct TCP_Server_Info *server,
|
|
|
|
const char *share, size_t share_len,
|
|
|
|
bool *result);
|
2023-03-01 06:01:54 +08:00
|
|
|
int cifs_inval_name_dfs_link_error(const unsigned int xid,
|
|
|
|
struct cifs_tcon *tcon,
|
|
|
|
struct cifs_sb_info *cifs_sb,
|
|
|
|
const char *full_path,
|
|
|
|
bool *islink);
|
|
|
|
#else
|
|
|
|
static inline int cifs_inval_name_dfs_link_error(const unsigned int xid,
|
|
|
|
struct cifs_tcon *tcon,
|
|
|
|
struct cifs_sb_info *cifs_sb,
|
|
|
|
const char *full_path,
|
|
|
|
bool *islink)
|
|
|
|
{
|
|
|
|
*islink = false;
|
|
|
|
return 0;
|
|
|
|
}
|
2018-11-15 02:24:03 +08:00
|
|
|
#endif
|
|
|
|
|
2020-02-04 03:46:43 +08:00
|
|
|
static inline int cifs_create_options(struct cifs_sb_info *cifs_sb, int options)
|
|
|
|
{
|
2020-02-05 03:02:59 +08:00
|
|
|
if (cifs_sb && (backup_cred(cifs_sb)))
|
2020-02-04 03:46:43 +08:00
|
|
|
return options | CREATE_OPEN_BACKUP_INTENT;
|
|
|
|
else
|
|
|
|
return options;
|
|
|
|
}
|
|
|
|
|
2021-11-04 00:53:29 +08:00
|
|
|
struct super_block *cifs_get_tcon_super(struct cifs_tcon *tcon);
|
|
|
|
void cifs_put_tcon_super(struct super_block *sb);
|
2023-03-01 06:01:55 +08:00
|
|
|
int cifs_wait_for_server_reconnect(struct TCP_Server_Info *server, bool retry);
|
2021-11-04 00:53:29 +08:00
|
|
|
|
2023-04-24 10:26:51 +08:00
|
|
|
/* Put references of @ses and @ses->dfs_root_ses */
|
|
|
|
static inline void cifs_put_smb_ses(struct cifs_ses *ses)
|
|
|
|
{
|
|
|
|
struct cifs_ses *rses = ses->dfs_root_ses;
|
|
|
|
|
|
|
|
__cifs_put_smb_ses(ses);
|
|
|
|
if (rses)
|
|
|
|
__cifs_put_smb_ses(rses);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get an active reference of @ses and @ses->dfs_root_ses.
|
|
|
|
*
|
|
|
|
* NOTE: make sure to call this function when incrementing reference count of
|
|
|
|
* @ses to ensure that any DFS root session attached to it (@ses->dfs_root_ses)
|
|
|
|
* will also get its reference count incremented.
|
|
|
|
*
|
|
|
|
* cifs_put_smb_ses() will put both references, so call it when you're done.
|
|
|
|
*/
|
|
|
|
static inline void cifs_smb_ses_inc_refcount(struct cifs_ses *ses)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(&cifs_tcp_ses_lock);
|
|
|
|
|
|
|
|
ses->ses_count++;
|
|
|
|
if (ses->dfs_root_ses)
|
|
|
|
ses->dfs_root_ses->ses_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool dfs_src_pathname_equal(const char *s1, const char *s2)
|
|
|
|
{
|
|
|
|
if (strlen(s1) != strlen(s2))
|
|
|
|
return false;
|
|
|
|
for (; *s1; s1++, s2++) {
|
|
|
|
if (*s1 == '/' || *s1 == '\\') {
|
|
|
|
if (*s2 != '/' && *s2 != '\\')
|
|
|
|
return false;
|
|
|
|
} else if (tolower(*s1) != tolower(*s2))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* _CIFSPROTO_H */
|