taglinefilesource code
server75fs/nfs/inode.cstruct nfs_server *server;
server113fs/nfs/inode.cserver = &sb->u.nfs_sb.s_server;
server114fs/nfs/inode.cserver->file = filp;
server115fs/nfs/inode.cserver->lock = 0;
server116fs/nfs/inode.cserver->wait = NULL;
server117fs/nfs/inode.cserver->flags = data->flags;
server118fs/nfs/inode.cserver->rsize = data->rsize;
server119fs/nfs/inode.cif (server->rsize <= 0)
server120fs/nfs/inode.cserver->rsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
server121fs/nfs/inode.celse if (server->rsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
server122fs/nfs/inode.cserver->rsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
server123fs/nfs/inode.cserver->wsize = data->wsize;
server124fs/nfs/inode.cif (server->wsize <= 0)
server125fs/nfs/inode.cserver->wsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
server126fs/nfs/inode.celse if (server->wsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
server127fs/nfs/inode.cserver->wsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
server128fs/nfs/inode.cserver->timeo = data->timeo*HZ/10;
server129fs/nfs/inode.cserver->retrans = data->retrans;
server130fs/nfs/inode.cserver->acregmin = data->acregmin*HZ;
server131fs/nfs/inode.cserver->acregmax = data->acregmax*HZ;
server132fs/nfs/inode.cserver->acdirmin = data->acdirmin*HZ;
server133fs/nfs/inode.cserver->acdirmax = data->acdirmax*HZ;
server134fs/nfs/inode.cstrcpy(server->hostname, data->hostname);
server139fs/nfs/inode.cif (((struct sockaddr_in *)(&server->toaddr))->sin_addr.s_addr == INADDR_ANY) {
server153fs/nfs/inode.csock->ops->getname(sock, &(server->toaddr), &dummylen, 1) ;
server157fs/nfs/inode.cmemcpy((char *)&(server->toaddr),(char *)(&data->addr),sizeof(server->toaddr));
server161fs/nfs/inode.cif ((server->rsock = rpc_makesock(filp)) == NULL) {
server225fs/nfs/proc.cint nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
server233fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server238fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server261fs/nfs/proc.cint nfs_proc_setattr(struct nfs_server *server, struct nfs_fh *fhandle,
server269fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server275fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server298fs/nfs/proc.cint nfs_proc_lookup(struct nfs_server *server, struct nfs_fh *dir, const char *name,
server310fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server316fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server340fs/nfs/proc.cint nfs_proc_readlink(struct nfs_server *server, struct nfs_fh *fhandle,
server347fs/nfs/proc.cif (!(*p0 = nfs_rpc_alloc(server->rsize)))
server352fs/nfs/proc.cif ((status = nfs_rpc_call(server, *p0, p, server->rsize)) < 0)
server375fs/nfs/proc.cint nfs_proc_read(struct nfs_server *server, struct nfs_fh *fhandle,
server384fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server392fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server421fs/nfs/proc.cint nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
server429fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server438fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server461fs/nfs/proc.cint nfs_proc_create(struct nfs_server *server, struct nfs_fh *dir,
server470fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server477fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server501fs/nfs/proc.cint nfs_proc_remove(struct nfs_server *server, struct nfs_fh *dir, const char *name)
server508fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server514fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server536fs/nfs/proc.cint nfs_proc_rename(struct nfs_server *server,
server545fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server553fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server575fs/nfs/proc.cint nfs_proc_link(struct nfs_server *server, struct nfs_fh *fhandle,
server583fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server590fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server612fs/nfs/proc.cint nfs_proc_symlink(struct nfs_server *server, struct nfs_fh *dir,
server620fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server628fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server650fs/nfs/proc.cint nfs_proc_mkdir(struct nfs_server *server, struct nfs_fh *dir,
server659fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server666fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server690fs/nfs/proc.cint nfs_proc_rmdir(struct nfs_server *server, struct nfs_fh *dir, const char *name)
server697fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server703fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server725fs/nfs/proc.cint nfs_proc_readdir(struct nfs_server *server, struct nfs_fh *fhandle,
server736fs/nfs/proc.csize = server->rsize;
server737fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server744fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server781fs/nfs/proc.cint nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
server789fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server794fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server51fs/nfs/sock.cnfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
server58fs/nfs/sock.ctimeout.init_timeout = server->timeo;
server60fs/nfs/sock.ctimeout.retries = server->retrans;
server65fs/nfs/sock.c| ((server->flags & NFS_MOUNT_INTR)
server74fs/nfs/sock.cresult = rpc_call(server->rsock, 
server75fs/nfs/sock.c&server->toaddr, sizeof(server->toaddr),
server82fs/nfs/sock.cif (server->flags & NFS_MOUNT_SOFT) {
server84fs/nfs/sock.c"still trying.\n", server->hostname);
server90fs/nfs/sock.c"timed out.\n", server->hostname);
server98fs/nfs/sock.c} while (result == -ETIMEDOUT && !(server->flags & NFS_MOUNT_SOFT));
server101fs/nfs/sock.cprintk("NFS server %s OK.\n", server->hostname);
server43fs/smbfs/dir.csmb_find_inode(struct smb_server *server, const char *path);
server162fs/smbfs/dir.cstruct smb_server *server = SMB_SERVER(inode);
server215fs/smbfs/dir.cresult = smb_proc_readdir(server, inode,
server233fs/smbfs/dir.cswitch (server->case_handling) 
server269fs/smbfs/dir.cino_info = smb_find_inode(server, complete_path);
server558fs/smbfs/dir.csmb_init_root(struct smb_server *server)
server560fs/smbfs/dir.cstruct smb_inode_info *root = &(server->root);
server562fs/smbfs/dir.croot->finfo.path = server->m.root_path;
server574fs/smbfs/dir.csmb_stat_root(struct smb_server *server)
server576fs/smbfs/dir.cstruct smb_inode_info *root = &(server->root);
server580fs/smbfs/dir.cresult = smb_proc_getattr(server, "\\", 1, &(root->finfo));
server584fs/smbfs/dir.cresult = smb_proc_getattr(server, 
server592fs/smbfs/dir.csmb_free_all_inodes(struct smb_server *server)
server598fs/smbfs/dir.cstruct smb_inode_info *root = &(server->root);
server619fs/smbfs/dir.csmb_invalidate_all_inodes(struct smb_server *server)
server621fs/smbfs/dir.cstruct smb_inode_info *ino = &(server->root);
server626fs/smbfs/dir.c} while (ino != &(server->root));
server637fs/smbfs/dir.csmb_find_inode(struct smb_server *server, const char *path)
server639fs/smbfs/dir.cstruct smb_inode_info *result = &(server->root);
server649fs/smbfs/dir.c} while (result != &(server->root));
server151fs/smbfs/inode.cstruct smb_server *server = &(SMB_SBP(sb)->s_server);
server153fs/smbfs/inode.csmb_proc_disconnect(server);
server154fs/smbfs/inode.cclose_fp(server->sock_file);
server158fs/smbfs/inode.csmb_free_all_inodes(server);
server160fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server176fs/smbfs/inode.cstruct smb_server *server;
server226fs/smbfs/inode.cserver = &(SMB_SBP(sb)->s_server);
server227fs/smbfs/inode.cserver->sock_file = filp;
server228fs/smbfs/inode.cserver->lock = 0;
server229fs/smbfs/inode.cserver->wait = NULL;
server230fs/smbfs/inode.cserver->packet = NULL;
server231fs/smbfs/inode.cserver->max_xmit = data->max_xmit;
server232fs/smbfs/inode.cif (server->max_xmit <= 0)
server233fs/smbfs/inode.cserver->max_xmit = SMB_DEF_MAX_XMIT;
server235fs/smbfs/inode.cserver->tid = 0;
server236fs/smbfs/inode.cserver->pid = current->pid;
server237fs/smbfs/inode.cserver->mid = current->pid + 20;
server239fs/smbfs/inode.cserver->m = *data;
server240fs/smbfs/inode.cserver->m.file_mode = (server->m.file_mode &
server242fs/smbfs/inode.cserver->m.dir_mode  = (server->m.dir_mode &
server245fs/smbfs/inode.csmb_init_root(server);
server251fs/smbfs/inode.cerror = smb_proc_connect(server);
server262fs/smbfs/inode.cif (server->protocol >= PROTOCOL_LANMAN2)
server263fs/smbfs/inode.cserver->case_handling = CASE_DEFAULT;
server265fs/smbfs/inode.cserver->case_handling = CASE_LOWER;
server271fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server275fs/smbfs/inode.cif ((error = smb_stat_root(server)) < 0) {
server278fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server290fs/smbfs/inode.cif (!(sb->s_mounted = iget(sb, (int)&(server->root)))) {
server293fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server383fs/smbfs/proc.csmb_lock_server(struct smb_server *server)
server385fs/smbfs/proc.cwhile (server->lock)
server386fs/smbfs/proc.csleep_on(&server->wait);
server387fs/smbfs/proc.cserver->lock = 1;
server391fs/smbfs/proc.csmb_unlock_server(struct smb_server *server)
server393fs/smbfs/proc.cif (server->lock != 1) {
server397fs/smbfs/proc.cserver->lock = 0;
server398fs/smbfs/proc.cwake_up(&server->wait);
server439fs/smbfs/proc.csmb_retry(struct smb_server *server)
server441fs/smbfs/proc.cif (server->state != CONN_INVALID) {
server445fs/smbfs/proc.cif (smb_release(server) < 0) {
server447fs/smbfs/proc.cserver->state = CONN_RETRIED;
server450fs/smbfs/proc.cif(smb_proc_reconnect(server) < 0) {
server452fs/smbfs/proc.cserver->state = CONN_RETRIED;
server456fs/smbfs/proc.cserver->state = CONN_VALID;
server474fs/smbfs/proc.csmb_setup_header(struct smb_server *server, byte command, word wct, word bcc)
server477fs/smbfs/proc.cbyte *p = server->packet;
server478fs/smbfs/proc.cbyte *buf = server->packet;
server493fs/smbfs/proc.cWSET(buf, smb_tid, server->tid);
server494fs/smbfs/proc.cWSET(buf, smb_pid, server->pid);
server495fs/smbfs/proc.cWSET(buf, smb_uid, server->server_uid);
server496fs/smbfs/proc.cWSET(buf, smb_mid, server->mid);
server498fs/smbfs/proc.cif (server->protocol > PROTOCOL_CORE) {
server514fs/smbfs/proc.csmb_setup_header_exclusive(struct smb_server *server,
server517fs/smbfs/proc.csmb_lock_server(server);
server518fs/smbfs/proc.creturn smb_setup_header(server, command, wct, bcc);
server529fs/smbfs/proc.csmb_proc_open(struct smb_server *server, const char *pathname, int len,
server534fs/smbfs/proc.cchar* buf = server->packet;
server539fs/smbfs/proc.csmb_lock_server(server);
server542fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
server547fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBopen, 7, 0)) != 0) {
server549fs/smbfs/proc.cif (smb_retry(server)) {
server554fs/smbfs/proc.csmb_unlock_server(server);
server558fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
server563fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBopen, 7, 0)) != 0) {
server564fs/smbfs/proc.cif (smb_retry(server)) {
server567fs/smbfs/proc.csmb_unlock_server(server);
server581fs/smbfs/proc.csmb_unlock_server(server);
server591fs/smbfs/proc.csmb_proc_close(struct smb_server *server, struct smb_dirent *finfo)
server593fs/smbfs/proc.cchar *buf = server->packet;
server595fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBclose, 3, 0);
server599fs/smbfs/proc.creturn smb_request_ok_unlock(server, SMBclose, 0, 0);
server609fs/smbfs/proc.csmb_proc_read(struct smb_server *server, struct smb_dirent *finfo, 
server613fs/smbfs/proc.cchar *buf = server->packet;
server616fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBread, 5, 0);
server623fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBread, 5, -1)) < 0) {
server624fs/smbfs/proc.csmb_unlock_server(server);
server630fs/smbfs/proc.csmb_decode_data(SMB_BUF(server->packet), data, &data_len, fs);
server632fs/smbfs/proc.csmb_unlock_server(server);
server647fs/smbfs/proc.csmb_proc_read_raw(struct smb_server *server, struct smb_dirent *finfo, 
server650fs/smbfs/proc.cchar *buf = server->packet;
server657fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBreadbraw, 8, 0);
server665fs/smbfs/proc.cresult = smb_request_read_raw(server, data, count);
server666fs/smbfs/proc.csmb_unlock_server(server);
server671fs/smbfs/proc.csmb_proc_write(struct smb_server *server, struct smb_dirent *finfo,
server675fs/smbfs/proc.cchar *buf = server->packet;
server678fs/smbfs/proc.cp = smb_setup_header_exclusive(server, SMBwrite, 5, count + 3);
server688fs/smbfs/proc.cif ((res = smb_request_ok(server, SMBwrite, 1, 0)) >= 0) {
server692fs/smbfs/proc.csmb_unlock_server(server);
server699fs/smbfs/proc.csmb_proc_write_raw(struct smb_server *server, struct smb_dirent *finfo, 
server702fs/smbfs/proc.cchar *buf = server->packet;
server709fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBwritebraw, 11, 0);
server721fs/smbfs/proc.cresult = smb_request_ok(server, SMBwritebraw, 1, 0);
server726fs/smbfs/proc.csmb_unlock_server(server);
server730fs/smbfs/proc.cresult = smb_request_write_raw(server, data, count);
server736fs/smbfs/proc.cif (smb_valid_packet(server->packet) != 0) {
server739fs/smbfs/proc.c} else if (server->rcls != 0) {
server740fs/smbfs/proc.cresult = -smb_errno(server->rcls, server->err);
server741fs/smbfs/proc.c} else if (smb_verify(server->packet, SMBwritec,1,0) != 0) {
server747fs/smbfs/proc.csmb_unlock_server(server);
server755fs/smbfs/proc.csmb_proc_do_create(struct smb_server *server, const char *path, int len, 
server760fs/smbfs/proc.cchar *buf = server->packet;
server762fs/smbfs/proc.csmb_lock_server(server);
server764fs/smbfs/proc.cp = smb_setup_header(server, command, 3, len + 2);
server769fs/smbfs/proc.cif ((error = smb_request_ok(server, command, 1, 0)) < 0) {
server770fs/smbfs/proc.cif (smb_retry(server)) {
server773fs/smbfs/proc.csmb_unlock_server(server);
server779fs/smbfs/proc.csmb_unlock_server(server);
server781fs/smbfs/proc.csmb_proc_close(server, entry);
server787fs/smbfs/proc.csmb_proc_create(struct smb_server *server, const char *path, int len,
server790fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBcreate);
server794fs/smbfs/proc.csmb_proc_mknew(struct smb_server *server, const char *path, int len,
server797fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBmknew);
server801fs/smbfs/proc.csmb_proc_mv(struct smb_server *server, 
server806fs/smbfs/proc.cchar *buf = server->packet;
server809fs/smbfs/proc.csmb_lock_server(server);
server812fs/smbfs/proc.cp = smb_setup_header(server, SMBmv, 1, olen + nlen + 4);
server817fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBmv, 0, 0)) < 0) {
server818fs/smbfs/proc.cif (smb_retry(server)) {
server822fs/smbfs/proc.csmb_unlock_server(server);
server827fs/smbfs/proc.csmb_proc_mkdir(struct smb_server *server, const char *path, const int len)
server832fs/smbfs/proc.csmb_lock_server(server);
server835fs/smbfs/proc.cp = smb_setup_header(server, SMBmkdir, 0, 2 + len);
server838fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBmkdir, 0, 0)) < 0) {
server839fs/smbfs/proc.cif (smb_retry(server)) {
server843fs/smbfs/proc.csmb_unlock_server(server);
server848fs/smbfs/proc.csmb_proc_rmdir(struct smb_server *server, const char *path, const int len)
server853fs/smbfs/proc.csmb_lock_server(server);
server856fs/smbfs/proc.cp = smb_setup_header(server, SMBrmdir, 0, 2 + len);
server859fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBrmdir, 0, 0)) < 0) {
server860fs/smbfs/proc.cif (smb_retry(server)) {
server864fs/smbfs/proc.csmb_unlock_server(server);
server869fs/smbfs/proc.csmb_proc_unlink(struct smb_server *server, const char *path, const int len)
server872fs/smbfs/proc.cchar *buf = server->packet;
server875fs/smbfs/proc.csmb_lock_server(server);
server878fs/smbfs/proc.cp = smb_setup_header(server, SMBunlink, 1, 2 + len);
server882fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBunlink, 0, 0)) < 0) {
server883fs/smbfs/proc.cif (smb_retry(server)) {
server887fs/smbfs/proc.csmb_unlock_server(server);
server892fs/smbfs/proc.csmb_proc_trunc(struct smb_server *server, word fid, dword length)
server895fs/smbfs/proc.cchar *buf = server->packet;
server898fs/smbfs/proc.csmb_lock_server(server);
server901fs/smbfs/proc.cp = smb_setup_header(server, SMBwrite, 5, 3);
server908fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBwrite, 1, 0)) < 0) {
server909fs/smbfs/proc.cif (smb_retry(server)) {
server913fs/smbfs/proc.csmb_unlock_server(server);
server935fs/smbfs/proc.csmb_proc_readdir_short(struct smb_server *server, struct inode *dir, int fpos,
server948fs/smbfs/proc.cint entries_asked = (server->max_xmit - 100) / SMB_DIRINFO_SIZE;
server958fs/smbfs/proc.cbuf = server->packet;
server960fs/smbfs/proc.csmb_lock_server(server);
server969fs/smbfs/proc.cp = smb_setup_header(server, SMBsearch, 2,
server977fs/smbfs/proc.cp = smb_setup_header(server, SMBsearch, 2,
server985fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBsearch, 1, -1)) < 0) {
server986fs/smbfs/proc.cif (   (server->rcls == ERRDOS)
server987fs/smbfs/proc.c&& (server->err  == ERRnofiles)) {
server993fs/smbfs/proc.cif (smb_retry(server)) {
server1001fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1020fs/smbfs/proc.cSMB_BUF(server->packet) + 3 +
server1049fs/smbfs/proc.csmb_unlock_server(server);
server1139fs/smbfs/proc.csmb_proc_readdir_long(struct smb_server *server, struct inode *dir, int fpos,
server1179fs/smbfs/proc.csmb_lock_server(server);
server1190fs/smbfs/proc.cunsigned char *outbuf = server->packet;
server1200fs/smbfs/proc.csmb_setup_header(server, SMBtrans2, 15,
server1251fs/smbfs/proc.cresult = smb_trans2_request(server,
server1256fs/smbfs/proc.cif (smb_retry(server)) {
server1264fs/smbfs/proc.cif (server->rcls != 0)
server1360fs/smbfs/proc.csmb_unlock_server(server);
server1366fs/smbfs/proc.csmb_proc_readdir(struct smb_server *server, struct inode *dir, int fpos,
server1369fs/smbfs/proc.cif (server->protocol >= PROTOCOL_LANMAN2)
server1370fs/smbfs/proc.creturn smb_proc_readdir_long(server, dir, fpos, cache_size,
server1373fs/smbfs/proc.creturn smb_proc_readdir_short(server, dir, fpos, cache_size,
server1378fs/smbfs/proc.csmb_proc_getattr_core(struct smb_server *server, const char *path, int len, 
server1383fs/smbfs/proc.cchar *buf = server->packet;
server1385fs/smbfs/proc.csmb_lock_server(server);
server1390fs/smbfs/proc.cp = smb_setup_header(server, SMBgetatr, 0, 2 + len);
server1393fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBgetatr, 10, 0)) < 0) {
server1394fs/smbfs/proc.cif (smb_retry(server)) {
server1397fs/smbfs/proc.csmb_unlock_server(server);
server1406fs/smbfs/proc.csmb_unlock_server(server);
server1413fs/smbfs/proc.csmb_proc_getattrE(struct smb_server *server, struct smb_dirent *entry)
server1415fs/smbfs/proc.cchar* buf = server->packet;
server1418fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBgetattrE, 1, 0);
server1421fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBgetattrE, 11, 0)) != 0) {
server1422fs/smbfs/proc.csmb_unlock_server(server);
server1432fs/smbfs/proc.csmb_unlock_server(server);
server1437fs/smbfs/proc.csmb_proc_getattr(struct smb_server *server, const char *path, int len, 
server1440fs/smbfs/proc.cif (server->protocol >= PROTOCOL_LANMAN1) {
server1445fs/smbfs/proc.cif ((result=smb_proc_open(server,path,len,
server1449fs/smbfs/proc.creturn smb_proc_getattr_core(server,path,len,entry);
server1452fs/smbfs/proc.cif ((result=smb_proc_getattrE(server, &temp_entry)) >= 0) {
server1460fs/smbfs/proc.csmb_proc_close(server, &temp_entry);
server1464fs/smbfs/proc.creturn smb_proc_getattr_core(server, path, len, entry);
server1472fs/smbfs/proc.csmb_proc_setattr_core(struct smb_server *server,
server1477fs/smbfs/proc.cchar *buf = server->packet;
server1480fs/smbfs/proc.csmb_lock_server(server);
server1483fs/smbfs/proc.cp = smb_setup_header(server, SMBsetatr, 8, 4 + len);
server1489fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBsetatr, 0, 0)) < 0) {
server1490fs/smbfs/proc.cif (smb_retry(server)) {
server1494fs/smbfs/proc.csmb_unlock_server(server);
server1501fs/smbfs/proc.csmb_proc_setattrE(struct smb_server *server, word fid,
server1504fs/smbfs/proc.cchar *buf = server->packet;
server1507fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBsetattrE, 7, 0);
server1523fs/smbfs/proc.creturn smb_request_ok_unlock(server, SMBsetattrE, 0, 0);
server1529fs/smbfs/proc.csmb_proc_setattr(struct smb_server *server, struct inode *inode,
server1535fs/smbfs/proc.cif (server->protocol >= PROTOCOL_LANMAN1) {
server1538fs/smbfs/proc.creturn smb_proc_setattrE(server, finfo->fileid, new_finfo);
server1540fs/smbfs/proc.creturn smb_proc_setattr_core(server, finfo->path, finfo->len,
server1550fs/smbfs/proc.cstruct smb_server *server = &(SMB_SBP(super)->s_server);
server1552fs/smbfs/proc.csmb_lock_server(server);
server1555fs/smbfs/proc.csmb_setup_header(server, SMBdskattr, 0, 0);
server1557fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBdskattr, 5, 0)) < 0) {
server1558fs/smbfs/proc.cif (smb_retry(server)) {
server1561fs/smbfs/proc.csmb_unlock_server(server);
server1565fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1570fs/smbfs/proc.csmb_unlock_server(server);
server1591fs/smbfs/proc.csmb_proc_reconnect(struct smb_server *server)
server1607fs/smbfs/proc.cint given_max_xmit = server->m.max_xmit;
server1611fs/smbfs/proc.cif ((result = smb_connect(server)) < 0) {
server1617fs/smbfs/proc.cserver->state = CONN_VALID;
server1619fs/smbfs/proc.cif (server->packet != NULL) {
server1620fs/smbfs/proc.csmb_kfree_s(server->packet, server->max_xmit);
server1623fs/smbfs/proc.cserver->packet = smb_kmalloc(max_xmit, GFP_KERNEL);
server1625fs/smbfs/proc.cif (server->packet == NULL) {
server1631fs/smbfs/proc.cserver->max_xmit = max_xmit;
server1636fs/smbfs/proc.cp = server->packet + 4;
server1638fs/smbfs/proc.cp = smb_name_mangle(p, server->m.server_name);
server1639fs/smbfs/proc.cp = smb_name_mangle(p, server->m.client_name);
server1641fs/smbfs/proc.csmb_encode_smb_length(server->packet,
server1642fs/smbfs/proc.c(void *)p - (void *)(server->packet));
server1644fs/smbfs/proc.cserver->packet[0] = 0x81; /* SESSION REQUEST */
server1646fs/smbfs/proc.cif (smb_catch_keepalive(server) < 0) {
server1650fs/smbfs/proc.cif ((result = smb_request(server)) < 0) {
server1652fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1656fs/smbfs/proc.cif (server->packet[0] != 0x82) {
server1659fs/smbfs/proc.cserver->packet[0]);
server1660fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1662fs/smbfs/proc.csmb_dump_packet(server->packet);
server1671fs/smbfs/proc.cmemset(server->packet, 0, SMB_HEADER_LEN);
server1678fs/smbfs/proc.csmb_setup_header(server, SMBnegprot, 0, plength);
server1680fs/smbfs/proc.cp = SMB_BUF(server->packet);
server1686fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBnegprot, 1, -1)) < 0) {
server1688fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1696fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1698fs/smbfs/proc.cserver->protocol = prots[i].prot;
server1703fs/smbfs/proc.cif (server->protocol > PROTOCOL_LANMAN1) {
server1705fs/smbfs/proc.cword passlen = strlen(server->m.password);
server1706fs/smbfs/proc.cword userlen = strlen(server->m.username);
server1709fs/smbfs/proc.cserver->m.password);
server1711fs/smbfs/proc.cserver->m.username);
server1713fs/smbfs/proc.cWVAL(server->packet, smb_vwv5));
server1715fs/smbfs/proc.cserver->maxxmt = WVAL(server->packet, smb_vwv2);
server1716fs/smbfs/proc.cserver->maxmux = WVAL(server->packet, smb_vwv3);
server1717fs/smbfs/proc.cserver->maxvcs = WVAL(server->packet, smb_vwv4);
server1718fs/smbfs/proc.cserver->blkmode= WVAL(server->packet, smb_vwv5);
server1719fs/smbfs/proc.cserver->sesskey= DVAL(server->packet, smb_vwv6);
server1721fs/smbfs/proc.csmb_setup_header(server, SMBsesssetupX, 10,
server1724fs/smbfs/proc.cWSET(server->packet, smb_vwv0, 0x00ff);
server1725fs/smbfs/proc.cWSET(server->packet, smb_vwv1, 0);
server1726fs/smbfs/proc.cWSET(server->packet, smb_vwv2, given_max_xmit);
server1727fs/smbfs/proc.cWSET(server->packet, smb_vwv3, 2);
server1728fs/smbfs/proc.cWSET(server->packet, smb_vwv4, server->pid);
server1729fs/smbfs/proc.cDSET(server->packet, smb_vwv5, server->sesskey);
server1730fs/smbfs/proc.cWSET(server->packet, smb_vwv7, passlen + 1);
server1731fs/smbfs/proc.cWSET(server->packet, smb_vwv8, 0);
server1732fs/smbfs/proc.cWSET(server->packet, smb_vwv9, 0);
server1734fs/smbfs/proc.cp = SMB_BUF(server->packet);
server1735fs/smbfs/proc.cstrcpy(p, server->m.password);
server1737fs/smbfs/proc.cstrcpy(p, server->m.username);
server1739fs/smbfs/proc.cif ((result = smb_request_ok(server,SMBsesssetupX,3,0)) < 0) {
server1741fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1744fs/smbfs/proc.csmb_decode_word(server->packet+32, &(server->server_uid));
server1749fs/smbfs/proc.cserver->maxxmt = 0;
server1750fs/smbfs/proc.cserver->maxmux = 0;
server1751fs/smbfs/proc.cserver->maxvcs = 0;
server1752fs/smbfs/proc.cserver->blkmode = 0;
server1753fs/smbfs/proc.cserver->sesskey = 0;
server1758fs/smbfs/proc.csmb_setup_header(server, SMBtcon, 0,
server1759fs/smbfs/proc.c6 + strlen(server->m.service) +
server1760fs/smbfs/proc.cstrlen(server->m.password) + strlen(dev));
server1761fs/smbfs/proc.cp = SMB_BUF(server->packet);
server1762fs/smbfs/proc.cp = smb_encode_ascii(p, server->m.service, strlen(server->m.service));
server1763fs/smbfs/proc.cp = smb_encode_ascii(p,server->m.password, strlen(server->m.password));
server1766fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBtcon, 2, 0)) < 0) {
server1768fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1774fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1775fs/smbfs/proc.cp = smb_decode_word(p, &server->max_xmit);
server1777fs/smbfs/proc.cif (server->max_xmit > given_max_xmit)
server1778fs/smbfs/proc.cserver->max_xmit = given_max_xmit;
server1780fs/smbfs/proc.cp = smb_decode_word(p, &server->tid);
server1784fs/smbfs/proc.cserver->max_xmit += 4;
server1786fs/smbfs/proc.cDPRINTK("max_xmit = %d, tid = %d\n", server->max_xmit, server->tid);
server1789fs/smbfs/proc.csmb_kfree_s(server->packet, max_xmit); 
server1791fs/smbfs/proc.cserver->packet = smb_kmalloc(server->max_xmit, GFP_KERNEL);
server1792fs/smbfs/proc.cif (server->packet == NULL) {
server1795fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1803fs/smbfs/proc.cserver->state = CONN_INVALID;
server1810fs/smbfs/proc.csmb_proc_connect(struct smb_server *server)
server1813fs/smbfs/proc.csmb_lock_server(server);
server1814fs/smbfs/proc.cresult = smb_proc_reconnect(server);
server1815fs/smbfs/proc.cif ((result < 0) && (server->packet != NULL)) {
server1816fs/smbfs/proc.csmb_kfree_s(server->packet, server->max_xmit);
server1817fs/smbfs/proc.cserver->packet = NULL;
server1819fs/smbfs/proc.csmb_unlock_server(server);
server1824fs/smbfs/proc.csmb_proc_disconnect(struct smb_server *server)
server1826fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBtdis, 0, 0);
server1827fs/smbfs/proc.creturn smb_request_ok_unlock(server, SMBtdis, 0, 0);
server107fs/smbfs/sock.csmb_catch_keepalive(struct smb_server *server)
server114fs/smbfs/sock.cif (   (server == NULL)
server115fs/smbfs/sock.c|| ((file  = server->sock_file) == NULL)
server120fs/smbfs/sock.cserver->data_ready = NULL;
server128fs/smbfs/sock.cserver->data_ready = NULL;
server136fs/smbfs/sock.cserver->data_ready = NULL;
server142fs/smbfs/sock.c(unsigned int)(server->data_ready));
server149fs/smbfs/sock.cserver->data_ready = sk->data_ready;
server155fs/smbfs/sock.csmb_dont_catch_keepalive(struct smb_server *server)
server162fs/smbfs/sock.cif (   (server == NULL)
server163fs/smbfs/sock.c|| ((file  = server->sock_file) == NULL)
server186fs/smbfs/sock.cif (server->data_ready == NULL) {
server200fs/smbfs/sock.c(unsigned int)(server->data_ready));
server202fs/smbfs/sock.csk->data_ready = server->data_ready;
server203fs/smbfs/sock.cserver->data_ready = NULL;
server294fs/smbfs/sock.csmb_receive(struct smb_server *server, struct socket *sock)
server298fs/smbfs/sock.cresult = smb_receive_raw(sock, server->packet,
server299fs/smbfs/sock.cserver->max_xmit - 4, /* max_xmit in server
server308fs/smbfs/sock.cserver->rcls = *((unsigned char *)(server->packet+9));
server309fs/smbfs/sock.cserver->err  = *((unsigned short *)(server->packet+11));
server311fs/smbfs/sock.cif (server->rcls != 0) {
server313fs/smbfs/sock.cserver->rcls, server->err);
server324fs/smbfs/sock.csmb_receive_trans2(struct smb_server *server, struct socket *sock,
server331fs/smbfs/sock.cunsigned char *inbuf = server->packet;
server337fs/smbfs/sock.cif ((result = smb_receive(server, sock)) < 0) {
server341fs/smbfs/sock.cif (server->rcls != 0) {
server412fs/smbfs/sock.cif ((result = smb_receive(server, sock)) < 0) {
server415fs/smbfs/sock.cif (server->rcls != 0) {
server434fs/smbfs/sock.cserver_sock(struct smb_server *server)
server439fs/smbfs/sock.cif (server == NULL)
server441fs/smbfs/sock.cif ((file = server->sock_file) == NULL)
server449fs/smbfs/sock.csmb_release(struct smb_server *server)
server451fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server471fs/smbfs/sock.csmb_connect(struct smb_server *server)
server473fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server480fs/smbfs/sock.creturn sock->ops->connect(sock, (struct sockaddr *)&(server->m.addr),
server491fs/smbfs/sock.csmb_request(struct smb_server *server)
server498fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server499fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server506fs/smbfs/sock.cif (server->state != CONN_VALID)
server509fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server510fs/smbfs/sock.cserver->state = CONN_INVALID;
server511fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server529fs/smbfs/sock.cresult = smb_receive(server, sock);
server538fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server543fs/smbfs/sock.cserver->state = CONN_INVALID;
server544fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server557fs/smbfs/sock.csmb_trans2_request(struct smb_server *server,
server566fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server567fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server574fs/smbfs/sock.cif (server->state != CONN_VALID)
server577fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server578fs/smbfs/sock.cserver->state = CONN_INVALID;
server579fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server597fs/smbfs/sock.cresult = smb_receive_trans2(server, sock,
server608fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server613fs/smbfs/sock.cserver->state = CONN_INVALID;
server614fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server624fs/smbfs/sock.csmb_request_read_raw(struct smb_server *server,
server632fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server633fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server640fs/smbfs/sock.cif (server->state != CONN_VALID)
server643fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server644fs/smbfs/sock.cserver->state = CONN_INVALID;
server645fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server680fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server685fs/smbfs/sock.cserver->state = CONN_INVALID;
server686fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server698fs/smbfs/sock.csmb_request_write_raw(struct smb_server *server,
server707fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server708fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server715fs/smbfs/sock.cif (server->state != CONN_VALID)
server718fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server719fs/smbfs/sock.cserver->state = CONN_INVALID;
server720fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server744fs/smbfs/sock.cresult = smb_receive(server, sock);
server754fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server759fs/smbfs/sock.cserver->state = CONN_INVALID;
server760fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server52include/linux/nfs_fs.hextern int nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
server54include/linux/nfs_fs.hextern int nfs_proc_setattr(struct nfs_server *server, struct nfs_fh *fhandle,
server56include/linux/nfs_fs.hextern int nfs_proc_lookup(struct nfs_server *server, struct nfs_fh *dir,
server59include/linux/nfs_fs.hextern int nfs_proc_readlink(struct nfs_server *server, struct nfs_fh *fhandle,
server62include/linux/nfs_fs.hextern int nfs_proc_read(struct nfs_server *server, struct nfs_fh *fhandle,
server65include/linux/nfs_fs.hextern int nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
server68include/linux/nfs_fs.hextern int nfs_proc_create(struct nfs_server *server, struct nfs_fh *dir,
server71include/linux/nfs_fs.hextern int nfs_proc_remove(struct nfs_server *server, struct nfs_fh *dir,
server73include/linux/nfs_fs.hextern int nfs_proc_rename(struct nfs_server *server,
server76include/linux/nfs_fs.hextern int nfs_proc_link(struct nfs_server *server, struct nfs_fh *fhandle,
server78include/linux/nfs_fs.hextern int nfs_proc_symlink(struct nfs_server *server, struct nfs_fh *dir,
server80include/linux/nfs_fs.hextern int nfs_proc_mkdir(struct nfs_server *server, struct nfs_fh *dir,
server83include/linux/nfs_fs.hextern int nfs_proc_rmdir(struct nfs_server *server, struct nfs_fh *dir,
server85include/linux/nfs_fs.hextern int nfs_proc_readdir(struct nfs_server *server, struct nfs_fh *fhandle,
server87include/linux/nfs_fs.hextern int nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
server92include/linux/nfs_fs.hextern int nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size);
server106include/linux/smb_fs.hvoid smb_free_all_inodes(struct smb_server *server);
server107include/linux/smb_fs.hvoid smb_init_root(struct smb_server *server);
server108include/linux/smb_fs.hint  smb_stat_root(struct smb_server *server);
server111include/linux/smb_fs.hvoid smb_invalidate_all_inodes(struct smb_server *server);
server122include/linux/smb_fs.hvoid smb_invalidate_connection(struct smb_server *server);
server123include/linux/smb_fs.hint smb_conn_is_valid(struct smb_server *server);
server128include/linux/smb_fs.hint smb_proc_open(struct smb_server *server, const char *pathname,
server130include/linux/smb_fs.hint smb_proc_close(struct smb_server *server, struct smb_dirent *finfo);
server131include/linux/smb_fs.hint smb_proc_read(struct smb_server *server, struct smb_dirent *finfo, 
server133include/linux/smb_fs.hint smb_proc_read_raw(struct smb_server *server, struct smb_dirent *finfo, 
server135include/linux/smb_fs.hint smb_proc_write(struct smb_server *server, struct smb_dirent *finfo,
server137include/linux/smb_fs.hint smb_proc_write_raw(struct smb_server *server, struct smb_dirent *finfo, 
server139include/linux/smb_fs.hint smb_proc_create(struct smb_server *server, const char *path,
server141include/linux/smb_fs.hint smb_proc_mknew(struct smb_server *server, const char *path, int len,
server143include/linux/smb_fs.hint smb_proc_mv(struct smb_server *server, const char *opath, const int olen, 
server145include/linux/smb_fs.hint smb_proc_mkdir(struct smb_server *server, const char *path, const int len);
server146include/linux/smb_fs.hint smb_proc_rmdir(struct smb_server *server, const char *path, const int len);
server147include/linux/smb_fs.hint smb_proc_unlink(struct smb_server *server, const char *path,
server149include/linux/smb_fs.hint smb_proc_readdir(struct smb_server *server, struct inode *dir,
server152include/linux/smb_fs.hint smb_proc_getattr(struct smb_server *server, const char *path,
server154include/linux/smb_fs.hint smb_proc_setattr(struct smb_server *server,
server157include/linux/smb_fs.hint smb_proc_chkpath(struct smb_server *server, char *path, int len,
server160include/linux/smb_fs.hint smb_proc_reconnect(struct smb_server *server);
server161include/linux/smb_fs.hint smb_proc_connect(struct smb_server *server);
server162include/linux/smb_fs.hint smb_proc_disconnect(struct smb_server *server);
server163include/linux/smb_fs.hint smb_proc_trunc(struct smb_server *server, word fid, dword length);
server166include/linux/smb_fs.hint smb_release(struct smb_server *server);
server167include/linux/smb_fs.hint smb_connect(struct smb_server *server);
server168include/linux/smb_fs.hint smb_request(struct smb_server *server);
server169include/linux/smb_fs.hint smb_request_read_raw(struct smb_server *server,
server171include/linux/smb_fs.hint smb_request_write_raw(struct smb_server *server,
server173include/linux/smb_fs.hint smb_catch_keepalive(struct smb_server *server);
server174include/linux/smb_fs.hint smb_dont_catch_keepalive(struct smb_server *server);
server175include/linux/smb_fs.hint smb_trans2_request(struct smb_server *server,