~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/cifs_debug.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *   fs/cifs_debug.c
  3  *
  4  *   Copyright (C) International Business Machines  Corp., 2000,2005
  5  *
  6  *   Modified by Steve French (sfrench@us.ibm.com)
  7  *
  8  *   This program is free software;  you can redistribute it and/or modify
  9  *   it under the terms of the GNU General Public License as published by
 10  *   the Free Software Foundation; either version 2 of the License, or
 11  *   (at your option) any later version.
 12  *
 13  *   This program is distributed in the hope that it will be useful,
 14  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 16  *   the GNU General Public License for more details.
 17  *
 18  *   You should have received a copy of the GNU General Public License
 19  *   along with this program;  if not, write to the Free Software
 20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 21  */
 22 #include <linux/fs.h>
 23 #include <linux/string.h>
 24 #include <linux/ctype.h>
 25 #include <linux/module.h>
 26 #include <linux/proc_fs.h>
 27 #include <asm/uaccess.h>
 28 #include "cifspdu.h"
 29 #include "cifsglob.h"
 30 #include "cifsproto.h"
 31 #include "cifs_debug.h"
 32 #include "cifsfs.h"
 33 
 34 void
 35 cifs_dump_mem(char *label, void *data, int length)
 36 {
 37         int i, j;
 38         int *intptr = data;
 39         char *charptr = data;
 40         char buf[10], line[80];
 41 
 42         printk(KERN_DEBUG "%s: dump of %d bytes of data at 0x%p\n",
 43                 label, length, data);
 44         for (i = 0; i < length; i += 16) {
 45                 line[0] = 0;
 46                 for (j = 0; (j < 4) && (i + j * 4 < length); j++) {
 47                         sprintf(buf, " %08x", intptr[i / 4 + j]);
 48                         strcat(line, buf);
 49                 }
 50                 buf[0] = ' ';
 51                 buf[2] = 0;
 52                 for (j = 0; (j < 16) && (i + j < length); j++) {
 53                         buf[1] = isprint(charptr[i + j]) ? charptr[i + j] : '.';
 54                         strcat(line, buf);
 55                 }
 56                 printk(KERN_DEBUG "%s\n", line);
 57         }
 58 }
 59 
 60 #ifdef CONFIG_CIFS_DEBUG2
 61 void cifs_dump_detail(struct smb_hdr *smb)
 62 {
 63         cERROR(1, ("Cmd: %d Err: 0x%x Flags: 0x%x Flgs2: 0x%x Mid: %d Pid: %d",
 64                   smb->Command, smb->Status.CifsError,
 65                   smb->Flags, smb->Flags2, smb->Mid, smb->Pid));
 66         cERROR(1, ("smb buf %p len %d", smb, smbCalcSize_LE(smb)));
 67 }
 68 
 69 
 70 void cifs_dump_mids(struct TCP_Server_Info *server)
 71 {
 72         struct list_head *tmp;
 73         struct mid_q_entry *mid_entry;
 74 
 75         if (server == NULL)
 76                 return;
 77 
 78         cERROR(1, ("Dump pending requests:"));
 79         spin_lock(&GlobalMid_Lock);
 80         list_for_each(tmp, &server->pending_mid_q) {
 81                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 82                 cERROR(1, ("State: %d Cmd: %d Pid: %d Tsk: %p Mid %d",
 83                         mid_entry->midState,
 84                         (int)mid_entry->command,
 85                         mid_entry->pid,
 86                         mid_entry->tsk,
 87                         mid_entry->mid));
 88 #ifdef CONFIG_CIFS_STATS2
 89                 cERROR(1, ("IsLarge: %d buf: %p time rcv: %ld now: %ld",
 90                         mid_entry->largeBuf,
 91                         mid_entry->resp_buf,
 92                         mid_entry->when_received,
 93                         jiffies));
 94 #endif /* STATS2 */
 95                 cERROR(1, ("IsMult: %d IsEnd: %d", mid_entry->multiRsp,
 96                           mid_entry->multiEnd));
 97                 if (mid_entry->resp_buf) {
 98                         cifs_dump_detail(mid_entry->resp_buf);
 99                         cifs_dump_mem("existing buf: ",
100                                 mid_entry->resp_buf, 62);
101                 }
102         }
103         spin_unlock(&GlobalMid_Lock);
104 }
105 #endif /* CONFIG_CIFS_DEBUG2 */
106 
107 #ifdef CONFIG_PROC_FS
108 static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
109 {
110         struct list_head *tmp1, *tmp2, *tmp3;
111         struct mid_q_entry *mid_entry;
112         struct TCP_Server_Info *server;
113         struct cifsSesInfo *ses;
114         struct cifsTconInfo *tcon;
115         int i, j;
116         __u32 dev_type;
117 
118         seq_puts(m,
119                     "Display Internal CIFS Data Structures for Debugging\n"
120                     "---------------------------------------------------\n");
121         seq_printf(m, "CIFS Version %s\n", CIFS_VERSION);
122         seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid);
123         seq_printf(m, "Servers:");
124 
125         i = 0;
126         read_lock(&cifs_tcp_ses_lock);
127         list_for_each(tmp1, &cifs_tcp_ses_list) {
128                 server = list_entry(tmp1, struct TCP_Server_Info,
129                                     tcp_ses_list);
130                 i++;
131                 list_for_each(tmp2, &server->smb_ses_list) {
132                         ses = list_entry(tmp2, struct cifsSesInfo,
133                                          smb_ses_list);
134                         if ((ses->serverDomain == NULL) ||
135                                 (ses->serverOS == NULL) ||
136                                 (ses->serverNOS == NULL)) {
137                                 seq_printf(m, "\n%d) entry for %s not fully "
138                                            "displayed\n\t", i, ses->serverName);
139                         } else {
140                                 seq_printf(m,
141                                     "\n%d) Name: %s  Domain: %s Uses: %d OS:"
142                                     " %s\n\tNOS: %s\tCapability: 0x%x\n\tSMB"
143                                     " session status: %d\t",
144                                 i, ses->serverName, ses->serverDomain,
145                                 ses->ses_count, ses->serverOS, ses->serverNOS,
146                                 ses->capabilities, ses->status);
147                         }
148                         seq_printf(m, "TCP status: %d\n\tLocal Users To "
149                                    "Server: %d SecMode: 0x%x Req On Wire: %d",
150                                    server->tcpStatus, server->srv_count,
151                                    server->secMode,
152                                    atomic_read(&server->inFlight));
153 
154 #ifdef CONFIG_CIFS_STATS2
155                         seq_printf(m, " In Send: %d In MaxReq Wait: %d",
156                                 atomic_read(&server->inSend),
157                                 atomic_read(&server->num_waiters));
158 #endif
159 
160                         seq_puts(m, "\n\tShares:");
161                         j = 0;
162                         list_for_each(tmp3, &ses->tcon_list) {
163                                 tcon = list_entry(tmp3, struct cifsTconInfo,
164                                                   tcon_list);
165                                 ++j;
166                                 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
167                                 seq_printf(m, "\n\t%d) %s Mounts: %d ", j,
168                                            tcon->treeName, tcon->tc_count);
169                                 if (tcon->nativeFileSystem) {
170                                         seq_printf(m, "Type: %s ",
171                                                    tcon->nativeFileSystem);
172                                 }
173                                 seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x"
174                                         "\nPathComponentMax: %d Status: 0x%d",
175                                         le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),
176                                         le32_to_cpu(tcon->fsAttrInfo.Attributes),
177                                         le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),
178                                         tcon->tidStatus);
179                                 if (dev_type == FILE_DEVICE_DISK)
180                                         seq_puts(m, " type: DISK ");
181                                 else if (dev_type == FILE_DEVICE_CD_ROM)
182                                         seq_puts(m, " type: CDROM ");
183                                 else
184                                         seq_printf(m, " type: %d ", dev_type);
185 
186                                 if (tcon->need_reconnect)
187                                         seq_puts(m, "\tDISCONNECTED ");
188                                 seq_putc(m, '\n');
189                         }
190 
191                         seq_puts(m, "\n\tMIDs:\n");
192 
193                         spin_lock(&GlobalMid_Lock);
194                         list_for_each(tmp3, &server->pending_mid_q) {
195                                 mid_entry = list_entry(tmp3, struct mid_q_entry,
196                                         qhead);
197                                 seq_printf(m, "\tState: %d com: %d pid:"
198                                                 " %d tsk: %p mid %d\n",
199                                                 mid_entry->midState,
200                                                 (int)mid_entry->command,
201                                                 mid_entry->pid,
202                                                 mid_entry->tsk,
203                                                 mid_entry->mid);
204                         }
205                         spin_unlock(&GlobalMid_Lock);
206                 }
207         }
208         read_unlock(&cifs_tcp_ses_lock);
209         seq_putc(m, '\n');
210 
211         /* BB add code to dump additional info such as TCP session info now */
212         return 0;
213 }
214 
215 static int cifs_debug_data_proc_open(struct inode *inode, struct file *file)
216 {
217         return single_open(file, cifs_debug_data_proc_show, NULL);
218 }
219 
220 static const struct file_operations cifs_debug_data_proc_fops = {
221         .owner          = THIS_MODULE,
222         .open           = cifs_debug_data_proc_open,
223         .read           = seq_read,
224         .llseek         = seq_lseek,
225         .release        = single_release,
226 };
227 
228 #ifdef CONFIG_CIFS_STATS
229 static ssize_t cifs_stats_proc_write(struct file *file,
230                 const char __user *buffer, size_t count, loff_t *ppos)
231 {
232         char c;
233         int rc;
234         struct list_head *tmp1, *tmp2, *tmp3;
235         struct TCP_Server_Info *server;
236         struct cifsSesInfo *ses;
237         struct cifsTconInfo *tcon;
238 
239         rc = get_user(c, buffer);
240         if (rc)
241                 return rc;
242 
243         if (c == '1' || c == 'y' || c == 'Y' || c == '') {
244 #ifdef CONFIG_CIFS_STATS2
245                 atomic_set(&totBufAllocCount, 0);
246                 atomic_set(&totSmBufAllocCount, 0);
247 #endif /* CONFIG_CIFS_STATS2 */
248                 read_lock(&cifs_tcp_ses_lock);
249                 list_for_each(tmp1, &cifs_tcp_ses_list) {
250                         server = list_entry(tmp1, struct TCP_Server_Info,
251                                             tcp_ses_list);
252                         list_for_each(tmp2, &server->smb_ses_list) {
253                                 ses = list_entry(tmp2, struct cifsSesInfo,
254                                                  smb_ses_list);
255                                 list_for_each(tmp3, &ses->tcon_list) {
256                                         tcon = list_entry(tmp3,
257                                                           struct cifsTconInfo,
258                                                           tcon_list);
259                                         atomic_set(&tcon->num_smbs_sent, 0);
260                                         atomic_set(&tcon->num_writes, 0);
261                                         atomic_set(&tcon->num_reads, 0);
262                                         atomic_set(&tcon->num_oplock_brks, 0);
263                                         atomic_set(&tcon->num_opens, 0);
264                                         atomic_set(&tcon->num_posixopens, 0);
265                                         atomic_set(&tcon->num_posixmkdirs, 0);
266                                         atomic_set(&tcon->num_closes, 0);
267                                         atomic_set(&tcon->num_deletes, 0);
268                                         atomic_set(&tcon->num_mkdirs, 0);
269                                         atomic_set(&tcon->num_rmdirs, 0);
270                                         atomic_set(&tcon->num_renames, 0);
271                                         atomic_set(&tcon->num_t2renames, 0);
272                                         atomic_set(&tcon->num_ffirst, 0);
273                                         atomic_set(&tcon->num_fnext, 0);
274                                         atomic_set(&tcon->num_fclose, 0);
275                                         atomic_set(&tcon->num_hardlinks, 0);
276                                         atomic_set(&tcon->num_symlinks, 0);
277                                         atomic_set(&tcon->num_locks, 0);
278                                 }
279                         }
280                 }
281                 read_unlock(&cifs_tcp_ses_lock);
282         }
283 
284         return count;
285 }
286 
287 static int cifs_stats_proc_show(struct seq_file *m, void *v)
288 {
289         int i;
290         struct list_head *tmp1, *tmp2, *tmp3;
291         struct TCP_Server_Info *server;
292         struct cifsSesInfo *ses;
293         struct cifsTconInfo *tcon;
294 
295         seq_printf(m,
296                         "Resources in use\nCIFS Session: %d\n",
297                         sesInfoAllocCount.counter);
298         seq_printf(m, "Share (unique mount targets): %d\n",
299                         tconInfoAllocCount.counter);
300         seq_printf(m, "SMB Request/Response Buffer: %d Pool size: %d\n",
301                         bufAllocCount.counter,
302                         cifs_min_rcv + tcpSesAllocCount.counter);
303         seq_printf(m, "SMB Small Req/Resp Buffer: %d Pool size: %d\n",
304                         smBufAllocCount.counter, cifs_min_small);
305 #ifdef CONFIG_CIFS_STATS2
306         seq_printf(m, "Total Large %d Small %d Allocations\n",
307                                 atomic_read(&totBufAllocCount),
308                                 atomic_read(&totSmBufAllocCount));
309 #endif /* CONFIG_CIFS_STATS2 */
310 
311         seq_printf(m, "Operations (MIDs): %d\n", midCount.counter);
312         seq_printf(m,
313                 "\n%d session %d share reconnects\n",
314                 tcpSesReconnectCount.counter, tconInfoReconnectCount.counter);
315 
316         seq_printf(m,
317                 "Total vfs operations: %d maximum at one time: %d\n",
318                 GlobalCurrentXid, GlobalMaxActiveXid);
319 
320         i = 0;
321         read_lock(&cifs_tcp_ses_lock);
322         list_for_each(tmp1, &cifs_tcp_ses_list) {
323                 server = list_entry(tmp1, struct TCP_Server_Info,
324                                     tcp_ses_list);
325                 list_for_each(tmp2, &server->smb_ses_list) {
326                         ses = list_entry(tmp2, struct cifsSesInfo,
327                                          smb_ses_list);
328                         list_for_each(tmp3, &ses->tcon_list) {
329                                 tcon = list_entry(tmp3,
330                                                   struct cifsTconInfo,
331                                                   tcon_list);
332                                 i++;
333                                 seq_printf(m, "\n%d) %s", i, tcon->treeName);
334                                 if (tcon->need_reconnect)
335                                         seq_puts(m, "\tDISCONNECTED ");
336                                 seq_printf(m, "\nSMBs: %d Oplock Breaks: %d",
337                                         atomic_read(&tcon->num_smbs_sent),
338                                         atomic_read(&tcon->num_oplock_brks));
339                                 seq_printf(m, "\nReads:  %d Bytes: %lld",
340                                         atomic_read(&tcon->num_reads),
341                                         (long long)(tcon->bytes_read));
342                                 seq_printf(m, "\nWrites: %d Bytes: %lld",
343                                         atomic_read(&tcon->num_writes),
344                                         (long long)(tcon->bytes_written));
345                                 seq_printf(m, "\nFlushes: %d",
346                                         atomic_read(&tcon->num_flushes));
347                                 seq_printf(m, "\nLocks: %d HardLinks: %d "
348                                               "Symlinks: %d",
349                                         atomic_read(&tcon->num_locks),
350                                         atomic_read(&tcon->num_hardlinks),
351                                         atomic_read(&tcon->num_symlinks));
352                                 seq_printf(m, "\nOpens: %d Closes: %d "
353                                               "Deletes: %d",
354                                         atomic_read(&tcon->num_opens),
355                                         atomic_read(&tcon->num_closes),
356                                         atomic_read(&tcon->num_deletes));
357                                 seq_printf(m, "\nPosix Opens: %d "
358                                               "Posix Mkdirs: %d",
359                                         atomic_read(&tcon->num_posixopens),
360                                         atomic_read(&tcon->num_posixmkdirs));
361                                 seq_printf(m, "\nMkdirs: %d Rmdirs: %d",
362                                         atomic_read(&tcon->num_mkdirs),
363                                         atomic_read(&tcon->num_rmdirs));
364                                 seq_printf(m, "\nRenames: %d T2 Renames %d",
365                                         atomic_read(&tcon->num_renames),
366                                         atomic_read(&tcon->num_t2renames));
367                                 seq_printf(m, "\nFindFirst: %d FNext %d "
368                                               "FClose %d",
369                                         atomic_read(&tcon->num_ffirst),
370                                         atomic_read(&tcon->num_fnext),
371                                         atomic_read(&tcon->num_fclose));
372                         }
373                 }
374         }
375         read_unlock(&cifs_tcp_ses_lock);
376 
377         seq_putc(m, '\n');
378         return 0;
379 }
380 
381 static int cifs_stats_proc_open(struct inode *inode, struct file *file)
382 {
383         return single_open(file, cifs_stats_proc_show, NULL);
384 }
385 
386 static const struct file_operations cifs_stats_proc_fops = {
387         .owner          = THIS_MODULE,
388         .open           = cifs_stats_proc_open,
389         .read           = seq_read,
390         .llseek         = seq_lseek,
391         .release        = single_release,
392         .write          = cifs_stats_proc_write,
393 };
394 #endif /* STATS */
395 
396 static struct proc_dir_entry *proc_fs_cifs;
397 static const struct file_operations cifsFYI_proc_fops;
398 static const struct file_operations cifs_oplock_proc_fops;
399 static const struct file_operations cifs_lookup_cache_proc_fops;
400 static const struct file_operations traceSMB_proc_fops;
401 static const struct file_operations cifs_multiuser_mount_proc_fops;
402 static const struct file_operations cifs_security_flags_proc_fops;
403 static const struct file_operations cifs_experimental_proc_fops;
404 static const struct file_operations cifs_linux_ext_proc_fops;
405 
406 void
407 cifs_proc_init(void)
408 {
409         proc_fs_cifs = proc_mkdir("fs/cifs", NULL);
410         if (proc_fs_cifs == NULL)
411                 return;
412 
413         proc_create("DebugData", 0, proc_fs_cifs, &cifs_debug_data_proc_fops);
414 
415 #ifdef CONFIG_CIFS_STATS
416         proc_create("Stats", 0, proc_fs_cifs, &cifs_stats_proc_fops);
417 #endif /* STATS */
418         proc_create("cifsFYI", 0, proc_fs_cifs, &cifsFYI_proc_fops);
419         proc_create("traceSMB", 0, proc_fs_cifs, &traceSMB_proc_fops);
420         proc_create("OplockEnabled", 0, proc_fs_cifs, &cifs_oplock_proc_fops);
421         proc_create("Experimental", 0, proc_fs_cifs,
422                     &cifs_experimental_proc_fops);
423         proc_create("LinuxExtensionsEnabled", 0, proc_fs_cifs,
424                     &cifs_linux_ext_proc_fops);
425         proc_create("MultiuserMount", 0, proc_fs_cifs,
426                     &cifs_multiuser_mount_proc_fops);
427         proc_create("SecurityFlags", 0, proc_fs_cifs,
428                     &cifs_security_flags_proc_fops);
429         proc_create("LookupCacheEnabled", 0, proc_fs_cifs,
430                     &cifs_lookup_cache_proc_fops);
431 }
432 
433 void
434 cifs_proc_clean(void)
435 {
436         if (proc_fs_cifs == NULL)
437                 return;
438 
439         remove_proc_entry("DebugData", proc_fs_cifs);
440         remove_proc_entry("cifsFYI", proc_fs_cifs);
441         remove_proc_entry("traceSMB", proc_fs_cifs);
442 #ifdef CONFIG_CIFS_STATS
443         remove_proc_entry("Stats", proc_fs_cifs);
444 #endif
445         remove_proc_entry("MultiuserMount", proc_fs_cifs);
446         remove_proc_entry("OplockEnabled", proc_fs_cifs);
447         remove_proc_entry("SecurityFlags", proc_fs_cifs);
448         remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);
449         remove_proc_entry("Experimental", proc_fs_cifs);
450         remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);
451         remove_proc_entry("fs/cifs", NULL);
452 }
453 
454 static int cifsFYI_proc_show(struct seq_file *m, void *v)
455 {
456         seq_printf(m, "%d\n", cifsFYI);
457         return 0;
458 }
459 
460 static int cifsFYI_proc_open(struct inode *inode, struct file *file)
461 {
462         return single_open(file, cifsFYI_proc_show, NULL);
463 }
464 
465 static ssize_t cifsFYI_proc_write(struct file *file, const char __user *buffer,
466                 size_t count, loff_t *ppos)
467 {
468         char c;
469         int rc;
470 
471         rc = get_user(c, buffer);
472         if (rc)
473                 return rc;
474         if (c == '' || c == 'n' || c == 'N')
475                 cifsFYI = 0;
476         else if (c == '1' || c == 'y' || c == 'Y')
477                 cifsFYI = 1;
478         else if ((c > '1') && (c <= '9'))
479                 cifsFYI = (int) (c - ''); /* see cifs_debug.h for meanings */
480 
481         return count;
482 }
483 
484 static const struct file_operations cifsFYI_proc_fops = {
485         .owner          = THIS_MODULE,
486         .open           = cifsFYI_proc_open,
487         .read           = seq_read,
488         .llseek         = seq_lseek,
489         .release        = single_release,
490         .write          = cifsFYI_proc_write,
491 };
492 
493 static int cifs_oplock_proc_show(struct seq_file *m, void *v)
494 {
495         seq_printf(m, "%d\n", oplockEnabled);
496         return 0;
497 }
498 
499 static int cifs_oplock_proc_open(struct inode *inode, struct file *file)
500 {
501         return single_open(file, cifs_oplock_proc_show, NULL);
502 }
503 
504 static ssize_t cifs_oplock_proc_write(struct file *file,
505                 const char __user *buffer, size_t count, loff_t *ppos)
506 {
507         char c;
508         int rc;
509 
510         rc = get_user(c, buffer);
511         if (rc)
512                 return rc;
513         if (c == '' || c == 'n' || c == 'N')
514                 oplockEnabled = 0;
515         else if (c == '1' || c == 'y' || c == 'Y')
516                 oplockEnabled = 1;
517 
518         return count;
519 }
520 
521 static const struct file_operations cifs_oplock_proc_fops = {
522         .owner          = THIS_MODULE,
523         .open           = cifs_oplock_proc_open,
524         .read           = seq_read,
525         .llseek         = seq_lseek,
526         .release        = single_release,
527         .write          = cifs_oplock_proc_write,
528 };
529 
530 static int cifs_experimental_proc_show(struct seq_file *m, void *v)
531 {
532         seq_printf(m, "%d\n", experimEnabled);
533         return 0;
534 }
535 
536 static int cifs_experimental_proc_open(struct inode *inode, struct file *file)
537 {
538         return single_open(file, cifs_experimental_proc_show, NULL);
539 }
540 
541 static ssize_t cifs_experimental_proc_write(struct file *file,
542                 const char __user *buffer, size_t count, loff_t *ppos)
543 {
544         char c;
545         int rc;
546 
547         rc = get_user(c, buffer);
548         if (rc)
549                 return rc;
550         if (c == '' || c == 'n' || c == 'N')
551                 experimEnabled = 0;
552         else if (c == '1' || c == 'y' || c == 'Y')
553                 experimEnabled = 1;
554         else if (c == '2')
555                 experimEnabled = 2;
556 
557         return count;
558 }
559 
560 static const struct file_operations cifs_experimental_proc_fops = {
561         .owner          = THIS_MODULE,
562         .open           = cifs_experimental_proc_open,
563         .read           = seq_read,
564         .llseek         = seq_lseek,
565         .release        = single_release,
566         .write          = cifs_experimental_proc_write,
567 };
568 
569 static int cifs_linux_ext_proc_show(struct seq_file *m, void *v)
570 {
571         seq_printf(m, "%d\n", linuxExtEnabled);
572         return 0;
573 }
574 
575 static int cifs_linux_ext_proc_open(struct inode *inode, struct file *file)
576 {
577         return single_open(file, cifs_linux_ext_proc_show, NULL);
578 }
579 
580 static ssize_t cifs_linux_ext_proc_write(struct file *file,
581                 const char __user *buffer, size_t count, loff_t *ppos)
582 {
583         char c;
584         int rc;
585 
586         rc = get_user(c, buffer);
587         if (rc)
588                 return rc;
589         if (c == '' || c == 'n' || c == 'N')
590                 linuxExtEnabled = 0;
591         else if (c == '1' || c == 'y' || c == 'Y')
592                 linuxExtEnabled = 1;
593 
594         return count;
595 }
596 
597 static const struct file_operations cifs_linux_ext_proc_fops = {
598         .owner          = THIS_MODULE,
599         .open           = cifs_linux_ext_proc_open,
600         .read           = seq_read,
601         .llseek         = seq_lseek,
602         .release        = single_release,
603         .write          = cifs_linux_ext_proc_write,
604 };
605 
606 static int cifs_lookup_cache_proc_show(struct seq_file *m, void *v)
607 {
608         seq_printf(m, "%d\n", lookupCacheEnabled);
609         return 0;
610 }
611 
612 static int cifs_lookup_cache_proc_open(struct inode *inode, struct file *file)
613 {
614         return single_open(file, cifs_lookup_cache_proc_show, NULL);
615 }
616 
617 static ssize_t cifs_lookup_cache_proc_write(struct file *file,
618                 const char __user *buffer, size_t count, loff_t *ppos)
619 {
620         char c;
621         int rc;
622 
623         rc = get_user(c, buffer);
624         if (rc)
625                 return rc;
626         if (c == '' || c == 'n' || c == 'N')
627                 lookupCacheEnabled = 0;
628         else if (c == '1' || c == 'y' || c == 'Y')
629                 lookupCacheEnabled = 1;
630 
631         return count;
632 }
633 
634 static const struct file_operations cifs_lookup_cache_proc_fops = {
635         .owner          = THIS_MODULE,
636         .open           = cifs_lookup_cache_proc_open,
637         .read           = seq_read,
638         .llseek         = seq_lseek,
639         .release        = single_release,
640         .write          = cifs_lookup_cache_proc_write,
641 };
642 
643 static int traceSMB_proc_show(struct seq_file *m, void *v)
644 {
645         seq_printf(m, "%d\n", traceSMB);
646         return 0;
647 }
648 
649 static int traceSMB_proc_open(struct inode *inode, struct file *file)
650 {
651         return single_open(file, traceSMB_proc_show, NULL);
652 }
653 
654 static ssize_t traceSMB_proc_write(struct file *file, const char __user *buffer,
655                 size_t count, loff_t *ppos)
656 {
657         char c;
658         int rc;
659 
660         rc = get_user(c, buffer);
661         if (rc)
662                 return rc;
663         if (c == '' || c == 'n' || c == 'N')
664                 traceSMB = 0;
665         else if (c == '1' || c == 'y' || c == 'Y')
666                 traceSMB = 1;
667 
668         return count;
669 }
670 
671 static const struct file_operations traceSMB_proc_fops = {
672         .owner          = THIS_MODULE,
673         .open           = traceSMB_proc_open,
674         .read           = seq_read,
675         .llseek         = seq_lseek,
676         .release        = single_release,
677         .write          = traceSMB_proc_write,
678 };
679 
680 static int cifs_multiuser_mount_proc_show(struct seq_file *m, void *v)
681 {
682         seq_printf(m, "%d\n", multiuser_mount);
683         return 0;
684 }
685 
686 static int cifs_multiuser_mount_proc_open(struct inode *inode, struct file *fh)
687 {
688         return single_open(fh, cifs_multiuser_mount_proc_show, NULL);
689 }
690 
691 static ssize_t cifs_multiuser_mount_proc_write(struct file *file,
692                 const char __user *buffer, size_t count, loff_t *ppos)
693 {
694         char c;
695         int rc;
696 
697         rc = get_user(c, buffer);
698         if (rc)
699                 return rc;
700         if (c == '' || c == 'n' || c == 'N')
701                 multiuser_mount = 0;
702         else if (c == '1' || c == 'y' || c == 'Y')
703                 multiuser_mount = 1;
704 
705         return count;
706 }
707 
708 static const struct file_operations cifs_multiuser_mount_proc_fops = {
709         .owner          = THIS_MODULE,
710         .open           = cifs_multiuser_mount_proc_open,
711         .read           = seq_read,
712         .llseek         = seq_lseek,
713         .release        = single_release,
714         .write          = cifs_multiuser_mount_proc_write,
715 };
716 
717 static int cifs_security_flags_proc_show(struct seq_file *m, void *v)
718 {
719         seq_printf(m, "0x%x\n", extended_security);
720         return 0;
721 }
722 
723 static int cifs_security_flags_proc_open(struct inode *inode, struct file *file)
724 {
725         return single_open(file, cifs_security_flags_proc_show, NULL);
726 }
727 
728 static ssize_t cifs_security_flags_proc_write(struct file *file,
729                 const char __user *buffer, size_t count, loff_t *ppos)
730 {
731         unsigned int flags;
732         char flags_string[12];
733         char c;
734 
735         if ((count < 1) || (count > 11))
736                 return -EINVAL;
737 
738         memset(flags_string, 0, 12);
739 
740         if (copy_from_user(flags_string, buffer, count))
741                 return -EFAULT;
742 
743         if (count < 3) {
744                 /* single char or single char followed by null */
745                 c = flags_string[0];
746                 if (c == '' || c == 'n' || c == 'N') {
747                         extended_security = CIFSSEC_DEF; /* default */
748                         return count;
749                 } else if (c == '1' || c == 'y' || c == 'Y') {
750                         extended_security = CIFSSEC_MAX;
751                         return count;
752                 } else if (!isdigit(c)) {
753                         cERROR(1, ("invalid flag %c", c));
754                         return -EINVAL;
755                 }
756         }
757         /* else we have a number */
758 
759         flags = simple_strtoul(flags_string, NULL, 0);
760 
761         cFYI(1, ("sec flags 0x%x", flags));
762 
763         if (flags <= 0)  {
764                 cERROR(1, ("invalid security flags %s", flags_string));
765                 return -EINVAL;
766         }
767 
768         if (flags & ~CIFSSEC_MASK) {
769                 cERROR(1, ("attempt to set unsupported security flags 0x%x",
770                         flags & ~CIFSSEC_MASK));
771                 return -EINVAL;
772         }
773         /* flags look ok - update the global security flags for cifs module */
774         extended_security = flags;
775         if (extended_security & CIFSSEC_MUST_SIGN) {
776                 /* requiring signing implies signing is allowed */
777                 extended_security |= CIFSSEC_MAY_SIGN;
778                 cFYI(1, ("packet signing now required"));
779         } else if ((extended_security & CIFSSEC_MAY_SIGN) == 0) {
780                 cFYI(1, ("packet signing disabled"));
781         }
782         /* BB should we turn on MAY flags for other MUST options? */
783         return count;
784 }
785 
786 static const struct file_operations cifs_security_flags_proc_fops = {
787         .owner          = THIS_MODULE,
788         .open           = cifs_security_flags_proc_open,
789         .read           = seq_read,
790         .llseek         = seq_lseek,
791         .release        = single_release,
792         .write          = cifs_security_flags_proc_write,
793 };
794 #else
795 inline void cifs_proc_init(void)
796 {
797 }
798 
799 inline void cifs_proc_clean(void)
800 {
801 }
802 #endif /* PROC_FS */
803 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp