]> git.ipfire.org Git - people/teissler/ipfire-2.x.git/blob - src/patches/suse-2.6.27.31/patches.suse/convert-novfs-to-open-soure-coding-standards.patch
projects / people / teissler / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Reenabled linux-xen, added patches for Xen Kernel Version 2.6.27.31,
[people/teissler/ipfire-2.x.git] / src / patches / suse-2.6.27.31 / patches.suse / convert-novfs-to-open-soure-coding-standards.patch
1 From rgoldwyn@suse.de Tue Jun 10 15:41:39 2008
2 From: Goldwyn Rodrigues <rgoldwyn@suse.de>
3 Date: Tue Jun 10 14:22:41 IST 2008
4 Subject: Convert novfs to open soure coding standards
5 Message-ID: <1213088555.4964.9.camel@baloo.junglebook>
6
7
8 Convert novfs to open source coding standards. Summary -
9 - convert structures from typedefs to structures
10 - change function names
11 - remove unused functions
12 - use correct structures in function prototypes instead of void
13 pointers
14 - return immediately on error (such as ENOMEM), instead of
15 creating enclosing in if..else code blocks for better
16 understanding.
17
18 Signed-off-by: Goldwyn Rodrigues <rgoldwyn@suse.de>
19 Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
20
21 ---
22 fs/novfs/commands.h | 818 ++++++--------
23 fs/novfs/daemon.c | 1031 ++++++------------
24 fs/novfs/file.c | 894 ++++++++-------
25 fs/novfs/inode.c | 2950 ++++++++++++++++++----------------------------------
26 fs/novfs/nwcapi.c | 2888 ++++++++++++++++++++++----------------------------
27 fs/novfs/nwcapi.h | 1019 +----------------
28 fs/novfs/proc.c | 85 -
29 fs/novfs/profile.c | 169 +-
30 fs/novfs/scope.c | 362 +++---
31 fs/novfs/vfs.h | 406 +++----
32 10 files changed, 4133 insertions(+), 6489 deletions(-)
33
34 --- a/fs/novfs/commands.h
35 +++ b/fs/novfs/commands.h
36 @@ -126,11 +126,7 @@
37
38 #pragma pack(push, 1)
39
40 -#ifndef NWHANDLE
41 -typedef void *NWHANDLE;
42 -#endif
43 -
44 -/*typedef struct _ncl_string
45 +/*struct _ncl_string
46 {
47 unsigned int type;
48 unsigned char *buffer;
49 @@ -138,206 +134,127 @@ typedef void *NWHANDLE;
50
51 } NclString, *PNclString;
52 */
53 -typedef struct _ncl_string {
54 +struct ncl_string {
55 unsigned int type;
56 unsigned char *buffer;
57 u32 len;
58 +};
59
60 -} NclString, *PNclString;
61 -
62 -typedef struct _nwd_string {
63 +struct nwd_string {
64 unsigned int type;
65 unsigned int len;
66 unsigned int boffset;
67 +};
68
69 -} NwdString, *PNwdString;
70 -
71 -typedef struct _COMMAND_REQUEST_HEADER {
72 +struct novfs_command_request_header {
73 unsigned int CommandType;
74 unsigned long SequenceNumber;
75 - struct schandle SessionId;
76 -} COMMAND_REQUEST_HEADER, *PCOMMAND_REQUEST_HEADER;
77 + struct novfs_schandle SessionId;
78 +
79 +};
80
81 -typedef struct _COMMAND_REPLY_HEADER {
82 +struct novfs_command_reply_header {
83 unsigned long Sequence_Number;
84 unsigned int ErrorCode;
85
86 -} COMMAND_REPLY_HEADER, *PCOMMAND_REPLY_HEADER;
87 +};
88
89 -typedef struct _CLOSE_REQUEST {
90 - COMMAND_REQUEST_HEADER Command;
91 - NWHANDLE FileHandle;
92 -} CLOSE_REQUEST, *PCLOSE_REQUEST;
93 -
94 -typedef struct _CLOSE_REPLY {
95 - COMMAND_REPLY_HEADER Reply;
96 -} CLOSE_REPLY, *PCLOSE_REPLY;
97
98 -typedef struct _DELETE_FILE_REQUEST {
99 - COMMAND_REQUEST_HEADER Command;
100 +struct novfs_delete_file_request {
101 + struct novfs_command_request_header Command;
102 unsigned int isDirectory;
103 unsigned int pathlength;
104 unsigned char path[1];
105 -} DELETE_FILE_REQUEST, *PDELETE_FILE_REQUEST;
106 +};
107
108 -typedef struct _DELETE_FILE_REPLY {
109 - COMMAND_REPLY_HEADER Reply;
110 -} DELETE_FILE_REPLY, *PDELETE_FILE_REPLY;
111 -
112 -typedef struct _FLUSH_REQUEST {
113 - COMMAND_REQUEST_HEADER Command;
114 - NWHANDLE FileHandle;
115 -} FLUSH_REQUEST, *PFLUSH_REQUEST;
116 -
117 -typedef struct _FLUSH_REPLY {
118 - COMMAND_REPLY_HEADER Reply;
119 -} FLUSH_REPLY, *PFLUSH_REPLY;
120 -
121 -typedef struct _GET_FILEINFO_REQUEST {
122 - COMMAND_REQUEST_HEADER Command;
123 - NWHANDLE FileHandle;
124 -} GET_FILEINFO_REQUEST, *PGET_FILEINFO_REQUEST;
125 -
126 -typedef struct _GET_FILEINFO_REPLY {
127 - COMMAND_REPLY_HEADER Reply;
128 -} GET_FILEINFO_REPLY, *PGET_FILEINFO_REPLY;
129 -
130 -typedef struct _GET_CONNECTED_SERVER_LIST_REQUEST {
131 - COMMAND_REQUEST_HEADER Command;
132 -} GET_CONNECTED_SERVER_LIST_REQUEST, *PGET_CONNECTED_SERVER_LIST_REQUEST;
133 +struct novfs_delete_file_reply {
134 + struct novfs_command_reply_header Reply;
135 +};
136 +
137 +struct novfs_get_connected_server_list {
138 + struct novfs_command_request_header Command;
139 +};
140
141 -typedef struct _GET_CONNECTED_SERVER_LIST_REPLY {
142 - COMMAND_REPLY_HEADER Reply;
143 +struct novfs_get_connected_server_list_reply {
144 + struct novfs_command_reply_header Reply;
145 unsigned char List[1];
146 -} GET_CONNECTED_SERVER_LIST_REPLY, *PGET_CONNECTED_SERVER_LIST_REPLY;
147 +};
148 +
149 +struct novfs_get_connected_server_list_request_ex {
150 + struct novfs_command_request_header Command;
151 +};
152
153 -typedef struct _GET_CONNECTED_SERVER_LIST_REQUEST_EX {
154 - COMMAND_REQUEST_HEADER Command;
155 -} GET_CONNECTED_SERVER_LIST_REQUEST_EX, *PGET_CONNECTED_SERVER_LIST_REQUEST_EX;
156 +struct novfs_get_connected_server_list_reply_ex {
157
158 -typedef struct _GET_CONNECTED_SERVER_LIST_REPLY_EX {
159 - COMMAND_REPLY_HEADER Reply;
160 + struct novfs_command_reply_header Reply;
161 unsigned int bufferLen;
162 unsigned char List[1];
163
164 -} GET_CONNECTED_SERVER_LIST_REPLY_EX, *PGET_CONNECTED_SERVER_LIST_REPLY_EX;
165 +};
166
167 -typedef struct _GET_SERVER_VOLUME_LIST_REQUEST {
168 - COMMAND_REQUEST_HEADER Command;
169 +struct novfs_get_server_volume_list {
170 + struct novfs_command_request_header Command;
171 unsigned int Length;
172 unsigned char Name[1];
173 -} GET_SERVER_VOLUME_LIST_REQUEST, *PGET_SERVER_VOLUME_LIST_REQUEST;
174 +};
175
176 -typedef struct _GET_SERVER_VOLUME_LIST_REPLY {
177 - COMMAND_REPLY_HEADER Reply;
178 +struct novfs_get_server_volume_list_reply {
179 + struct novfs_command_reply_header Reply;
180 unsigned char List[1];
181 -} GET_SERVER_VOLUME_LIST_REPLY, *PGET_SERVER_VOLUME_LIST_REPLY;
182 -
183 -typedef struct _OPEN_CONNECTION_BY_ADDR_REQUEST {
184 - COMMAND_REQUEST_HEADER Command;
185 - unsigned int address;
186 -
187 -} OPEN_CONNECTION_BY_ADDR_REQUEST, *POPEN_CONNECTION_BY_ADDR_REQUEST;
188 -
189 -typedef struct _OPEN_CONNECTION_BY_ADDR_REPLY {
190 - COMMAND_REPLY_HEADER Reply;
191 - unsigned char serverName[64];
192 - unsigned char treeName[64];
193 - NWHANDLE connHandle;
194 -
195 -} OPEN_CONNECTION_BY_ADDR_REPLY, *POPEN_CONNECTION_BY_ADDR_REPLY;
196 -
197 -typedef struct _OPEN_CONNECTION_BY_NAME_REQUEST {
198 - COMMAND_REQUEST_HEADER Command;
199 - unsigned int NameLen;
200 - unsigned char Name[1];
201 -
202 -} OPEN_CONNECTION_BY_NAME_REQUEST, *POPEN_CONNECTION_BY_NAME_REQUEST;
203 +};
204
205 -typedef struct _OPEN_CONNECTION_BY_NAME_REPLY {
206 - COMMAND_REPLY_HEADER Reply;
207 - unsigned char treeName[64];
208 - NWHANDLE connHandle;
209 -
210 -} OPEN_CONNECTION_BY_NAME_REPLY, *POPEN_CONNECTION_BY_NAME_REPLY;
211 -
212 -/*
213 -typedef struct _LOGIN_IDENTITY_REQUEST
214 -{
215 - COMMAND_REQUEST_HEADER Command;
216 - unsigned int treeFlags;
217 - unsigned char treeName[64];
218 - unsigned int serverFlags;
219 - unsigned char serverName[64];
220 - unsigned int userFlags;
221 - unsigned char userName[512];
222 - unsigned int passwordFlags;
223 - unsigned char password[128];
224 -
225 -} LOGIN_IDENTITY_REQUEST, *PLOGIN_IDENTITY_REQUEST;
226 -
227 -typedef struct _LOGIN_IDENTITY_REPLY
228 -{
229 - COMMAND_REPLY_HEADER Reply;
230 - unsigned char serverName[64];
231 - unsigned char treeName[64];
232 - NWHANDLE connHandle;
233 -
234 -} LOGIN_IDENTITY_REPLY, *PLOGIN_IDENTITY_REPLY;
235 -*/
236 -
237 -typedef struct _VERIFY_FILE_REQUEST {
238 - COMMAND_REQUEST_HEADER Command;
239 +struct novfs_verify_file_request {
240 + struct novfs_command_request_header Command;
241 unsigned int pathLen;
242 unsigned char path[1];
243
244 -} VERIFY_FILE_REQUEST, *PVERIFY_FILE_REQUEST;
245 +};
246
247 -typedef struct _VERIFY_FILE_REPLY {
248 - COMMAND_REPLY_HEADER Reply;
249 +struct novfs_verify_file_reply {
250 + struct novfs_command_reply_header Reply;
251 unsigned int lastAccessTime;
252 unsigned int modifyTime;
253 unsigned int createTime;
254 unsigned long long fileSize;
255 unsigned int fileMode;
256
257 -} VERIFY_FILE_REPLY, *PVERIFY_FILE_REPLY;
258 +};
259
260 -typedef struct _BEGIN_ENUMERATE_DIRECTORY_REQUEST {
261 - COMMAND_REQUEST_HEADER Command;
262 +struct novfs_begin_enumerate_directory_request {
263 + struct novfs_command_request_header Command;
264 unsigned int pathLen;
265 unsigned char path[1];
266
267 -} BEGIN_ENUMERATE_DIRECTORY_REQUEST, *PBEGIN_ENUMERATE_DIRECTORY_REQUEST;
268 +};
269
270 -typedef struct _BEGIN_ENUMERATE_DIRECTORY_REPLY {
271 - COMMAND_REPLY_HEADER Reply;
272 - HANDLE enumerateHandle;
273 +struct novfs_begin_enumerate_directory_reply {
274 + struct novfs_command_reply_header Reply;
275 + void *enumerateHandle;
276
277 -} BEGIN_ENUMERATE_DIRECTORY_REPLY, *PBEGIN_ENUMERATE_DIRECTORY_REPLY;
278 +};
279
280 -typedef struct _END_ENUMERATE_DIRECTORY_REQUEST {
281 - COMMAND_REQUEST_HEADER Command;
282 - HANDLE enumerateHandle;
283 +struct novfs_end_enumerate_directory_request {
284 + struct novfs_command_request_header Command;
285 + void *enumerateHandle;
286
287 -} END_ENUMERATE_DIRECTORY_REQUEST, *PEND_ENUMERATE_DIRECTORY_REQUEST;
288 +};
289
290 -typedef struct _END_ENUMERATE_DIRECTORY_REPLY {
291 - COMMAND_REPLY_HEADER Reply;
292 +struct novfs_end_enumerate_directory_reply {
293 + struct novfs_command_reply_header Reply;
294
295 -} END_ENUMERATE_DIRECTORY_REPLY, *PEND_ENUMERATE_DIRECTORY_REPLY;
296 +};
297
298 -typedef struct _ENUMERATE_DIRECTORY_REQUEST {
299 - COMMAND_REQUEST_HEADER Command;
300 - HANDLE enumerateHandle;
301 +struct novfs_enumerate_directory_request {
302 + struct novfs_command_request_header Command;
303 + void *enumerateHandle;
304 unsigned int pathLen;
305 unsigned char path[1];
306
307 -} ENUMERATE_DIRECTORY_REQUEST, *PENUMERATE_DIRECTORY_REQUEST;
308 +};
309
310 -typedef struct _ENUMERATE_DIRECTORY_REPLY {
311 - COMMAND_REPLY_HEADER Reply;
312 - HANDLE enumerateHandle;
313 +struct novfs_enumerate_directory_reply {
314 + struct novfs_command_reply_header Reply;
315 + void *enumerateHandle;
316 unsigned int lastAccessTime;
317 unsigned int modifyTime;
318 unsigned int createTime;
319 @@ -346,17 +263,17 @@ typedef struct _ENUMERATE_DIRECTORY_REPL
320 unsigned int nameLen;
321 unsigned char name[1];
322
323 -} ENUMERATE_DIRECTORY_REPLY, *PENUMERATE_DIRECTORY_REPLY;
324 +};
325
326 -typedef struct _ENUMERATE_DIRECTORY_EX_REQUEST {
327 - COMMAND_REQUEST_HEADER Command;
328 - HANDLE enumerateHandle;
329 +struct novfs_enumerate_directory_ex_request {
330 + struct novfs_command_request_header Command;
331 + void *enumerateHandle;
332 unsigned int pathLen;
333 unsigned char path[1];
334
335 -} ENUMERATE_DIRECTORY_EX_REQUEST, *PENUMERATE_DIRECTORY_EX_REQUEST;
336 +};
337
338 -typedef struct _ENUMERATE_DIRECTORY_EX_DATA {
339 +struct novfs_enumerate_directory_ex_data {
340 unsigned int length;
341 unsigned int lastAccessTime;
342 unsigned int modifyTime;
343 @@ -366,143 +283,130 @@ typedef struct _ENUMERATE_DIRECTORY_EX_D
344 unsigned int nameLen;
345 unsigned char name[1];
346
347 -} ENUMERATE_DIRECTORY_EX_DATA, *PENUMERATE_DIRECTORY_EX_DATA;
348 +};
349
350 -typedef struct _ENUMERATE_DIRECTORY_EX_REPLY {
351 - COMMAND_REPLY_HEADER Reply;
352 - HANDLE enumerateHandle;
353 +struct novfs_enumerate_directory_ex_reply {
354 + struct novfs_command_reply_header Reply;
355 + void *enumerateHandle;
356 unsigned int enumCount;
357
358 -} ENUMERATE_DIRECTORY_EX_REPLY, *PENUMERATE_DIRECTORY_EX_REPLY;
359 +};
360
361 -typedef struct _OPEN_FILE_REQUEST {
362 - COMMAND_REQUEST_HEADER Command;
363 +struct novfs_open_file_request {
364 + struct novfs_command_request_header Command;
365 unsigned int access; /* File Access */
366 unsigned int mode; /* Sharing Mode */
367 unsigned int disp; /* Create Disposition */
368 unsigned int pathLen;
369 unsigned char path[1];
370
371 -} OPEN_FILE_REQUEST, *POPEN_FILE_REQUEST;
372 +};
373
374 -typedef struct _OPEN_FILE_REPLY {
375 - COMMAND_REPLY_HEADER Reply;
376 - HANDLE handle;
377 +struct novfs_open_file_reply {
378 + struct novfs_command_reply_header Reply;
379 + void *handle;
380 unsigned int lastAccessTime;
381 unsigned int modifyTime;
382 unsigned int createTime;
383 unsigned int attributes;
384 loff_t size;
385
386 -} OPEN_FILE_REPLY, *POPEN_FILE_REPLY;
387 +};
388
389 -typedef struct _CREATE_FILE_REQUEST {
390 +struct novfs_create_file_request {
391
392 - COMMAND_REQUEST_HEADER Command;
393 + struct novfs_command_request_header Command;
394 unsigned int pathlength;
395 unsigned char path[1];
396
397 -} CREATE_FILE_REQUEST, *PCREATE_FILE_REQUEST;
398 +};
399
400 -typedef struct _CREATE_FILE_REPLY {
401 - COMMAND_REPLY_HEADER Reply;
402 +struct novfs_create_file_reply {
403 + struct novfs_command_reply_header Reply;
404
405 -} CREATE_FILE_REPLY, *PCREATE_FILE_REPLY;
406 +};
407
408 -typedef struct _CLOSE_FILE_REQUEST {
409 - COMMAND_REQUEST_HEADER Command;
410 - HANDLE handle;
411 +struct novfs_close_file_request {
412 + struct novfs_command_request_header Command;
413 + void *handle;
414
415 -} CLOSE_FILE_REQUEST, *PCLOSE_FILE_REQUEST;
416 +};
417
418 -typedef struct _CLOSE_FILE_REPLY {
419 - COMMAND_REPLY_HEADER Reply;
420 +struct novfs_close_file_reply {
421 + struct novfs_command_reply_header Reply;
422
423 -} CLOSE_FILE_REPLY, *PCLOSE_FILE_REPLY;
424 +};
425
426 -typedef struct _READ_FILE_REQUEST {
427 - COMMAND_REQUEST_HEADER Command;
428 - HANDLE handle;
429 +struct novfs_read_file_request {
430 + struct novfs_command_request_header Command;
431 + void *handle;
432 loff_t offset;
433 size_t len;
434
435 -} READ_FILE_REQUEST, *PREAD_FILE_REQUEST;
436 +};
437
438 -typedef struct _READ_FILE_REPLY {
439 - COMMAND_REPLY_HEADER Reply;
440 +struct novfs_read_file_reply {
441 + struct novfs_command_reply_header Reply;
442 unsigned long long bytesRead;
443 unsigned char data[1];
444
445 -} READ_FILE_REPLY, *PREAD_FILE_REPLY;
446 +};
447
448 -typedef struct _WRITE_FILE_REQUEST {
449 - COMMAND_REQUEST_HEADER Command;
450 - HANDLE handle;
451 +struct novfs_write_file_request {
452 + struct novfs_command_request_header Command;
453 + void *handle;
454 loff_t offset;
455 size_t len;
456 unsigned char data[1];
457
458 -} WRITE_FILE_REQUEST, *PWRITE_FILE_REQUEST;
459 +};
460
461 -typedef struct _WRITE_FILE_REPLY {
462 - COMMAND_REPLY_HEADER Reply;
463 +struct novfs_write_file_reply {
464 + struct novfs_command_reply_header Reply;
465 unsigned long long bytesWritten;
466 -} WRITE_FILE_REPLY, *PWRITE_FILE_REPLY;
467 +};
468
469 -typedef struct _READ_STREAM_REQUEST {
470 - COMMAND_REQUEST_HEADER Command;
471 - HANDLE connection;
472 +struct novfs_read_stream_request {
473 + struct novfs_command_request_header Command;
474 + void *connection;
475 unsigned char handle[6];
476 loff_t offset;
477 size_t len;
478 -} READ_STREAM_REQUEST, *PREAD_STREAM_REQUEST;
479 +};
480
481 -typedef struct _READ_STREAM_REPLY {
482 - COMMAND_REPLY_HEADER Reply;
483 +struct novfs_read_stream_reply {
484 + struct novfs_command_reply_header Reply;
485 size_t bytesRead;
486 unsigned char data[1];
487 -} READ_STREAM_REPLY, *PREAD_STREAM_REPLY;
488 +};
489
490 -typedef struct _WRITE_STREAM_REQUEST {
491 - COMMAND_REQUEST_HEADER Command;
492 - HANDLE connection;
493 +struct novfs_write_stream_request {
494 + struct novfs_command_request_header Command;
495 + void *connection;
496 unsigned char handle[6];
497 loff_t offset;
498 size_t len;
499 unsigned char data[1];
500 -} WRITE_STREAM_REQUEST, *PWRITE_STREAM_REQUEST;
501 +};
502
503 -typedef struct _WRITE_STREAM_REPLY {
504 - COMMAND_REPLY_HEADER Reply;
505 +struct novfs_write_stream_reply {
506 + struct novfs_command_reply_header Reply;
507 size_t bytesWritten;
508 -} WRITE_STREAM_REPLY, *PWRITE_STREAM_REPLY;
509 +};
510
511 -typedef struct _CLOSE_STREAM_REQUEST {
512 - COMMAND_REQUEST_HEADER Command;
513 - HANDLE connection;
514 +struct novfs_close_stream_request {
515 + struct novfs_command_request_header Command;
516 + void *connection;
517 unsigned char handle[6];
518 -} CLOSE_STREAM_REQUEST, *PCLOSE_STREAM_REQUEST;
519 +};
520
521 -typedef struct _CLOSE_STREAM_REPLY {
522 - COMMAND_REPLY_HEADER Reply;
523 +struct novfs_close_stream_reply {
524 + struct novfs_command_reply_header Reply;
525
526 -} CLOSE_STREAM_REPLY, *PCLOSE_STREAM_REPLY;
527 +};
528
529 -typedef struct _CREATE_DIRECTORY_REQUEST {
530 -
531 - COMMAND_REQUEST_HEADER Command;
532 - unsigned int pathlength;
533 - unsigned char path[1];
534 -
535 -} CREATE_DIRECTORY_REQUEST, *PCREATE_DIRECTORY_REQUEST;
536 -
537 -typedef struct _CREATE_DIRECTORY_REPLY {
538 - COMMAND_REPLY_HEADER Reply;
539 -
540 -} CREATE_DIRECTORY_REPLY, *PCREATE_DIRECTORY_REPLY;
541 -
542 -typedef struct _LOGIN_USER_REQUEST {
543 - COMMAND_REQUEST_HEADER Command;
544 +struct novfs_login_user_request {
545 + struct novfs_command_request_header Command;
546 unsigned int srvNameType;
547 unsigned int serverLength;
548 unsigned int serverOffset;
549 @@ -513,46 +417,47 @@ typedef struct _LOGIN_USER_REQUEST {
550 unsigned int passwordLength;
551 unsigned int passwordOffset;
552
553 -} LOGIN_USER_REQUEST, *PLOGIN_USER_REQUEST;
554 +};
555
556 -typedef struct _LOGIN_USER_REPLY {
557 - COMMAND_REPLY_HEADER Reply;
558 +struct novfs_login_user_reply {
559 + struct novfs_command_reply_header Reply;
560 unsigned int connectionHandle;
561 - HANDLE loginIdentity;
562 + void *loginIdentity;
563
564 -} LOGIN_USER_REPLY, *PLOGIN_USER_REPLY;
565 +};
566
567 -typedef struct _LOGOUT_REQUEST {
568 - COMMAND_REQUEST_HEADER Command;
569 +struct novfs_logout_request {
570 + struct novfs_command_request_header Command;
571 unsigned int length;
572 unsigned char Name[1];
573
574 -} LOGOUT_REQUEST, *PLOGOUT_REQUEST;
575 +};
576
577 -typedef struct _LOGOUT_REPLY {
578 - COMMAND_REPLY_HEADER Reply;
579 +struct novfs_logout_reply {
580 + struct novfs_command_reply_header Reply;
581
582 -} LOGOUT_REPLY, *PLOGOUT_REPLY;
583 +};
584
585 -typedef struct _CREATE_CONTEXT_REQUEST {
586 - COMMAND_REQUEST_HEADER Command;
587 +struct novfs_create_context_request {
588 + struct novfs_command_request_header Command;
589
590 -} CREATE_CONTEXT_REQUEST, *PCREATE_CONTEXT_REQUEST;
591 +};
592
593 -typedef struct _CREATE_CONTEXT_REPLY {
594 - COMMAND_REPLY_HEADER Reply;
595 - struct schandle SessionId;
596 -} CREATE_CONTEXT_REPLY, *PCREATE_CONTEXT_REPLY;
597 +struct novfs_create_context_reply {
598 + struct novfs_command_reply_header Reply;
599 + struct novfs_schandle SessionId;
600
601 -typedef struct _DESTROY_CONTEXT_REQUEST {
602 - COMMAND_REQUEST_HEADER Command;
603 +};
604
605 -} DESTROY_CONTEXT_REQUEST, *PDESTROY_CONTEXT_REQUEST;
606 +struct novfs_destroy_context_request {
607 + struct novfs_command_request_header Command;
608
609 -typedef struct _DESTROY_CONTEXT_REPLY {
610 - COMMAND_REPLY_HEADER Reply;
611 +};
612
613 -} DESTROY_CONTEXT_REPLY, *PDESTROY_CONTEXT_REPLY;
614 +struct novfs_destroy_context_reply {
615 + struct novfs_command_reply_header Reply;
616 +
617 +};
618
619 /*
620 * Attribute flags. These should be or-ed together to figure out what
621 @@ -572,7 +477,7 @@ typedef struct _DESTROY_CONTEXT_REPLY {
622 #define ATTR_ATTR_FLAG 1024
623 #endif
624
625 -typedef struct _LNX_FILE_INFO {
626 +struct novfs_lnx_file_info {
627 unsigned int ia_valid;
628 unsigned int ia_mode;
629 uid_t ia_uid;
630 @@ -582,126 +487,124 @@ typedef struct _LNX_FILE_INFO {
631 time_t ia_mtime;
632 time_t ia_ctime;
633 unsigned int ia_attr_flags;
634 +};
635
636 -} LX_FILE_INFO, *PLX_FILE_INFO;
637 -
638 -typedef struct _SET_FILE_INFO_REQUEST {
639 - COMMAND_REQUEST_HEADER Command;
640 - LX_FILE_INFO fileInfo;
641 +struct novfs_set_file_info_request {
642 + struct novfs_command_request_header Command;
643 + struct novfs_lnx_file_info fileInfo;
644 unsigned int pathlength;
645 char path[1];
646 +};
647
648 -} SET_FILE_INFO_REQUEST, *PSET_FILE_INFO_REQUEST;
649 -
650 -typedef struct _SET_FILE_INFO_REPLY {
651 - COMMAND_REPLY_HEADER Reply;
652 +struct novfs_set_file_info_reply {
653 + struct novfs_command_reply_header Reply;
654
655 -} SET_FILE_INFO_REPLY, *PSET_FILE_INFO_REPLY;
656 +};
657
658 -typedef struct _TRUNCATE_FILE_REQUEST {
659 - COMMAND_REQUEST_HEADER Command;
660 +struct novfs_truncate_file_request {
661 + struct novfs_command_request_header Command;
662 unsigned int pathLen;
663 char path[1];
664
665 -} TRUNCATE_FILE_REQUEST, *PTRUNCATE_FILE_REQUEST;
666 +};
667
668 -typedef struct _TRUNCATE_FILE_REPLY {
669 - COMMAND_REPLY_HEADER Reply;
670 +struct novfs_truncate_file_reply {
671 + struct novfs_command_reply_header Reply;
672
673 -} TRUNCATE_FILE_REPLY, *PTRUNCATE_FILE_REPLY;
674 +};
675
676 -typedef struct _GETPWUID_REQUEST {
677 - COMMAND_REQUEST_HEADER Command;
678 +struct novfs_getpwuid_request {
679 + struct novfs_command_request_header Command;
680 unsigned int uid;
681 -} GETPWUID_REQUEST, *PGETPWUID_REQUEST;
682 +};
683
684 -typedef struct _GETPWUID_REPLY {
685 - COMMAND_REPLY_HEADER Reply;
686 +struct novfs_getpwuid_reply {
687 + struct novfs_command_reply_header Reply;
688 unsigned char UserName[1];
689 -} GETPWUID_REPLY, *PGETPWUID_REPLY;
690 +};
691
692 -typedef struct _GET_VERSION_REQUEST {
693 - COMMAND_REQUEST_HEADER Command;
694 -} GET_VERSION_REQUEST, *PGET_VERSION_REQUEST;
695 +struct novfs_get_version_request {
696 + struct novfs_command_request_header Command;
697 +};
698
699 -typedef struct _GET_VERSION_REPLY {
700 - COMMAND_REPLY_HEADER Reply;
701 +struct novfs_get_version_reply {
702 + struct novfs_command_reply_header Reply;
703 unsigned char Version[1];
704 -} GET_VERSION_REPLY, *PGET_VERSION_REPLY;
705 +};
706
707 -typedef struct _SET_MOUNT_PATH {
708 - COMMAND_REQUEST_HEADER Command;
709 +struct novfs_set_mount_path {
710 + struct novfs_command_request_header Command;
711 unsigned int PathLength;
712 unsigned char Path[1];
713 -} SET_MOUNT_PATH_REQUEST, *PSET_MOUNT_PATH_REQUEST;
714 +};
715
716 -typedef struct _SET_MOUNT_PATH_REPLY {
717 - COMMAND_REPLY_HEADER Reply;
718 -} SET_MOUNT_PATH, *PSET_MOUNT_PATH_REPLY;
719 -
720 -typedef struct _GET_USER_SPACE {
721 - COMMAND_REQUEST_HEADER Command;
722 -} GET_USER_SPACE_REQUEST, *PGET_USER_SPACE_REQUEST;
723 +struct novfs_set_mount_path_reply {
724 + struct novfs_command_reply_header Reply;
725 +};
726 +
727 +struct novfs_get_user_space {
728 + struct novfs_command_request_header Command;
729 +};
730
731 -typedef struct _GET_USER_SPACE_REPLY {
732 - COMMAND_REPLY_HEADER Reply;
733 +struct novfs_get_user_space_reply {
734 + struct novfs_command_reply_header Reply;
735 uint64_t TotalSpace;
736 uint64_t FreeSpace;
737 uint64_t TotalEnties;
738 uint64_t FreeEnties;
739 -} GET_USER_SPACE_REPLY, *PGET_USER_SPACE_REPLY;
740 +};
741
742 -typedef struct _XPLAT_CALL_REQUEST {
743 - COMMAND_REQUEST_HEADER Command;
744 +struct novfs_xplat_call_request {
745 + struct novfs_command_request_header Command;
746 unsigned int NwcCommand;
747 unsigned long dataLen;
748 unsigned char data[1];
749
750 -} XPLAT_CALL_REQUEST, *PXPLAT_CALL_REQUEST;
751 +};
752
753 -typedef struct _XPLAT_CALL_REPLY {
754 - COMMAND_REPLY_HEADER Reply;
755 +struct novfs_xplat_call_reply {
756 + struct novfs_command_reply_header Reply;
757 unsigned long dataLen;
758 unsigned char data[1];
759
760 -} XPLAT_CALL_REPLY, *PXPLAT_CALL_REPLY;
761 +};
762
763 /* XPlat NWC structures used by the daemon */
764
765 -typedef struct _NWD_OPEN_CONN_BY_NAME {
766 - HANDLE ConnHandle;
767 +struct nwd_open_conn_by_name {
768 + void *ConnHandle;
769 unsigned int nameLen;
770 unsigned int oName; /* Ofset to the Name */
771 unsigned int serviceLen;
772 unsigned int oServiceType; /* Offset to service Type; */
773 unsigned int uConnFlags;
774 unsigned int uTranType;
775 - HANDLE newConnHandle;
776 + void *newConnHandle;
777
778 -} NwdCOpenConnByName, *PNwdCOpenConnByName;
779 +};
780
781 -typedef struct _NWD_TRAN_ADDR {
782 +struct nwd_tran_addr {
783 unsigned int uTransportType;
784 unsigned int uAddressLength;
785 unsigned int oAddress;
786
787 -} NwdCTranAddr, *PNwdCTranAddr;
788 +};
789
790 -typedef struct _NWD_OPEN_CONN_BY_ADDR {
791 - HANDLE ConnHandle;
792 +struct nwd_open_conn_by_addr {
793 + void *ConnHandle;
794 unsigned int oServiceType;
795 unsigned int uConnFlags;
796 - NwdCTranAddr TranAddr;
797 + struct nwd_tran_addr TranAddr;
798
799 -} NwdCOpenConnByAddr, *PNwdCOpenConnByAddr;
800 +};
801
802 -typedef struct _NWD_CLOSE_CONN {
803 - HANDLE ConnHandle;
804 +struct nwd_close_conn {
805 + void *ConnHandle;
806
807 -} NwdCCloseConn, *PNwdCCloseConn;
808 +};
809
810 -typedef struct _NWD_NCP_REQ {
811 - HANDLE ConnHandle;
812 +struct nwd_ncp_req {
813 + void *ConnHandle;
814 unsigned int replyLen;
815 unsigned int requestLen;
816 unsigned int function;
817 @@ -710,48 +613,37 @@ typedef struct _NWD_NCP_REQ {
818 unsigned int flags;
819 unsigned char data[1];
820
821 -} NwdCNCPReq, *PNwdCNCPReq;
822 +};
823
824 -typedef struct _NWD_NCP_REP {
825 +struct nwd_ncp_rep {
826 unsigned int replyLen;
827 unsigned char data[1];
828
829 -} NwdCNCPRep, *PNwdCNCPRep;
830 +};
831
832 -typedef struct _NWC_AUTH_WID {
833 - HANDLE ConnHandle;
834 +struct nwc_auth_wid {
835 + void *ConnHandle;
836 u32 AuthenticationId;
837
838 -} NwdCAuthenticateWithId, *PNwdCAuthenticateWithId;
839 +};
840
841 -typedef struct _NWC_AUTHENTICATE {
842 - HANDLE ConnHandle;
843 - unsigned int uAuthenticationType;
844 - unsigned int userNameOffset;
845 - unsigned int passwordOffset;
846 - unsigned int MaxInfoLength;
847 - unsigned int InfoLength;
848 - unsigned int authenInfoOffset;
849 -
850 -} NwdCAuthenticate, *PNwdCAuthenticate;
851 -
852 -typedef struct _NWC_UNAUTHENTICATE {
853 - HANDLE ConnHandle;
854 +struct nwc_unauthenticate {
855 + void *ConnHandle;
856 unsigned int AuthenticationId;
857
858 -} NwdCUnauthenticate, *PNwdCUnauthenticate;
859 +};
860
861 -typedef struct _NWC_LISC_ID {
862 - HANDLE ConnHandle;
863 +struct nwc_lisc_id {
864 + void *ConnHandle;
865
866 -} NwdCLicenseConn, *PNwdCLicenseConn;
867 +};
868
869 -typedef struct _NWC_UNLIC_CONN {
870 - HANDLE ConnHandle;
871 +struct nwc_unlic_conn {
872 + void *ConnHandle;
873
874 -} NwdCUnlicenseConn, *PNwdCUnlicenseConn;
875 +};
876
877 -typedef struct _NWC_GET_IDENT_INFO {
878 +struct nwd_get_id_info {
879 u32 AuthenticationId;
880 unsigned int AuthType;
881 unsigned int NameType;
882 @@ -762,44 +654,44 @@ typedef struct _NWC_GET_IDENT_INFO {
883 unsigned int objectLen;
884 unsigned int pObjectNameOffset;
885
886 -} NwdCGetIdentityInfo, *PNwdCGetIdentityInfo;
887 +};
888
889 -typedef struct _NWC_LO_ID {
890 +struct nwc_lo_id {
891 u32 AuthenticationId;
892
893 -} NwdCLogoutIdentity, *PNwdCLogoutIdentity;
894 +};
895
896 -typedef struct _RENAME_FILE_REQUEST {
897 - COMMAND_REQUEST_HEADER Command;
898 +struct novfs_rename_file_request {
899 + struct novfs_command_request_header Command;
900 int directoryFlag;
901 unsigned int newnameLen;
902 unsigned char newname[256];
903 unsigned int oldnameLen;
904 unsigned char oldname[256];
905 -} RENAME_FILE_REQUEST, *PRENAME_FILE_REQUEST;
906 +};
907
908 -typedef struct _RENAME_FILE_REPLY {
909 - COMMAND_REPLY_HEADER Reply;
910 +struct novfs_rename_file_reply {
911 + struct novfs_command_reply_header Reply;
912
913 -} RENAME_FILE_REPLY, *PRENAME_FILE_REPLY;
914 +};
915
916 -typedef struct __NwdServerVersion {
917 +struct nwd_server_version {
918 unsigned int uMajorVersion;
919 unsigned short int uMinorVersion;
920 unsigned short int uRevision;
921 +};
922
923 -} NwdServerVersion, *PNwdServerVersion;
924
925 #define MAX_ADDRESS_LENGTH 32
926
927 -typedef struct tagNwdTranAddrEx {
928 +struct tagNwdTranAddrEx {
929 unsigned int uTransportType;
930 unsigned int uAddressLength;
931 unsigned char Buffer[MAX_ADDRESS_LENGTH];
932
933 -} NwdTranAddr, *PNwdTranAddr;
934 +};
935
936 -typedef struct __NWD_CONN_INFO {
937 +struct __NWD_CONN_INFO {
938 unsigned int uInfoVersion;
939 unsigned int uAuthenticationState;
940 unsigned int uBroadcastState;
941 @@ -819,33 +711,31 @@ typedef struct __NWD_CONN_INFO {
942 unsigned int uDistance;
943 u32 uAuthId;
944 unsigned int uDisconnected;
945 - NwdServerVersion ServerVersion;
946 - NwdTranAddr TranAddress;
947 -
948 -} NwdConnInfo, *PNwdConnInfo;
949 + struct nwd_server_version ServerVersion;
950 + struct nwd_tran_addr TranAddress;
951 +};
952
953 -typedef struct _nwd_conn_info {
954 - HANDLE ConnHandle;
955 +struct nwd_conn_info {
956 + void *ConnHandle;
957 unsigned int uInfoLevel;
958 unsigned int uInfoLength;
959 +};
960
961 -} NwdCGetConnInfo, *PNwdCGetConnInfo;
962 -
963 -typedef struct nwd_open_conn_by_Ref {
964 - HANDLE uConnReference;
965 +struct nwd_open_conn_by_ref {
966 + void *uConnReference;
967 unsigned int uConnFlags;
968 - HANDLE ConnHandle;
969 + void *ConnHandle;
970
971 -} NwdCOpenConnByRef, *PNwdCOpenConnByRef;
972 +};
973
974 -typedef struct nwd_get_reqversion {
975 +struct nwd_get_reqversion {
976 unsigned int uMajorVersion;
977 unsigned int uMinorVersion;
978 unsigned int uRevision;
979
980 -} NwdCGetRequesterVersion, *PNwdCGetRequesterVersion;
981 +};
982
983 -typedef struct _nwc_scan_conn_info {
984 +struct nwd_scan_conn_info {
985 unsigned int uScanIndex;
986 unsigned int uScanInfoLevel;
987 unsigned int uScanInfoLen;
988 @@ -856,43 +746,43 @@ typedef struct _nwc_scan_conn_info {
989 unsigned int uConnectionReference;
990 unsigned int uReturnConnInfoOffset;
991
992 -} NwdCScanConnInfo, *PNwdCScanConnInfo;
993 +};
994
995 -typedef struct nwc_get_pref_ds_tree {
996 +struct nwd_get_pref_ds_tree {
997 unsigned int uTreeLength;
998 unsigned int DsTreeNameOffset;
999
1000 -} NwdCGetPreferredDsTree, *PNwdCGetPreferredDsTree;
1001 +};
1002
1003 -typedef struct nwc_set_pref_ds_tree {
1004 +struct nwd_set_pref_ds_tree {
1005 unsigned int uTreeLength;
1006 unsigned int DsTreeNameOffset;
1007
1008 -} NwdCSetPreferredDsTree, *PNwdCSetPreferredDsTree;
1009 +};
1010
1011 -typedef struct nwc_set_def_name_ctx {
1012 +struct nwd_set_def_name_ctx {
1013 unsigned int uTreeLength;
1014 unsigned int TreeOffset;
1015 unsigned int uNameLength;
1016 unsigned int NameContextOffset;
1017
1018 -} NwdCSetDefaultNameContext, *PNwdCSetDefaultNameContext;
1019 +};
1020
1021 -typedef struct nwc_get_def_name_ctx {
1022 +struct nwd_get_def_name_ctx {
1023 unsigned int uTreeLength;
1024 unsigned int TreeOffset;
1025 unsigned int uNameLength;
1026 unsigned int NameContextOffset;
1027
1028 -} NwdCGetDefaultNameContext, *PNwdCGetDefaultNameContext;
1029 +};
1030
1031 -typedef struct _nwc_get_treemonitored_connref {
1032 - NwdString TreeName;
1033 - HANDLE uConnReference;
1034 +struct nwd_get_tree_monitored_conn_ref {
1035 + struct nwd_string TreeName;
1036 + void *uConnReference;
1037
1038 -} NwdCGetTreeMonitoredConnRef, *PNwdCGetTreeMonitoredConnRef;
1039 +};
1040
1041 -typedef struct _nwc_enumerate_identities {
1042 +struct nwd_enum_ids {
1043 unsigned int Iterator;
1044 unsigned int domainNameLen;
1045 unsigned int domainNameOffset;
1046 @@ -904,9 +794,9 @@ typedef struct _nwc_enumerate_identities
1047 unsigned int IdentityFlags;
1048 u32 AuthenticationId;
1049
1050 -} NwdCDEnumerateIdentities, *PNwdCEnumerateIdentities;
1051 +};
1052
1053 -typedef struct nwd_change_key {
1054 +struct nwd_change_key {
1055 unsigned int domainNameOffset;
1056 unsigned int domainNameLen;
1057 unsigned int AuthType;
1058 @@ -919,82 +809,43 @@ typedef struct nwd_change_key {
1059 unsigned int newPasswordOffset;
1060 unsigned int newPasswordLen;
1061
1062 -} NwdCChangeKey, *PNwdCChangeKey;
1063 +};
1064
1065 -typedef struct _nwd_get_primary_conn {
1066 - HANDLE uConnReference;
1067 +struct nwd_set_primary_conn {
1068 + void *ConnHandle;
1069
1070 -} NwdCGetPrimaryConnection, *PNwdCGetPrimaryConnection;
1071 +};
1072
1073 -typedef struct _nwd_set_primary_conn {
1074 - HANDLE ConnHandle;
1075 -
1076 -} NwdCSetPrimaryConnection, *PNwdCSetPrimaryConnection;
1077 -
1078 -typedef struct _nwd_map_drive_ex {
1079 - u32 ConnHandle;
1080 - u32 localUid;
1081 - u32 linkOffsetLength;
1082 - u32 linkOffset;
1083 - u32 dirPathOffsetLength;
1084 - u32 dirPathOffset;
1085 -
1086 -} NwdCMapDriveEx, *PNwdCMapDriveEx;
1087 -
1088 -typedef struct _nwd_unmap_drive_ex {
1089 - unsigned int linkLen;
1090 - char linkPath[1];
1091 -
1092 -} NwdCUnmapDriveEx, *PNwdCUnmapDriveEx;
1093 -
1094 -typedef struct _nwd_enum_links {
1095 - unsigned int totalLen;
1096 - unsigned int linkCount;
1097 -
1098 -} NwdCEnumLinks, *PNwdCEnumLinks;
1099 -
1100 -typedef struct nwd_getbroadcastnotification {
1101 +struct nwd_get_bcast_notification {
1102 unsigned int uMessageFlags;
1103 - HANDLE uConnReference;
1104 + void *uConnReference;
1105 unsigned int messageLen;
1106 char message[1];
1107
1108 -} NwdCGetBroadcastNotification, *PNwdCGetBroadcastNotification;
1109 -
1110 -typedef struct _enum_entry {
1111 - unsigned int entryLen;
1112 - u32 connHdl;
1113 - char data[0];
1114 -} NwdCEnumEntry, *PNwdCEnumEntry;
1115 +};
1116
1117 -typedef struct _nwd_set_conn_info {
1118 - HANDLE ConnHandle;
1119 +struct nwd_set_conn_info {
1120 + void *ConnHandle;
1121 unsigned int uInfoLevel;
1122 unsigned int uInfoLength;
1123 unsigned int offsetConnInfo;
1124
1125 -} NwdCSetConnInfo, *PNwdCSetConnInfo;
1126 -
1127 -typedef struct _len_string {
1128 - u32 stLen;
1129 - char string[1];
1130 +};
1131
1132 -} LString, *PLString;
1133 -
1134 -typedef struct _DEBUG_REQUEST {
1135 - COMMAND_REQUEST_HEADER Command;
1136 +struct novfs_debug_request {
1137 + struct novfs_command_request_header Command;
1138 int cmdlen;
1139 char dbgcmd[1];
1140
1141 -} DEBUG_REQUEST, *PDEBUG_REQUEST;
1142 +};
1143
1144 -typedef struct _DEBUG_REPLY {
1145 - COMMAND_REPLY_HEADER Reply;
1146 +struct novfs_debug_reply {
1147 + struct novfs_command_reply_header Reply;
1148
1149 -} DEBUG_REPLY, *PDEBUG_REPLY;
1150 +};
1151
1152 -typedef struct _Nwd_Set_Key {
1153 - HANDLE ConnHandle;
1154 +struct nwd_set_key {
1155 + void *ConnHandle;
1156 unsigned int AuthenticationId;
1157 unsigned int objectNameLen;
1158 unsigned int objectNameOffset;
1159 @@ -1002,9 +853,9 @@ typedef struct _Nwd_Set_Key {
1160 unsigned int newPasswordLen;
1161 unsigned int newPasswordOffset;
1162
1163 -} NwdCSetKey, *PNwdCSetKey;
1164 +};
1165
1166 -typedef struct _Nwd_Verify_Key {
1167 +struct nwd_verify_key {
1168 unsigned int AuthType;
1169 unsigned int NameType;
1170 unsigned short int ObjectType;
1171 @@ -1015,43 +866,43 @@ typedef struct _Nwd_Verify_Key {
1172 unsigned int verifyPasswordLen;
1173 unsigned int verifyPasswordOffset;
1174
1175 -} NwdCVerifyKey, *PNwdCVerifyKey;
1176 +};
1177
1178 -typedef struct _GET_CACHE_FLAG {
1179 - COMMAND_REQUEST_HEADER Command;
1180 +struct novfs_get_cache_flag {
1181 + struct novfs_command_request_header Command;
1182 int pathLen;
1183 unsigned char path[0];
1184
1185 -} GET_CACHE_FLAG_REQUEST, *PGET_CACHE_FLAG_REQUEST;
1186 +};
1187
1188 -typedef struct _GET_CACHE_FLAG_REPLY {
1189 - COMMAND_REPLY_HEADER Reply;
1190 +struct novfs_get_cache_flag_reply {
1191 + struct novfs_command_reply_header Reply;
1192 int CacheFlag;
1193
1194 -} GET_CACHE_FLAG_REPLY, *PGET_CACHE_FLAG_REPLY;
1195 +};
1196
1197 -typedef struct _XA_LIST_REPLY {
1198 - COMMAND_REPLY_HEADER Reply;
1199 +struct novfs_xa_list_reply {
1200 + struct novfs_command_reply_header Reply;
1201 unsigned char *pData;
1202
1203 -} XA_LIST_REPLY, *PXA_LIST_REPLY;
1204 +};
1205
1206 -typedef struct _XA_GET_REQUEST {
1207 - COMMAND_REQUEST_HEADER Command;
1208 +struct novfs_xa_get_request {
1209 + struct novfs_command_request_header Command;
1210 unsigned int pathLen;
1211 unsigned int nameLen;
1212 unsigned char data[1]; //hold path, attribute name
1213
1214 -} XA_GET_REQUEST, *PXA_GET_REQUEST;
1215 +};
1216
1217 -typedef struct _XA_GET_REPLY {
1218 - COMMAND_REPLY_HEADER Reply;
1219 +struct novfs_xa_get_reply {
1220 + struct novfs_command_reply_header Reply;
1221 unsigned char *pData;
1222
1223 -} XA_GET_REPLY, *PXA_GET_REPLY;
1224 +};
1225
1226 -typedef struct _XA_SET_REQUEST {
1227 - COMMAND_REQUEST_HEADER Command;
1228 +struct novfs_xa_set_request {
1229 + struct novfs_command_request_header Command;
1230 unsigned int TtlWriteDataSize;
1231 unsigned int WritePosition;
1232 int flags;
1233 @@ -1060,27 +911,44 @@ typedef struct _XA_SET_REQUEST {
1234 unsigned int valueLen;
1235 unsigned char data[1]; //hold path, attribute name, value data
1236
1237 -} XA_SET_REQUEST, *PXA_SET_REQUEST;
1238 +};
1239
1240 -typedef struct _XA_SET_REPLY {
1241 - COMMAND_REPLY_HEADER Reply;
1242 +struct novfs_xa_set_reply {
1243 + struct novfs_command_reply_header Reply;
1244 unsigned char *pData;
1245
1246 -} XA_SET_REPLY, *PXA_SET_REPLY;
1247 +};
1248
1249 -typedef struct _SET_FILE_LOCK_REQUEST {
1250 - COMMAND_REQUEST_HEADER Command;
1251 - HANDLE handle;
1252 +struct novfs_set_file_lock_request {
1253 + struct novfs_command_request_header Command;
1254 + void *handle;
1255 unsigned char fl_type;
1256 loff_t fl_start;
1257 loff_t fl_len;
1258
1259 -} SET_FILE_LOCK_REQUEST, *PSET_FILE_LOCK_REQUEST;
1260 +};
1261 +
1262 +struct novfs_set_file_lock_reply {
1263 + struct novfs_command_reply_header Reply;
1264 +
1265 +};
1266
1267 -typedef struct _SET_FILE_LOCK_REPLY {
1268 - COMMAND_REPLY_HEADER Reply;
1269
1270 -} SET_FILE_LOCK_REPLY, *PSET_FILE_LOCK_REPLY;
1271 +struct novfs_scope_list{
1272 + struct list_head ScopeList;
1273 + struct novfs_schandle ScopeId;
1274 + struct novfs_schandle SessionId;
1275 + pid_t ScopePid;
1276 + struct task_struct *ScopeTask;
1277 + unsigned int ScopeHash;
1278 + uid_t ScopeUid;
1279 + uint64_t ScopeUSize;
1280 + uint64_t ScopeUFree;
1281 + uint64_t ScopeUTEnties;
1282 + uint64_t ScopeUAEnties;
1283 + int ScopeUserNameLength;
1284 + unsigned char ScopeUserName[32];
1285 +};
1286
1287 #pragma pack(pop)
1288
1289 --- a/fs/novfs/daemon.c
1290 +++ b/fs/novfs/daemon.c
1291 @@ -16,7 +16,6 @@
1292 #include <linux/module.h>
1293 #include <linux/fs.h>
1294 #include <linux/slab.h>
1295 -#include <linux/string.h>
1296 #include <linux/list.h>
1297 #include <linux/timer.h>
1298 #include <linux/poll.h>
1299 @@ -44,14 +43,13 @@
1300 #define DH_TYPE_STREAM 1
1301 #define DH_TYPE_CONNECTION 2
1302
1303 -/*===[ Type definitions ]=================================================*/
1304 -typedef struct _DAEMON_QUEUE {
1305 +struct daemon_queue {
1306 struct list_head list; /* Must be first entry */
1307 spinlock_t lock; /* Used to control access to list */
1308 struct semaphore semaphore; /* Used to signal when data is available */
1309 -} daemon_queue_t;
1310 +};
1311
1312 -typedef struct _DAEMON_COMMAND {
1313 +struct daemon_cmd {
1314 struct list_head list; /* Must be first entry */
1315 atomic_t reference;
1316 unsigned int status;
1317 @@ -65,61 +63,44 @@ typedef struct _DAEMON_COMMAND {
1318 int datalen;
1319 void *reply;
1320 unsigned long replen;
1321 -} daemon_command_t;
1322 +};
1323
1324 -typedef struct _DAEMON_HANDLE_ {
1325 +struct daemon_handle {
1326 struct list_head list;
1327 rwlock_t lock;
1328 - session_t session;
1329 -} daemon_handle_t;
1330 + struct novfs_schandle session;
1331 +};
1332
1333 -typedef struct _DAEMON_RESOURCE_ {
1334 +struct daemon_resource {
1335 struct list_head list;
1336 int type;
1337 - HANDLE connection;
1338 + void *connection;
1339 unsigned char handle[6];
1340 mode_t mode;
1341 loff_t size;
1342 -} daemon_resource_t;
1343 +};
1344
1345 -typedef struct _DRIVE_MAP_ {
1346 +struct drive_map {
1347 struct list_head list; /* Must be first item */
1348 - session_t session;
1349 + struct novfs_schandle session;
1350 unsigned long hash;
1351 int namelen;
1352 char name[1];
1353 -} drive_map_t;
1354 +};
1355 +
1356 +static void Queue_get(struct daemon_cmd * Que);
1357 +static void Queue_put(struct daemon_cmd * Que);
1358 +static void RemoveDriveMaps(void);
1359 +static int NwdConvertLocalHandle(struct novfs_xplat *pdata, struct daemon_handle * DHandle);
1360 +static int NwdConvertNetwareHandle(struct novfs_xplat *pdata, struct daemon_handle * DHandle);
1361 +static int set_map_drive(struct novfs_xplat *pdata, struct novfs_schandle Session);
1362 +static int unmap_drive(struct novfs_xplat *pdata, struct novfs_schandle Session);
1363 +static int NwdGetMountPath(struct novfs_xplat *pdata);
1364 +static int local_unlink(const char *pathname);
1365
1366 -/*===[ Function prototypes ]==============================================*/
1367 -int Daemon_Close_Control(struct inode *Inode, struct file *File);
1368 -int Daemon_Library_close(struct inode *inode, struct file *file);
1369 -int Daemon_Library_open(struct inode *inode, struct file *file);
1370 -loff_t Daemon_Library_llseek(struct file *file, loff_t offset, int origin);
1371 -int Daemon_Open_Control(struct inode *Inode, struct file *File);
1372 -uint Daemon_Poll(struct file *file, struct poll_table_struct *poll_table);
1373 -int Daemon_Remove_Resource(daemon_handle_t * DHandle, int Type, HANDLE CHandle,
1374 - unsigned long FHandle);
1375 -
1376 -int Daemon_SetMountPoint(char *Path);
1377 -void Daemon_Timer(unsigned long data);
1378 -int Daemon_getpwuid(uid_t uid, int unamelen, char *uname);
1379 -int Queue_Daemon_Command(void *request, unsigned long reqlen, void *data, int dlen,
1380 - void **reply, unsigned long * replen, int interruptible);
1381 -void Queue_get(daemon_command_t * que);
1382 -void Queue_put(daemon_command_t * que);
1383 -void Uninit_Daemon_Queue(void);
1384 -daemon_command_t *find_queue(unsigned long sequence);
1385 -daemon_command_t *get_next_queue(int Set_Queue_Waiting);
1386 -int NwdConvertNetwareHandle(PXPLAT pdata, daemon_handle_t * DHandle);
1387 -int NwdConvertLocalHandle(PXPLAT pdata, daemon_handle_t * DHandle);
1388 -int NwdGetMountPath(PXPLAT pdata);
1389 -static int NwdSetMapDrive(PXPLAT pdata, session_t Session);
1390 -static int NwdUnMapDrive(PXPLAT pdata, session_t Session);
1391 -void RemoveDriveMaps(void);
1392 -int local_unlink(const char *pathname);
1393
1394 /*===[ Global variables ]=================================================*/
1395 -static daemon_queue_t Daemon_Queue;
1396 +static struct daemon_queue Daemon_Queue;
1397
1398 static DECLARE_WAIT_QUEUE_HEAD(Read_waitqueue);
1399
1400 @@ -131,51 +112,24 @@ static unsigned long Daemon_Command_Time
1401 static DECLARE_MUTEX(DriveMapLock);
1402 static LIST_HEAD(DriveMapList);
1403
1404 -int MaxIoSize = PAGE_SIZE;
1405 +int novfs_max_iosize = PAGE_SIZE;
1406
1407 -void Init_Daemon_Queue(void)
1408 +void novfs_daemon_queue_init()
1409 {
1410 INIT_LIST_HEAD(&Daemon_Queue.list);
1411 spin_lock_init(&Daemon_Queue.lock);
1412 init_MUTEX_LOCKED(&Daemon_Queue.semaphore);
1413 }
1414
1415 -/*++======================================================================*/
1416 -void Uninit_Daemon_Queue(void)
1417 -/*
1418 - *
1419 - * Arguments:
1420 - *
1421 - * Returns:
1422 - *
1423 - * Abstract:
1424 - *
1425 - * Notes:
1426 - *
1427 - * Environment:
1428 - *
1429 - *========================================================================*/
1430 +void novfs_daemon_queue_exit(void)
1431 {
1432 /* Does nothing for now but we maybe should clear the queue. */
1433 }
1434
1435 /*++======================================================================*/
1436 -void Daemon_Timer(unsigned long data)
1437 -/*
1438 - *
1439 - * Arguments:
1440 - *
1441 - * Returns:
1442 - *
1443 - * Abstract:
1444 - *
1445 - * Notes:
1446 - *
1447 - * Environment:
1448 - *
1449 - *========================================================================*/
1450 +static void novfs_daemon_timer(unsigned long data)
1451 {
1452 - daemon_command_t *que = (daemon_command_t *) data;
1453 + struct daemon_cmd *que = (struct daemon_cmd *) data;
1454
1455 if (QUEUE_ACKED != que->status) {
1456 que->status = QUEUE_TIMEOUT;
1457 @@ -183,14 +137,14 @@ void Daemon_Timer(unsigned long data)
1458 up(&que->semaphore);
1459 }
1460
1461 -int Queue_Daemon_Command(void *request, unsigned long reqlen, void *data, int dlen,
1462 +/*++======================================================================*/
1463 +int Queue_Daemon_Command(void *request,
1464 + unsigned long reqlen,
1465 + void *data,
1466 + int dlen,
1467 void **reply, unsigned long * replen, int interruptible)
1468 -/*
1469 - * Arguments: void *request - pointer to the request that is to be sent. Needs to be kernel memory.
1470 - * int reqlen - length of the request.
1471 - *========================================================================*/
1472 {
1473 - daemon_command_t *que;
1474 + struct daemon_cmd *que;
1475 int retCode = 0;
1476 uint64_t ts1, ts2;
1477
1478 @@ -201,6 +155,7 @@ int Queue_Daemon_Command(void *request,
1479 if (atomic_read(&Daemon_Open_Count)) {
1480
1481 que = kmalloc(sizeof(*que), GFP_KERNEL);
1482 +
1483 DbgPrint("Queue_Daemon_Command: que=0x%p\n", que);
1484 if (que) {
1485 atomic_set(&que->reference, 0);
1486 @@ -211,7 +166,7 @@ int Queue_Daemon_Command(void *request,
1487
1488 que->sequence = atomic_inc_return(&Sequence);
1489
1490 - ((PCOMMAND_REQUEST_HEADER) request)->SequenceNumber =
1491 + ((struct novfs_command_request_header *) request)->SequenceNumber =
1492 que->sequence;
1493
1494 /*
1495 @@ -220,7 +175,7 @@ int Queue_Daemon_Command(void *request,
1496 init_timer(&que->timer);
1497 que->timer.expires = jiffies + (HZ * Daemon_Command_Timeout);
1498 que->timer.data = (unsigned long) que;
1499 - que->timer.function = Daemon_Timer;
1500 + que->timer.function = novfs_daemon_timer;
1501 add_timer(&que->timer);
1502
1503 /*
1504 @@ -317,41 +272,13 @@ int Queue_Daemon_Command(void *request,
1505 return (retCode);
1506 }
1507
1508 -/*++======================================================================*/
1509 -void Queue_get(daemon_command_t * Que)
1510 -/*
1511 - *
1512 - * Arguments:
1513 - *
1514 - * Returns:
1515 - *
1516 - * Abstract:
1517 - *
1518 - * Notes:
1519 - *
1520 - * Environment:
1521 - *
1522 - *========================================================================*/
1523 +static void Queue_get(struct daemon_cmd * Que)
1524 {
1525 DbgPrint("Queue_get: que=0x%p %d\n", Que, atomic_read(&Que->reference));
1526 atomic_inc(&Que->reference);
1527 }
1528
1529 -/*++======================================================================*/
1530 -void Queue_put(daemon_command_t * Que)
1531 -/*
1532 - *
1533 - * Arguments:
1534 - *
1535 - * Returns:
1536 - *
1537 - * Abstract:
1538 - *
1539 - * Notes:
1540 - *
1541 - * Environment:
1542 - *
1543 - *========================================================================*/
1544 +static void Queue_put(struct daemon_cmd * Que)
1545 {
1546
1547 DbgPrint("Queue_put: que=0x%p %d\n", Que, atomic_read(&Que->reference));
1548 @@ -373,35 +300,21 @@ void Queue_put(daemon_command_t * Que)
1549 }
1550 }
1551
1552 -/*++======================================================================*/
1553 -daemon_command_t *get_next_queue(int Set_Queue_Waiting)
1554 -/*
1555 - *
1556 - * Arguments:
1557 - *
1558 - * Returns:
1559 - *
1560 - * Abstract:
1561 - *
1562 - * Notes:
1563 - *
1564 - * Environment:
1565 - *
1566 - *========================================================================*/
1567 +struct daemon_cmd *get_next_queue(int Set_Queue_Waiting)
1568 {
1569 - daemon_command_t *que;
1570 + struct daemon_cmd *que;
1571
1572 DbgPrint("get_next_queue: que=0x%p\n", Daemon_Queue.list.next);
1573
1574 spin_lock(&Daemon_Queue.lock);
1575 - que = (daemon_command_t *) Daemon_Queue.list.next;
1576 + que = (struct daemon_cmd *) Daemon_Queue.list.next;
1577
1578 - while (que && (que != (daemon_command_t *) & Daemon_Queue.list.next)
1579 + while (que && (que != (struct daemon_cmd *) & Daemon_Queue.list.next)
1580 && (que->status != QUEUE_SENDING)) {
1581 - que = (daemon_command_t *) que->list.next;
1582 + que = (struct daemon_cmd *) que->list.next;
1583 }
1584
1585 - if ((NULL == que) || (que == (daemon_command_t *) & Daemon_Queue.list)
1586 + if ((NULL == que) || (que == (struct daemon_cmd *) & Daemon_Queue.list)
1587 || (que->status != QUEUE_SENDING)) {
1588 que = NULL;
1589 } else if (Set_Queue_Waiting) {
1590 @@ -418,36 +331,22 @@ daemon_command_t *get_next_queue(int Set
1591 return (que);
1592 }
1593
1594 -/*++======================================================================*/
1595 -daemon_command_t *find_queue(unsigned long sequence)
1596 -/*
1597 - *
1598 - * Arguments:
1599 - *
1600 - * Returns:
1601 - *
1602 - * Abstract:
1603 - *
1604 - * Notes:
1605 - *
1606 - * Environment:
1607 - *
1608 - *========================================================================*/
1609 +static struct daemon_cmd *find_queue(unsigned long sequence)
1610 {
1611 - daemon_command_t *que;
1612 + struct daemon_cmd *que;
1613
1614 DbgPrint("find_queue: 0x%x\n", sequence);
1615
1616 spin_lock(&Daemon_Queue.lock);
1617 - que = (daemon_command_t *) Daemon_Queue.list.next;
1618 + que = (struct daemon_cmd *) Daemon_Queue.list.next;
1619
1620 - while (que && (que != (daemon_command_t *) & Daemon_Queue.list.next)
1621 + while (que && (que != (struct daemon_cmd *) & Daemon_Queue.list.next)
1622 && (que->sequence != sequence)) {
1623 - que = (daemon_command_t *) que->list.next;
1624 + que = (struct daemon_cmd *) que->list.next;
1625 }
1626
1627 if ((NULL == que)
1628 - || (que == (daemon_command_t *) & Daemon_Queue.list.next)
1629 + || (que == (struct daemon_cmd *) & Daemon_Queue.list.next)
1630 || (que->sequence != sequence)) {
1631 que = NULL;
1632 }
1633 @@ -462,21 +361,7 @@ daemon_command_t *find_queue(unsigned lo
1634 return (que);
1635 }
1636
1637 -/*++======================================================================*/
1638 -int Daemon_Open_Control(struct inode *Inode, struct file *File)
1639 -/*
1640 - *
1641 - * Arguments:
1642 - *
1643 - * Returns:
1644 - *
1645 - * Abstract:
1646 - *
1647 - * Notes:
1648 - *
1649 - * Environment:
1650 - *
1651 - *========================================================================*/
1652 +int novfs_daemon_open_control(struct inode *Inode, struct file *File)
1653 {
1654 DbgPrint("Daemon_Open_Control: pid=%d Count=%d\n", current->pid,
1655 atomic_read(&Daemon_Open_Count));
1656 @@ -485,23 +370,9 @@ int Daemon_Open_Control(struct inode *In
1657 return (0);
1658 }
1659
1660 -/*++======================================================================*/
1661 -int Daemon_Close_Control(struct inode *Inode, struct file *File)
1662 -/*
1663 - *
1664 - * Arguments:
1665 - *
1666 - * Returns:
1667 - *
1668 - * Abstract:
1669 - *
1670 - * Notes:
1671 - *
1672 - * Environment:
1673 - *
1674 - *========================================================================*/
1675 +int novfs_daemon_close_control(struct inode *Inode, struct file *File)
1676 {
1677 - daemon_command_t *que;
1678 + struct daemon_cmd *que;
1679
1680 DbgPrint("Daemon_Close_Control: pid=%d Count=%d\n", current->pid,
1681 atomic_read(&Daemon_Open_Count));
1682 @@ -512,39 +383,39 @@ int Daemon_Close_Control(struct inode *I
1683 */
1684
1685 spin_lock(&Daemon_Queue.lock);
1686 - que = (daemon_command_t *) Daemon_Queue.list.next;
1687 + que = (struct daemon_cmd *) Daemon_Queue.list.next;
1688
1689 while (que
1690 - && (que != (daemon_command_t *) & Daemon_Queue.list.next)
1691 + && (que != (struct daemon_cmd *) & Daemon_Queue.list.next)
1692 && (que->status != QUEUE_DONE)) {
1693 que->status = QUEUE_TIMEOUT;
1694 up(&que->semaphore);
1695
1696 - que = (daemon_command_t *) que->list.next;
1697 + que = (struct daemon_cmd *) que->list.next;
1698 }
1699 spin_unlock(&Daemon_Queue.lock);
1700
1701 RemoveDriveMaps();
1702
1703 - Scope_Cleanup();
1704 + novfs_scope_cleanup();
1705 }
1706
1707 return (0);
1708 }
1709
1710 -ssize_t Daemon_Send_Command(struct file *file, char __user *buf, size_t len, loff_t * off)
1711 +ssize_t novfs_daemon_cmd_send(struct file * file, char *buf, size_t len, loff_t * off)
1712 {
1713 - daemon_command_t *que;
1714 + struct daemon_cmd *que;
1715 size_t retValue = 0;
1716 int Finished = 0;
1717 - struct data_list *dlist;
1718 + struct novfs_data_list *dlist;
1719 int i, dcnt, bcnt, ccnt, error;
1720 char *vadr;
1721 unsigned long cpylen;
1722
1723 DbgPrint("Daemon_Send_Command: %u %lld\n", len, *off);
1724 - if (len > MaxIoSize) {
1725 - MaxIoSize = len;
1726 + if (len > novfs_max_iosize) {
1727 + novfs_max_iosize = len;
1728 }
1729
1730 while (!Finished) {
1731 @@ -556,9 +427,9 @@ ssize_t Daemon_Send_Command(struct file
1732 retValue = len;
1733 }
1734 if (retValue > 0x80)
1735 - mydump(0x80, que->request);
1736 + novfs_dump(0x80, que->request);
1737 else
1738 - mydump(retValue, que->request);
1739 + novfs_dump(retValue, que->request);
1740
1741 cpylen = copy_to_user(buf, que->request, retValue);
1742 if (que->datalen && (retValue < len)) {
1743 @@ -599,10 +470,10 @@ ssize_t Daemon_Send_Command(struct file
1744 ("Daemon_Send_Command: Copy %d from 0x%p to 0x%p.\n",
1745 bcnt, vadr, buf);
1746 if (bcnt > 0x80)
1747 - mydump(0x80,
1748 + novfs_dump(0x80,
1749 vadr);
1750 else
1751 - mydump(bcnt,
1752 + novfs_dump(bcnt,
1753 vadr);
1754
1755 if (km_adr) {
1756 @@ -646,14 +517,14 @@ ssize_t Daemon_Send_Command(struct file
1757 return (retValue);
1758 }
1759
1760 -ssize_t Daemon_Receive_Reply(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
1761 +ssize_t novfs_daemon_recv_reply(struct file *file, const char *buf, size_t nbytes, loff_t * ppos)
1762 {
1763 - daemon_command_t *que;
1764 + struct daemon_cmd *que;
1765 size_t retValue = 0;
1766 void *reply;
1767 unsigned long sequence, cpylen;
1768
1769 - struct data_list *dlist;
1770 + struct novfs_data_list *dlist;
1771 char *vadr;
1772 int i;
1773
1774 @@ -727,9 +598,9 @@ ssize_t Daemon_Receive_Reply(struct file
1775 thiscopy);
1776
1777 if (thiscopy > 0x80)
1778 - mydump(0x80, vadr);
1779 + novfs_dump(0x80, vadr);
1780 else
1781 - mydump(thiscopy, vadr);
1782 + novfs_dump(thiscopy, vadr);
1783
1784 if (km_adr) {
1785 kunmap(dlist->page);
1786 @@ -743,17 +614,20 @@ ssize_t Daemon_Receive_Reply(struct file
1787 que->replen = retValue;
1788 } else {
1789 reply = kmalloc(nbytes, GFP_KERNEL);
1790 - DbgPrint("Daemon_Receive_Reply: reply=0x%p\n", reply);
1791 + DbgPrint("Daemon_Receive_Reply: reply=0x%p\n",
1792 + reply);
1793 if (reply) {
1794 retValue = nbytes;
1795 que->reply = reply;
1796 que->replen = nbytes;
1797
1798 - retValue -= copy_from_user(reply, buf, retValue);
1799 + retValue -=
1800 + copy_from_user(reply, buf,
1801 + retValue);
1802 if (retValue > 0x80)
1803 - mydump(0x80, reply);
1804 + novfs_dump(0x80, reply);
1805 else
1806 - mydump(retValue, reply);
1807 + novfs_dump(retValue, reply);
1808
1809 } else {
1810 retValue = -ENOMEM;
1811 @@ -775,10 +649,11 @@ ssize_t Daemon_Receive_Reply(struct file
1812 return (retValue);
1813 }
1814
1815 -int do_login(NclString *Server, NclString *Username, NclString *Password, HANDLE *lgnId, struct schandle *Session)
1816 +int novfs_do_login(struct ncl_string *Server, struct ncl_string *Username,
1817 +struct ncl_string *Password, void **lgnId, struct novfs_schandle *Session)
1818 {
1819 - PLOGIN_USER_REQUEST cmd;
1820 - PLOGIN_USER_REPLY reply;
1821 + struct novfs_login_user_request *cmd;
1822 + struct novfs_login_user_reply *reply;
1823 unsigned long replylen = 0;
1824 int retCode, cmdlen, datalen;
1825 unsigned char *data;
1826 @@ -812,8 +687,8 @@ int do_login(NclString *Server, NclStrin
1827 memcpy(data, Password->buffer, Password->len);
1828 data += Password->len;
1829
1830 - retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
1831 - &replylen, INTERRUPTIBLE);
1832 + retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
1833 + &replylen, INTERRUPTIBLE);
1834 if (reply) {
1835 if (reply->Reply.ErrorCode) {
1836 retCode = reply->Reply.ErrorCode;
1837 @@ -827,18 +702,18 @@ int do_login(NclString *Server, NclStrin
1838 }
1839 memset(cmd, 0, cmdlen);
1840 kfree(cmd);
1841 - return retCode;
1842 + return (retCode);
1843
1844 }
1845
1846 -int do_logout(struct qstr *Server, struct schandle *Session)
1847 +int novfs_daemon_logout(struct qstr *Server, struct novfs_schandle *Session)
1848 {
1849 - PLOGOUT_REQUEST cmd;
1850 - PLOGOUT_REPLY reply;
1851 + struct novfs_logout_request *cmd;
1852 + struct novfs_logout_reply *reply;
1853 unsigned long replylen = 0;
1854 int retCode, cmdlen;
1855
1856 - cmdlen = offsetof(LOGOUT_REQUEST, Name) + Server->len;
1857 + cmdlen = offsetof(struct novfs_logout_request, Name) + Server->len;
1858 cmd = kmalloc(cmdlen, GFP_KERNEL);
1859 if (!cmd)
1860 return -ENOMEM;
1861 @@ -849,7 +724,8 @@ int do_logout(struct qstr *Server, struc
1862 cmd->length = Server->len;
1863 memcpy(cmd->Name, Server->name, Server->len);
1864
1865 - retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
1866 + retCode =
1867 + Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
1868 if (reply) {
1869 if (reply->Reply.ErrorCode) {
1870 retCode = -EIO;
1871 @@ -861,24 +737,10 @@ int do_logout(struct qstr *Server, struc
1872
1873 }
1874
1875 -/*++======================================================================*/
1876 -int Daemon_getpwuid(uid_t uid, int unamelen, char *uname)
1877 -/*
1878 - *
1879 - * Arguments:
1880 - *
1881 - * Returns:
1882 - *
1883 - * Abstract:
1884 - *
1885 - * Notes:
1886 - *
1887 - * Environment:
1888 - *
1889 - *========================================================================*/
1890 +int novfs_daemon_getpwuid(uid_t uid, int unamelen, char *uname)
1891 {
1892 - GETPWUID_REQUEST cmd;
1893 - PGETPWUID_REPLY reply;
1894 + struct novfs_getpwuid_request cmd;
1895 + struct novfs_getpwuid_reply *reply;
1896 unsigned long replylen = 0;
1897 int retCode;
1898
1899 @@ -896,7 +758,9 @@ int Daemon_getpwuid(uid_t uid, int uname
1900 } else {
1901 retCode = 0;
1902 memset(uname, 0, unamelen);
1903 - replylen = replylen - offsetof(GETPWUID_REPLY, UserName);
1904 + replylen =
1905 + replylen - offsetof(struct
1906 + novfs_getpwuid_reply, UserName);
1907 if (replylen) {
1908 if (replylen > unamelen) {
1909 retCode = -EINVAL;
1910 @@ -911,24 +775,10 @@ int Daemon_getpwuid(uid_t uid, int uname
1911
1912 }
1913
1914 -/*++======================================================================*/
1915 -int Daemon_getversion(char *Buf, int length)
1916 -/*
1917 - *
1918 - * Arguments:
1919 - *
1920 - * Returns:
1921 - *
1922 - * Abstract:
1923 - *
1924 - * Notes:
1925 - *
1926 - * Environment:
1927 - *
1928 - *========================================================================*/
1929 +int novfs_daemon_getversion(char *Buf, int length)
1930 {
1931 - GET_VERSION_REQUEST cmd;
1932 - PGET_VERSION_REPLY reply;
1933 + struct novfs_get_version_request cmd;
1934 + struct novfs_get_version_reply *reply;
1935 unsigned long replylen = 0;
1936 int retVal = 0;
1937
1938 @@ -942,7 +792,9 @@ int Daemon_getversion(char *Buf, int len
1939 if (reply->Reply.ErrorCode) {
1940 retVal = -EIO;
1941 } else {
1942 - retVal = replylen - offsetof(GET_VERSION_REPLY, Version);
1943 + retVal =
1944 + replylen - offsetof(struct
1945 + novfs_get_version_reply, Version);
1946 if (retVal < length) {
1947 memcpy(Buf, reply->Version, retVal);
1948 Buf[retVal] = '\0';
1949 @@ -954,13 +806,13 @@ int Daemon_getversion(char *Buf, int len
1950
1951 }
1952
1953 -static int daemon_login(struct login *Login, struct schandle *Session)
1954 +static int daemon_login(struct novfs_login *Login, struct novfs_schandle *Session)
1955 {
1956 int retCode = -ENOMEM;
1957 - struct login lLogin;
1958 - NclString server;
1959 - NclString username;
1960 - NclString password;
1961 + struct novfs_login lLogin;
1962 + struct ncl_string server;
1963 + struct ncl_string username;
1964 + struct ncl_string password;
1965
1966 if (!copy_from_user(&lLogin, Login, sizeof(lLogin))) {
1967 server.buffer = kmalloc(lLogin.Server.length, GFP_KERNEL);
1968 @@ -968,29 +820,29 @@ static int daemon_login(struct login *Lo
1969 server.len = lLogin.Server.length;
1970 server.type = NWC_STRING_TYPE_ASCII;
1971 if (!copy_from_user((void *)server.buffer, lLogin.Server.data, server.len)) {
1972 - username.buffer = kmalloc(lLogin.UserName.length, GFP_KERNEL);
1973 + username.buffer = kmalloc(lLogin.UserName.length, GFP_KERNEL);
1974 if (username.buffer) {
1975 username.len = lLogin.UserName.length;
1976 username.type = NWC_STRING_TYPE_ASCII;
1977 if (!copy_from_user((void *)username.buffer, lLogin.UserName.data, username.len)) {
1978 - password.buffer = kmalloc(lLogin.Password.length, GFP_KERNEL);
1979 - if (password.buffer) {
1980 + password.buffer = kmalloc(lLogin.Password.length, GFP_KERNEL);
1981 + if (password.buffer)
1982 + {
1983 password.len = lLogin.Password.length;
1984 password.type = NWC_STRING_TYPE_ASCII;
1985 if (!copy_from_user((void *)password.buffer, lLogin.Password.data, password.len)) {
1986 - retCode = do_login (&server, &username, &password, NULL, Session);
1987 + retCode = novfs_do_login (&server, &username, &password, NULL, Session);
1988 if (!retCode) {
1989 - char *name;
1990 - name = Scope_Get_UserName();
1991 - if (name)
1992 - Novfs_Add_to_Root(name);
1993 + char *username;
1994 + username = novfs_scope_get_username();
1995 + if (username) {
1996 + novfs_add_to_root(username);
1997 + }
1998 }
1999 }
2000 - memset(password.buffer, 0, password.len);
2001 kfree(password.buffer);
2002 }
2003 }
2004 - memset(username.buffer, 0, username.len);
2005 kfree(username.buffer);
2006 }
2007 }
2008 @@ -1001,32 +853,30 @@ static int daemon_login(struct login *Lo
2009 return (retCode);
2010 }
2011
2012 -static int daemon_logout(struct logout *Logout, struct schandle *Session)
2013 +static int daemon_logout(struct novfs_logout *Logout, struct novfs_schandle *Session)
2014 {
2015 - struct logout lLogout;
2016 + struct novfs_logout lLogout;
2017 struct qstr server;
2018 - int retCode = -ENOMEM;
2019 + int retCode = 0;
2020
2021 if (copy_from_user(&lLogout, Logout, sizeof(lLogout)))
2022 return -EFAULT;
2023 -
2024 server.name = kmalloc(lLogout.Server.length, GFP_KERNEL);
2025 if (!server.name)
2026 return -ENOMEM;
2027 server.len = lLogout.Server.length;
2028 if (copy_from_user((void *)server.name, lLogout.Server.data, server.len))
2029 goto exit;
2030 -
2031 - retCode = do_logout(&server, Session);
2032 + retCode = novfs_daemon_logout(&server, Session);
2033 exit:
2034 kfree(server.name);
2035 - return retCode;
2036 + return (retCode);
2037 }
2038
2039 -int Daemon_CreateSessionId(struct schandle *SessionId)
2040 +int novfs_daemon_create_sessionId(struct novfs_schandle * SessionId)
2041 {
2042 - CREATE_CONTEXT_REQUEST cmd;
2043 - PCREATE_CONTEXT_REPLY reply;
2044 + struct novfs_create_context_request cmd;
2045 + struct novfs_create_context_reply *reply;
2046 unsigned long replylen = 0;
2047 int retCode = 0;
2048
2049 @@ -1041,7 +891,7 @@ int Daemon_CreateSessionId(struct schand
2050 &replylen, INTERRUPTIBLE);
2051 if (reply) {
2052 if (!reply->Reply.ErrorCode
2053 - && replylen > sizeof(COMMAND_REPLY_HEADER)) {
2054 + && replylen > sizeof(struct novfs_command_reply_header)) {
2055 *SessionId = reply->SessionId;
2056 retCode = 0;
2057 } else {
2058 @@ -1055,26 +905,26 @@ int Daemon_CreateSessionId(struct schand
2059 return (retCode);
2060 }
2061
2062 -int Daemon_DestroySessionId(struct schandle *SessionId)
2063 +int novfs_daemon_destroy_sessionId(struct novfs_schandle SessionId)
2064 {
2065 - DESTROY_CONTEXT_REQUEST cmd;
2066 - PDESTROY_CONTEXT_REPLY reply;
2067 + struct novfs_destroy_context_request cmd;
2068 + struct novfs_destroy_context_reply *reply;
2069 unsigned long replylen = 0;
2070 int retCode = 0;
2071
2072 - DbgPrint("Daemon_DestroySessionId: 0x%p:%p\n",
2073 - SessionId->hTypeId, SessionId->hId);
2074 + DbgPrint("Daemon_DestroySessionId: 0x%p:%p\n", SessionId.hTypeId,
2075 + SessionId.hId);
2076
2077 cmd.Command.CommandType = VFS_COMMAND_DESTROY_CONTEXT;
2078 cmd.Command.SequenceNumber = 0;
2079 - memcpy(&cmd.Command.SessionId, SessionId, sizeof (*SessionId));
2080 + cmd.Command.SessionId = SessionId;
2081
2082 retCode =
2083 Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
2084 &replylen, INTERRUPTIBLE);
2085 if (reply) {
2086 if (!reply->Reply.ErrorCode) {
2087 - drive_map_t *dm;
2088 + struct drive_map *dm;
2089 struct list_head *list;
2090
2091 retCode = 0;
2092 @@ -1085,11 +935,8 @@ int Daemon_DestroySessionId(struct schan
2093 */
2094 down(&DriveMapLock);
2095 list_for_each(list, &DriveMapList) {
2096 - struct schandle *temp;
2097 -
2098 - dm = list_entry(list, drive_map_t, list);
2099 - temp = &dm->session;
2100 - if (SC_EQUAL(SessionId, temp)) {
2101 + dm = list_entry(list, struct drive_map, list);
2102 + if (SC_EQUAL(SessionId, dm->session)) {
2103 local_unlink(dm->name);
2104 list = list->prev;
2105 list_del(&dm->list);
2106 @@ -1107,21 +954,21 @@ int Daemon_DestroySessionId(struct schan
2107 return (retCode);
2108 }
2109
2110 -int Daemon_Get_UserSpace(struct schandle *SessionId, uint64_t * TotalSize,
2111 +int novfs_daemon_get_userspace(struct novfs_schandle SessionId, uint64_t * TotalSize,
2112 uint64_t * Free, uint64_t * TotalEnties,
2113 uint64_t * FreeEnties)
2114 {
2115 - GET_USER_SPACE_REQUEST cmd;
2116 - PGET_USER_SPACE_REPLY reply;
2117 + struct novfs_get_user_space cmd;
2118 + struct novfs_get_user_space_reply *reply;
2119 unsigned long replylen = 0;
2120 int retCode = 0;
2121
2122 - DbgPrint("Daemon_Get_UserSpace: 0x%p:%p\n",
2123 - SessionId->hTypeId, SessionId->hId);
2124 + DbgPrint("Daemon_Get_UserSpace: 0x%p:%p\n", SessionId.hTypeId,
2125 + SessionId.hId);
2126
2127 cmd.Command.CommandType = VFS_COMMAND_GET_USER_SPACE;
2128 cmd.Command.SequenceNumber = 0;
2129 - memcpy(&cmd.Command.SessionId, SessionId, sizeof (*SessionId));
2130 + cmd.Command.SessionId = SessionId;
2131
2132 retCode =
2133 Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
2134 @@ -1151,36 +998,22 @@ int Daemon_Get_UserSpace(struct schandle
2135 return (retCode);
2136 }
2137
2138 -/*++======================================================================*/
2139 -int Daemon_SetMountPoint(char *Path)
2140 -/*
2141 - *
2142 - * Arguments:
2143 - *
2144 - * Returns:
2145 - *
2146 - * Abstract:
2147 - *
2148 - * Notes:
2149 - *
2150 - * Environment:
2151 - *
2152 - *========================================================================*/
2153 +int novfs_daemon_set_mnt_point(char *Path)
2154 {
2155 - PSET_MOUNT_PATH_REQUEST cmd;
2156 - PSET_MOUNT_PATH_REPLY reply;
2157 + struct novfs_set_mount_path *cmd;
2158 + struct novfs_set_mount_path_reply *reply;
2159 unsigned long replylen, cmdlen;
2160 int retCode = -ENOMEM;
2161
2162 DbgPrint("Daemon_SetMountPoint: %s\n", Path);
2163
2164 replylen = strlen(Path);
2165 - cmdlen = sizeof(SET_MOUNT_PATH_REQUEST) + replylen;
2166 +
2167 + cmdlen = sizeof(struct novfs_set_mount_path) + replylen;
2168
2169 cmd = kmalloc(cmdlen, GFP_KERNEL);
2170 if (!cmd)
2171 return -ENOMEM;
2172 -
2173 cmd->Command.CommandType = VFS_COMMAND_SET_MOUNT_PATH;
2174 cmd->Command.SequenceNumber = 0;
2175 SC_INITIALIZE(cmd->Command.SessionId);
2176 @@ -1190,7 +1023,9 @@ int Daemon_SetMountPoint(char *Path)
2177
2178 replylen = 0;
2179
2180 - retCode = Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
2181 + retCode =
2182 + Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
2183 + &replylen, INTERRUPTIBLE);
2184 if (reply) {
2185 if (!reply->Reply.ErrorCode) {
2186 retCode = 0;
2187 @@ -1203,27 +1038,13 @@ int Daemon_SetMountPoint(char *Path)
2188 return retCode;
2189 }
2190
2191 -/*++======================================================================*/
2192 -int Daemon_SendDebugCmd(char *Command)
2193 -/*
2194 - *
2195 - * Arguments:
2196 - *
2197 - * Returns:
2198 - *
2199 - * Abstract:
2200 - *
2201 - * Notes:
2202 - *
2203 - * Environment:
2204 - *
2205 - *========================================================================*/
2206 -{
2207 - DEBUG_REQUEST cmd;
2208 - PDEBUG_REPLY reply;
2209 - DEBUG_REPLY lreply;
2210 +int novfs_daemon_debug_cmd_send(char *Command)
2211 +{
2212 + struct novfs_debug_request cmd;
2213 + struct novfs_debug_reply *reply;
2214 + struct novfs_debug_reply lreply;
2215 unsigned long replylen, cmdlen;
2216 - struct data_list dlist[2];
2217 + struct novfs_data_list dlist[2];
2218
2219 int retCode = -ENOMEM;
2220
2221 @@ -1239,7 +1060,7 @@ int Daemon_SendDebugCmd(char *Command)
2222 dlist[1].len = sizeof(lreply);
2223 dlist[1].rwflag = DLWRITE;
2224
2225 - cmdlen = offsetof(DEBUG_REQUEST, dbgcmd);
2226 + cmdlen = offsetof(struct novfs_debug_request, dbgcmd);
2227
2228 cmd.Command.CommandType = VFS_COMMAND_DBG;
2229 cmd.Command.SequenceNumber = 0;
2230 @@ -1248,7 +1069,9 @@ int Daemon_SendDebugCmd(char *Command)
2231
2232 replylen = 0;
2233
2234 - retCode = Queue_Daemon_Command(&cmd, cmdlen, dlist, 2, (void *)&reply, &replylen, INTERRUPTIBLE);
2235 + retCode =
2236 + Queue_Daemon_Command(&cmd, cmdlen, dlist, 2, (void *)&reply,
2237 + &replylen, INTERRUPTIBLE);
2238 if (reply) {
2239 kfree(reply);
2240 }
2241 @@ -1259,21 +1082,20 @@ int Daemon_SendDebugCmd(char *Command)
2242 return (retCode);
2243 }
2244
2245 -int Daemon_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2246 +int novfs_daemon_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2247 {
2248 int retCode = -ENOSYS;
2249 unsigned long cpylen;
2250 - struct schandle session_id;
2251 -
2252 - session_id = Scope_Get_SessionId(NULL);
2253 + struct novfs_schandle session_id;
2254 + session_id = novfs_scope_get_sessionId(NULL);
2255
2256 switch (cmd) {
2257 case IOC_LOGIN:
2258 - retCode = daemon_login((struct login *)arg, &session_id);
2259 + retCode = daemon_login((struct novfs_login *) arg, &session_id);
2260 break;
2261
2262 case IOC_LOGOUT:
2263 - retCode = daemon_logout((struct logout *) arg, &session_id);
2264 + retCode = daemon_logout((struct novfs_logout *)arg, &session_id);
2265 break;
2266 case IOC_DEBUGPRINT:
2267 {
2268 @@ -1302,7 +1124,7 @@ int Daemon_ioctl(struct inode *inode, st
2269
2270 case IOC_XPLAT:
2271 {
2272 - XPLAT data;
2273 + struct novfs_xplat data;
2274
2275 cpylen =
2276 copy_from_user(&data, (void *)arg, sizeof(data));
2277 @@ -1324,23 +1146,29 @@ int Daemon_ioctl(struct inode *inode, st
2278 return (retCode);
2279 }
2280
2281 -int Daemon_Added_Resource(daemon_handle_t *DHandle, int Type, HANDLE CHandle, unsigned char *FHandle, unsigned long Mode, unsigned long Size)
2282 +static int daemon_added_resource(struct daemon_handle * DHandle, int Type, void *CHandle,
2283 + unsigned char * FHandle, unsigned long Mode, u_long Size)
2284 {
2285 - daemon_resource_t *resource;
2286 + struct daemon_resource *resource;
2287
2288 if (FHandle)
2289 - DbgPrint("Daemon_Added_Resource: DHandle=0x%p Type=%d CHandle=0x%p FHandle=0x%x Mode=0x%x Size=%d\n", DHandle, Type, CHandle, *(u32 *) & FHandle[2], Mode, Size);
2290 + DbgPrint
2291 + ("Daemon_Added_Resource: DHandle=0x%p Type=%d CHandle=0x%p FHandle=0x%x Mode=0x%x Size=%d\n",
2292 + DHandle, Type, CHandle, *(u32 *) & FHandle[2], Mode, Size);
2293 else
2294 - DbgPrint("Daemon_Added_Resource: DHandle=0x%p Type=%d CHandle=0x%p\n", DHandle, Type, CHandle);
2295 + DbgPrint
2296 + ("Daemon_Added_Resource: DHandle=0x%p Type=%d CHandle=0x%p\n",
2297 + DHandle, Type, CHandle);
2298
2299 - resource = kmalloc(sizeof(daemon_resource_t), GFP_KERNEL);
2300 + resource = kmalloc(sizeof(struct daemon_resource), GFP_KERNEL);
2301 if (!resource)
2302 return -ENOMEM;
2303
2304 resource->type = Type;
2305 resource->connection = CHandle;
2306 if (FHandle)
2307 - memcpy(resource->handle, FHandle, sizeof(resource->handle));
2308 + memcpy(resource->handle, FHandle,
2309 + sizeof(resource->handle));
2310 else
2311 memset(resource->handle, 0, sizeof(resource->handle));
2312 resource->mode = Mode;
2313 @@ -1348,29 +1176,15 @@ int Daemon_Added_Resource(daemon_handle_
2314 write_lock(&DHandle->lock);
2315 list_add(&resource->list, &DHandle->list);
2316 write_unlock(&DHandle->lock);
2317 - DbgPrint("Daemon_Added_Resource: Adding resource=0x%p\n", resource);
2318 -
2319 + DbgPrint("Daemon_Added_Resource: Adding resource=0x%p\n",
2320 + resource);
2321 return 0;
2322 }
2323
2324 -/*++======================================================================*/
2325 -int Daemon_Remove_Resource(daemon_handle_t * DHandle, int Type, HANDLE CHandle,
2326 +static int daemon_remove_resource(struct daemon_handle * DHandle, int Type, void *CHandle,
2327 unsigned long FHandle)
2328 -/*
2329 - *
2330 - * Arguments:
2331 - *
2332 - * Returns:
2333 - *
2334 - * Abstract:
2335 - *
2336 - * Notes:
2337 - *
2338 - * Environment:
2339 - *
2340 - *========================================================================*/
2341 {
2342 - daemon_resource_t *resource;
2343 + struct daemon_resource *resource;
2344 struct list_head *l;
2345 int retVal = -ENOMEM;
2346
2347 @@ -1381,7 +1195,7 @@ int Daemon_Remove_Resource(daemon_handle
2348 write_lock(&DHandle->lock);
2349
2350 list_for_each(l, &DHandle->list) {
2351 - resource = list_entry(l, daemon_resource_t, list);
2352 + resource = list_entry(l, struct daemon_resource, list);
2353
2354 if ((Type == resource->type) &&
2355 (resource->connection == CHandle)) {
2356 @@ -1400,76 +1214,59 @@ int Daemon_Remove_Resource(daemon_handle
2357 return (retVal);
2358 }
2359
2360 -int Daemon_Library_open(struct inode *inode, struct file *file)
2361 +int novfs_daemon_lib_open(struct inode *inode, struct file *file)
2362 {
2363 - daemon_handle_t *dh;
2364 + struct daemon_handle *dh;
2365
2366 DbgPrint("Daemon_Library_open: inode=0x%p file=0x%p\n", inode, file);
2367 -
2368 - dh = kmalloc(sizeof(daemon_handle_t), GFP_KERNEL);
2369 + dh = kmalloc(sizeof(struct daemon_handle), GFP_KERNEL);
2370 if (!dh)
2371 return -ENOMEM;
2372 -
2373 file->private_data = dh;
2374 INIT_LIST_HEAD(&dh->list);
2375 rwlock_init(&dh->lock);
2376 - dh->session = Scope_Get_SessionId(NULL);
2377 -
2378 + dh->session = novfs_scope_get_sessionId(NULL);
2379 return 0;
2380 }
2381
2382 -/*++======================================================================*/
2383 -int Daemon_Library_close(struct inode *inode, struct file *file)
2384 -/*
2385 - *
2386 - * Arguments:
2387 - *
2388 - * Returns:
2389 - *
2390 - * Abstract:
2391 - *
2392 - * Notes:
2393 - *
2394 - * Environment:
2395 - *
2396 - *========================================================================*/
2397 +int novfs_daemon_lib_close(struct inode *inode, struct file *file)
2398 {
2399 - daemon_handle_t *dh;
2400 - daemon_resource_t *resource;
2401 + struct daemon_handle *dh;
2402 + struct daemon_resource *resource;
2403 struct list_head *l;
2404
2405 - char commanddata[sizeof(XPLAT_CALL_REQUEST) + sizeof(NwdCCloseConn)];
2406 - PXPLAT_CALL_REQUEST cmd;
2407 - PXPLAT_CALL_REPLY reply;
2408 - PNwdCCloseConn nwdClose;
2409 + char commanddata[sizeof(struct novfs_xplat_call_request) + sizeof(struct nwd_close_conn)];
2410 + struct novfs_xplat_call_request *cmd;
2411 + struct xplat_call_reply *reply;
2412 + struct nwd_close_conn *nwdClose;
2413 unsigned long cmdlen, replylen;
2414
2415 DbgPrint("Daemon_Library_close: inode=0x%p file=0x%p\n", inode, file);
2416 if (file->private_data) {
2417 - dh = (daemon_handle_t *) file->private_data;
2418 + dh = (struct daemon_handle *) file->private_data;
2419
2420 list_for_each(l, &dh->list) {
2421 - resource = list_entry(l, daemon_resource_t, list);
2422 + resource = list_entry(l, struct daemon_resource, list);
2423
2424 if (DH_TYPE_STREAM == resource->type) {
2425 - Novfs_Close_Stream(resource->connection,
2426 + novfs_close_stream(resource->connection,
2427 resource->handle,
2428 dh->session);
2429 } else if (DH_TYPE_CONNECTION == resource->type) {
2430 - cmd = (PXPLAT_CALL_REQUEST) commanddata;
2431 + cmd = (struct novfs_xplat_call_request *) commanddata;
2432 cmdlen =
2433 - offsetof(XPLAT_CALL_REQUEST,
2434 - data) + sizeof(NwdCCloseConn);
2435 + offsetof(struct novfs_xplat_call_request,
2436 + data) + sizeof(struct nwd_close_conn);
2437 cmd->Command.CommandType =
2438 VFS_COMMAND_XPLAT_CALL;
2439 cmd->Command.SequenceNumber = 0;
2440 cmd->Command.SessionId = dh->session;
2441 cmd->NwcCommand = NWC_CLOSE_CONN;
2442
2443 - cmd->dataLen = sizeof(NwdCCloseConn);
2444 - nwdClose = (PNwdCCloseConn) cmd->data;
2445 + cmd->dataLen = sizeof(struct nwd_close_conn);
2446 + nwdClose = (struct nwd_close_conn *) cmd->data;
2447 nwdClose->ConnHandle =
2448 - (HANDLE) resource->connection;
2449 + (void *) resource->connection;
2450
2451 Queue_Daemon_Command((void *)cmd, cmdlen, NULL,
2452 0, (void **)&reply,
2453 @@ -1488,10 +1285,11 @@ int Daemon_Library_close(struct inode *i
2454 return (0);
2455 }
2456
2457 -ssize_t Daemon_Library_read(struct file *file, char __user *buf, size_t len, loff_t *off)
2458 +ssize_t novfs_daemon_lib_read(struct file * file, char *buf, size_t len,
2459 + loff_t * off)
2460 {
2461 - daemon_handle_t *dh;
2462 - daemon_resource_t *resource;
2463 + struct daemon_handle *dh;
2464 + struct daemon_resource *resource;
2465
2466 size_t thisread, totalread = 0;
2467 loff_t offset = *off;
2468 @@ -1504,12 +1302,12 @@ ssize_t Daemon_Library_read(struct file
2469 read_lock(&dh->lock);
2470 if (&dh->list != dh->list.next) {
2471 resource =
2472 - list_entry(dh->list.next, daemon_resource_t, list);
2473 + list_entry(dh->list.next, struct daemon_resource, list);
2474
2475 if (DH_TYPE_STREAM == resource->type) {
2476 while (len > 0 && (offset < resource->size)) {
2477 thisread = len;
2478 - if (Novfs_Read_Stream
2479 + if (novfs_read_stream
2480 (resource->connection,
2481 resource->handle, buf, &thisread,
2482 &offset, 1, dh->session)
2483 @@ -1530,10 +1328,11 @@ ssize_t Daemon_Library_read(struct file
2484 return (totalread);
2485 }
2486
2487 -ssize_t Daemon_Library_write(struct file *file, const char __user *buf, size_t len, loff_t *off)
2488 +ssize_t novfs_daemon_lib_write(struct file * file, const char *buf, size_t len,
2489 + loff_t * off)
2490 {
2491 - daemon_handle_t *dh;
2492 - daemon_resource_t *resource;
2493 + struct daemon_handle *dh;
2494 + struct daemon_resource *resource;
2495
2496 size_t thiswrite, totalwrite = -EINVAL;
2497 loff_t offset = *off;
2498 @@ -1547,14 +1346,14 @@ ssize_t Daemon_Library_write(struct file
2499 write_lock(&dh->lock);
2500 if (&dh->list != dh->list.next) {
2501 resource =
2502 - list_entry(dh->list.next, daemon_resource_t, list);
2503 + list_entry(dh->list.next, struct daemon_resource, list);
2504
2505 if ((DH_TYPE_STREAM == resource->type) && (len >= 0)) {
2506 totalwrite = 0;
2507 do {
2508 thiswrite = len;
2509 status =
2510 - Novfs_Write_Stream(resource->
2511 + novfs_write_stream(resource->
2512 connection,
2513 resource->handle,
2514 (void *)buf,
2515 @@ -1590,24 +1389,10 @@ ssize_t Daemon_Library_write(struct file
2516 return (totalwrite);
2517 }
2518
2519 -/*++======================================================================*/
2520 -loff_t Daemon_Library_llseek(struct file * file, loff_t offset, int origin)
2521 -/*
2522 - *
2523 - * Arguments:
2524 - *
2525 - * Returns:
2526 - *
2527 - * Abstract:
2528 - *
2529 - * Notes:
2530 - *
2531 - * Environment:
2532 - *
2533 - *========================================================================*/
2534 +loff_t novfs_daemon_lib_llseek(struct file * file, loff_t offset, int origin)
2535 {
2536 - daemon_handle_t *dh;
2537 - daemon_resource_t *resource;
2538 + struct daemon_handle *dh;
2539 + struct daemon_resource *resource;
2540
2541 loff_t retVal = -EINVAL;
2542
2543 @@ -1619,7 +1404,7 @@ loff_t Daemon_Library_llseek(struct file
2544 read_lock(&dh->lock);
2545 if (&dh->list != dh->list.next) {
2546 resource =
2547 - list_entry(dh->list.next, daemon_resource_t, list);
2548 + list_entry(dh->list.next, struct daemon_resource, list);
2549
2550 if (DH_TYPE_STREAM == resource->type) {
2551 switch (origin) {
2552 @@ -1646,11 +1431,11 @@ loff_t Daemon_Library_llseek(struct file
2553 return retVal;
2554 }
2555
2556 -int Daemon_Library_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2557 +int novfs_daemon_lib_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2558 {
2559 int retCode = -ENOSYS;
2560 - daemon_handle_t *dh;
2561 - HANDLE handle = NULL;
2562 + struct daemon_handle *dh;
2563 + void *handle = NULL;
2564 unsigned long cpylen;
2565
2566 dh = file->private_data;
2567 @@ -1662,11 +1447,11 @@ int Daemon_Library_ioctl(struct inode *i
2568
2569 switch (cmd) {
2570 case IOC_LOGIN:
2571 - retCode = daemon_login((struct login *)arg, &dh->session);
2572 + retCode = daemon_login((struct novfs_login *)arg, &dh->session);
2573 break;
2574
2575 case IOC_LOGOUT:
2576 - retCode = daemon_logout((struct logout *)arg, &dh->session);
2577 + retCode = daemon_logout((struct novfs_logout *)arg, &dh->session);
2578 break;
2579
2580 case IOC_DEBUGPRINT:
2581 @@ -1681,10 +1466,14 @@ int Daemon_Library_ioctl(struct inode *i
2582 copy_from_user(&io, (void *)arg,
2583 sizeof(io));
2584 if (io.length) {
2585 - buf = kmalloc(io.length + 1, GFP_KERNEL);
2586 + buf =
2587 + kmalloc(io.length + 1,
2588 + GFP_KERNEL);
2589 if (buf) {
2590 buf[0] = 0;
2591 - cpylen = copy_from_user(buf, io.data, io.length);
2592 + cpylen =
2593 + copy_from_user(buf, io.data,
2594 + io.length);
2595 buf[io.length] = '\0';
2596 DbgPrint("%s", buf);
2597 kfree(buf);
2598 @@ -1696,7 +1485,7 @@ int Daemon_Library_ioctl(struct inode *i
2599
2600 case IOC_XPLAT:
2601 {
2602 - XPLAT data;
2603 + struct novfs_xplat data;
2604
2605 cpylen =
2606 copy_from_user(&data, (void *)arg,
2607 @@ -1707,61 +1496,79 @@ int Daemon_Library_ioctl(struct inode *i
2608
2609 switch (data.xfunction) {
2610 case NWC_OPEN_CONN_BY_NAME:
2611 - DbgPrint("[VFS XPLAT] Call NwOpenConnByName\n");
2612 - retCode = NwOpenConnByName(&data, &handle, dh->session);
2613 + DbgPrint
2614 + ("[VFS XPLAT] Call NwOpenConnByName\n");
2615 + retCode =
2616 + novfs_open_conn_by_name(&data,
2617 + &handle, dh->session);
2618 if (!retCode)
2619 - Daemon_Added_Resource(dh, DH_TYPE_CONNECTION, handle, NULL, 0, 0);
2620 + daemon_added_resource(dh,
2621 + DH_TYPE_CONNECTION,handle, 0, 0, 0);
2622 break;
2623
2624 case NWC_OPEN_CONN_BY_ADDRESS:
2625 - DbgPrint("[VFS XPLAT] Call NwOpenConnByAddress\n");
2626 - retCode = NwOpenConnByAddr(&data, &handle, dh->session);
2627 + DbgPrint
2628 + ("[VFS XPLAT] Call NwOpenConnByAddress\n");
2629 + retCode =
2630 + novfs_open_conn_by_addr(&data, &handle,
2631 + dh->session);
2632 if (!retCode)
2633 - Daemon_Added_Resource(dh, DH_TYPE_CONNECTION, handle, NULL, 0, 0);
2634 + daemon_added_resource(dh,
2635 + DH_TYPE_CONNECTION,
2636 + handle, 0,
2637 + 0, 0);
2638 break;
2639
2640 case NWC_OPEN_CONN_BY_REFERENCE:
2641 - DbgPrint("[VFS XPLAT] Call NwOpenConnByReference\n");
2642 - retCode = NwOpenConnByRef(&data, &handle, dh->session);
2643 +
2644 + DbgPrint
2645 + ("[VFS XPLAT] Call NwOpenConnByReference\n");
2646 + retCode =
2647 + novfs_open_conn_by_ref(&data, &handle,
2648 + dh->session);
2649 if (!retCode)
2650 - Daemon_Added_Resource(dh,
2651 + daemon_added_resource(dh,
2652 DH_TYPE_CONNECTION,
2653 - handle, NULL,
2654 + handle, 0,
2655 0, 0);
2656 break;
2657
2658 case NWC_SYS_CLOSE_CONN:
2659 DbgPrint("[VFS XPLAT] Call NwSysCloseConn\n");
2660 - retCode = NwSysConnClose(&data, (unsigned long *)&handle, dh->session);
2661 - Daemon_Remove_Resource(dh, DH_TYPE_CONNECTION, handle, 0);
2662 + retCode =
2663 + novfs_sys_conn_close(&data, (unsigned long *)&handle, dh->session);
2664 + daemon_remove_resource(dh, DH_TYPE_CONNECTION, handle, 0);
2665 break;
2666
2667 case NWC_CLOSE_CONN:
2668 DbgPrint
2669 ("[VFS XPLAT] Call NwCloseConn\n");
2670 retCode =
2671 - NwConnClose(&data, &handle,
2672 + novfs_conn_close(&data, &handle,
2673 dh->session);
2674 - Daemon_Remove_Resource(dh,
2675 + daemon_remove_resource(dh,
2676 DH_TYPE_CONNECTION,
2677 handle, 0);
2678 break;
2679
2680 case NWC_LOGIN_IDENTITY:
2681 - DbgPrint("[VFS XPLAT] Call NwLoginIdentity\n");
2682 - retCode = NwLoginIdentity(&data, &dh->session);
2683 + DbgPrint
2684 + ("[VFS XPLAT] Call NwLoginIdentity\n");
2685 + retCode =
2686 + novfs_login_id(&data, dh->session);
2687 break;
2688
2689 case NWC_RAW_NCP_REQUEST:
2690 - DbgPrint("[VFS XPLAT] Send Raw NCP Request\n");
2691 - retCode = NwRawSend(&data, dh->session);
2692 + DbgPrint
2693 + ("[VFS XPLAT] Send Raw NCP Request\n");
2694 + retCode = novfs_raw_send(&data, dh->session);
2695 break;
2696
2697 case NWC_AUTHENTICATE_CONN_WITH_ID:
2698 DbgPrint
2699 ("[VFS XPLAT] Authenticate Conn With ID\n");
2700 retCode =
2701 - NwAuthConnWithId(&data,
2702 + novfs_auth_conn(&data,
2703 dh->session);
2704 break;
2705
2706 @@ -1769,21 +1576,21 @@ int Daemon_Library_ioctl(struct inode *i
2707 DbgPrint
2708 ("[VFS XPLAT] UnAuthenticate Conn With ID\n");
2709 retCode =
2710 - NwUnAuthenticate(&data,
2711 + novfs_unauthenticate(&data,
2712 dh->session);
2713 break;
2714
2715 case NWC_LICENSE_CONN:
2716 DbgPrint("Call NwLicenseConn\n");
2717 retCode =
2718 - NwLicenseConn(&data, dh->session);
2719 + novfs_license_conn(&data, dh->session);
2720 break;
2721
2722 case NWC_LOGOUT_IDENTITY:
2723 DbgPrint
2724 ("[VFS XPLAT] Call NwLogoutIdentity\n");
2725 retCode =
2726 - NwLogoutIdentity(&data,
2727 + novfs_logout_id(&data,
2728 dh->session);
2729 break;
2730
2731 @@ -1791,35 +1598,35 @@ int Daemon_Library_ioctl(struct inode *i
2732 DbgPrint
2733 ("[VFS XPLAT] Call NwUnlicense\n");
2734 retCode =
2735 - NwUnlicenseConn(&data, dh->session);
2736 + novfs_unlicense_conn(&data, dh->session);
2737 break;
2738
2739 case NWC_GET_CONN_INFO:
2740 DbgPrint
2741 ("[VFS XPLAT] Call NwGetConnInfo\n");
2742 retCode =
2743 - NwGetConnInfo(&data, dh->session);
2744 + novfs_get_conn_info(&data, dh->session);
2745 break;
2746
2747 case NWC_SET_CONN_INFO:
2748 DbgPrint
2749 ("[VFS XPLAT] Call NwGetConnInfo\n");
2750 retCode =
2751 - NwSetConnInfo(&data, dh->session);
2752 + novfs_set_conn_info(&data, dh->session);
2753 break;
2754
2755 case NWC_SCAN_CONN_INFO:
2756 DbgPrint
2757 ("[VFS XPLAT] Call NwScanConnInfo\n");
2758 retCode =
2759 - NwScanConnInfo(&data, dh->session);
2760 + novfs_scan_conn_info(&data, dh->session);
2761 break;
2762
2763 case NWC_GET_IDENTITY_INFO:
2764 DbgPrint
2765 ("[VFS XPLAT] Call NwGetIdentityInfo\n");
2766 retCode =
2767 - NwGetIdentityInfo(&data,
2768 + novfs_get_id_info(&data,
2769 dh->session);
2770 break;
2771
2772 @@ -1827,7 +1634,7 @@ int Daemon_Library_ioctl(struct inode *i
2773 DbgPrint
2774 ("[VFS XPLAT] Call NwGetDaemonVersion\n");
2775 retCode =
2776 - NwGetDaemonVersion(&data,
2777 + novfs_get_daemon_ver(&data,
2778 dh->session);
2779 break;
2780
2781 @@ -1835,7 +1642,7 @@ int Daemon_Library_ioctl(struct inode *i
2782 DbgPrint
2783 ("[VFS XPLAT] Call NwcGetPreferredDsTree\n");
2784 retCode =
2785 - NwcGetPreferredDSTree(&data,
2786 + novfs_get_preferred_DS_tree(&data,
2787 dh->session);
2788 break;
2789
2790 @@ -1843,7 +1650,7 @@ int Daemon_Library_ioctl(struct inode *i
2791 DbgPrint
2792 ("[VFS XPLAT] Call NwcSetPreferredDsTree\n");
2793 retCode =
2794 - NwcSetPreferredDSTree(&data,
2795 + novfs_set_preferred_DS_tree(&data,
2796 dh->session);
2797 break;
2798
2799 @@ -1851,7 +1658,7 @@ int Daemon_Library_ioctl(struct inode *i
2800 DbgPrint
2801 ("[VFS XPLAT] Call NwcGetDefaultNameContext\n");
2802 retCode =
2803 - NwcGetDefaultNameCtx(&data,
2804 + novfs_get_default_ctx(&data,
2805 dh->session);
2806 break;
2807
2808 @@ -1859,7 +1666,7 @@ int Daemon_Library_ioctl(struct inode *i
2809 DbgPrint
2810 ("[VFS XPLAT] Call NwcSetDefaultNameContext\n");
2811 retCode =
2812 - NwcSetDefaultNameCtx(&data,
2813 + novfs_set_default_ctx(&data,
2814 dh->session);
2815 break;
2816
2817 @@ -1867,14 +1674,14 @@ int Daemon_Library_ioctl(struct inode *i
2818 DbgPrint
2819 ("[VFS XPLAT] Call NwQueryFeature\n");
2820 retCode =
2821 - NwQueryFeature(&data, dh->session);
2822 + novfs_query_feature(&data, dh->session);
2823 break;
2824
2825 case NWC_GET_TREE_MONITORED_CONN_REF:
2826 DbgPrint
2827 ("[VFS XPLAT] Call NwcGetTreeMonitoredConn\n");
2828 retCode =
2829 - NwcGetTreeMonitoredConn(&data,
2830 + novfs_get_tree_monitored_conn(&data,
2831 dh->
2832 session);
2833 break;
2834 @@ -1883,7 +1690,7 @@ int Daemon_Library_ioctl(struct inode *i
2835 DbgPrint
2836 ("[VFS XPLAT] Call NwcEnumerateIdentities\n");
2837 retCode =
2838 - NwcEnumIdentities(&data,
2839 + novfs_enum_ids(&data,
2840 dh->session);
2841 break;
2842
2843 @@ -1891,7 +1698,7 @@ int Daemon_Library_ioctl(struct inode *i
2844 DbgPrint
2845 ("[VFS XPLAT] Call NwcChangeAuthKey\n");
2846 retCode =
2847 - NwcChangeAuthKey(&data,
2848 + novfs_change_auth_key(&data,
2849 dh->session);
2850 break;
2851
2852 @@ -1913,7 +1720,7 @@ int Daemon_Library_ioctl(struct inode *i
2853 DbgPrint
2854 ("[VFS XPLAT] Call NwcSetPrimaryConn\n");
2855 retCode =
2856 - NwcSetPrimaryConn(&data,
2857 + novfs_set_pri_conn(&data,
2858 dh->session);
2859 break;
2860
2861 @@ -1921,26 +1728,29 @@ int Daemon_Library_ioctl(struct inode *i
2862 DbgPrint
2863 ("[VFS XPLAT] Call NwcGetPrimaryConn\n");
2864 retCode =
2865 - NwcGetPrimaryConn(&data,
2866 + novfs_get_pri_conn(&data,
2867 dh->session);
2868 break;
2869
2870 case NWC_MAP_DRIVE:
2871 - DbgPrint("[VFS XPLAT] Call NwcMapDrive\n");
2872 - retCode = NwdSetMapDrive(&data, dh->session);
2873 + DbgPrint
2874 + ("[VFS XPLAT] Call NwcMapDrive\n");
2875 + retCode =
2876 + set_map_drive(&data, dh->session);
2877 break;
2878
2879 case NWC_UNMAP_DRIVE:
2880 DbgPrint
2881 ("[VFS XPLAT] Call NwcUnMapDrive\n");
2882 - retCode = NwdUnMapDrive(&data, dh->session);
2883 + retCode =
2884 + unmap_drive(&data, dh->session);
2885 break;
2886
2887 case NWC_ENUMERATE_DRIVES:
2888 DbgPrint
2889 ("[VFS XPLAT] Call NwcEnumerateDrives\n");
2890 retCode =
2891 - NwcEnumerateDrives(&data,
2892 + novfs_enum_drives(&data,
2893 dh->session);
2894 break;
2895
2896 @@ -1954,21 +1764,21 @@ int Daemon_Library_ioctl(struct inode *i
2897 DbgPrint
2898 ("[VSF XPLAT Call NwdGetBroadcastMessage\n");
2899 retCode =
2900 - NwcGetBroadcastMessage(&data,
2901 + novfs_get_bcast_msg(&data,
2902 dh->session);
2903 break;
2904
2905 case NWC_SET_KEY:
2906 DbgPrint("[VSF XPLAT Call NwdSetKey\n");
2907 retCode =
2908 - NwdSetKeyValue(&data, dh->session);
2909 + novfs_set_key_value(&data, dh->session);
2910 break;
2911
2912 case NWC_VERIFY_KEY:
2913 DbgPrint
2914 ("[VSF XPLAT Call NwdVerifyKey\n");
2915 retCode =
2916 - NwdVerifyKeyValue(&data,
2917 + novfs_verify_key_value(&data,
2918 dh->session);
2919 break;
2920
2921 @@ -1991,9 +1801,10 @@ int Daemon_Library_ioctl(struct inode *i
2922 return (retCode);
2923 }
2924
2925 -unsigned int Daemon_Poll(struct file *file, struct poll_table_struct *poll_table)
2926 +unsigned int novfs_daemon_poll(struct file *file,
2927 + struct poll_table_struct *poll_table)
2928 {
2929 - daemon_command_t *que;
2930 + struct daemon_cmd *que;
2931 unsigned int mask = POLLOUT | POLLWRNORM;
2932
2933 que = get_next_queue(0);
2934 @@ -2002,43 +1813,32 @@ unsigned int Daemon_Poll(struct file *fi
2935 return mask;
2936 }
2937
2938 -int NwdConvertNetwareHandle(PXPLAT pdata, daemon_handle_t *DHandle)
2939 +static int NwdConvertNetwareHandle(struct novfs_xplat *pdata, struct daemon_handle * DHandle)
2940 {
2941 int retVal;
2942 - NwcConvertNetWareHandle nh;
2943 + struct nwc_convert_netware_handle nh;
2944 unsigned long cpylen;
2945
2946 DbgPrint("NwdConvertNetwareHandle: DHandle=0x%p\n", DHandle);
2947
2948 - cpylen = copy_from_user(&nh, pdata->reqData, sizeof(NwcConvertNetWareHandle));
2949 + cpylen =
2950 + copy_from_user(&nh, pdata->reqData,
2951 + sizeof(struct nwc_convert_netware_handle));
2952 +
2953 + retVal =
2954 + daemon_added_resource(DHandle, DH_TYPE_STREAM,
2955 + Uint32toHandle(nh.ConnHandle),
2956 + nh.NetWareHandle, nh.uAccessMode,
2957 + nh.uFileSize);
2958
2959 - retVal = Daemon_Added_Resource(DHandle, DH_TYPE_STREAM,
2960 - Uint32toHandle(nh.ConnHandle),
2961 - nh.NetWareHandle, nh.uAccessMode,
2962 - nh.uFileSize);
2963 -
2964 - return retVal;
2965 + return (retVal);
2966 }
2967
2968 -/*++======================================================================*/
2969 -int NwdConvertLocalHandle(PXPLAT pdata, daemon_handle_t * DHandle)
2970 -/*
2971 - *
2972 - * Arguments:
2973 - *
2974 - * Returns:
2975 - *
2976 - * Abstract:
2977 - *
2978 - * Notes:
2979 - *
2980 - * Environment:
2981 - *
2982 - *========================================================================*/
2983 +static int NwdConvertLocalHandle(struct novfs_xplat *pdata, struct daemon_handle * DHandle)
2984 {
2985 int retVal = NWE_REQUESTER_FAILURE;
2986 - daemon_resource_t *resource;
2987 - NwcConvertLocalHandle lh;
2988 + struct daemon_resource *resource;
2989 + struct nwc_convert_local_handle lh;
2990 struct list_head *l;
2991 unsigned long cpylen;
2992
2993 @@ -2047,7 +1847,7 @@ int NwdConvertLocalHandle(PXPLAT pdata,
2994 read_lock(&DHandle->lock);
2995
2996 list_for_each(l, &DHandle->list) {
2997 - resource = list_entry(l, daemon_resource_t, list);
2998 + resource = list_entry(l, struct daemon_resource, list);
2999
3000 if (DH_TYPE_STREAM == resource->type) {
3001 lh.uConnReference =
3002 @@ -2055,10 +1855,10 @@ int NwdConvertLocalHandle(PXPLAT pdata,
3003
3004 //sgled memcpy(lh.NwWareHandle, resource->handle, sizeof(resource->handle));
3005 memcpy(lh.NetWareHandle, resource->handle, sizeof(resource->handle)); //sgled
3006 - if (pdata->repLen >= sizeof(NwcConvertLocalHandle)) {
3007 + if (pdata->repLen >= sizeof(struct nwc_convert_local_handle)) {
3008 cpylen =
3009 copy_to_user(pdata->repData, &lh,
3010 - sizeof(NwcConvertLocalHandle));
3011 + sizeof(struct nwc_convert_local_handle));
3012 retVal = 0;
3013 } else {
3014 retVal = NWE_BUFFER_OVERFLOW;
3015 @@ -2072,39 +1872,25 @@ int NwdConvertLocalHandle(PXPLAT pdata,
3016 return (retVal);
3017 }
3018
3019 -/*++======================================================================*/
3020 -int NwdGetMountPath(PXPLAT pdata)
3021 -/*
3022 - *
3023 - * Arguments:
3024 - *
3025 - * Returns:
3026 - *
3027 - * Abstract:
3028 - *
3029 - * Notes:
3030 - *
3031 - * Environment:
3032 - *
3033 - *========================================================================*/
3034 +static int NwdGetMountPath(struct novfs_xplat *pdata)
3035 {
3036 int retVal = NWE_REQUESTER_FAILURE;
3037 int len;
3038 unsigned long cpylen;
3039 - NwcGetMountPath mp;
3040 + struct nwc_get_mount_path mp;
3041
3042 cpylen = copy_from_user(&mp, pdata->reqData, pdata->reqLen);
3043
3044 - if (Novfs_CurrentMount) {
3045 + if (novfs_current_mnt) {
3046
3047 - len = strlen(Novfs_CurrentMount) + 1;
3048 + len = strlen(novfs_current_mnt) + 1;
3049 if ((len > mp.MountPathLen) && mp.pMountPath) {
3050 retVal = NWE_BUFFER_OVERFLOW;
3051 } else {
3052 if (mp.pMountPath) {
3053 cpylen =
3054 copy_to_user(mp.pMountPath,
3055 - Novfs_CurrentMount, len);
3056 + novfs_current_mnt, len);
3057 }
3058 retVal = 0;
3059 }
3060 @@ -2119,52 +1905,55 @@ int NwdGetMountPath(PXPLAT pdata)
3061 return (retVal);
3062 }
3063
3064 -static int NwdSetMapDrive(PXPLAT pdata, session_t Session)
3065 +static int set_map_drive(struct novfs_xplat *pdata, struct novfs_schandle Session)
3066 {
3067 int retVal;
3068 - NwcMapDriveEx symInfo;
3069 + unsigned long cpylen;
3070 + struct nwc_map_drive_ex symInfo;
3071 char *path;
3072 - drive_map_t *drivemap, *dm;
3073 + struct drive_map *drivemap, *dm;
3074 struct list_head *list;
3075
3076 - retVal = NwcSetMapDrive(pdata, Session);
3077 + retVal = novfs_set_map_drive(pdata, Session);
3078 if (retVal)
3079 return retVal;
3080 -
3081 if (copy_from_user(&symInfo, pdata->reqData, sizeof(symInfo)))
3082 return -EFAULT;
3083 -
3084 - drivemap = kmalloc(sizeof(drive_map_t) + symInfo.linkOffsetLength, GFP_KERNEL);
3085 + drivemap =
3086 + kmalloc(sizeof(struct drive_map) + symInfo.linkOffsetLength,
3087 + GFP_KERNEL);
3088 if (!drivemap)
3089 return -ENOMEM;
3090
3091 path = (char *)pdata->reqData;
3092 path += symInfo.linkOffset;
3093 - if (copy_from_user(drivemap->name, path, symInfo.linkOffsetLength)) {
3094 - kfree(drivemap);
3095 - return -EFAULT;
3096 - }
3097 + cpylen =
3098 + copy_from_user(drivemap->name, path,
3099 + symInfo.linkOffsetLength);
3100
3101 drivemap->session = Session;
3102 - drivemap->hash = full_name_hash(drivemap->name, symInfo.linkOffsetLength - 1);
3103 + drivemap->hash =
3104 + full_name_hash(drivemap->name,
3105 + symInfo.linkOffsetLength - 1);
3106 drivemap->namelen = symInfo.linkOffsetLength - 1;
3107 - DbgPrint("NwdSetMapDrive: hash=0x%x path=%s\n", drivemap->hash, drivemap->name);
3108 + DbgPrint("NwdSetMapDrive: hash=0x%x path=%s\n",
3109 + drivemap->hash, drivemap->name);
3110
3111 - dm = (drive_map_t *) & DriveMapList.next;
3112 + dm = (struct drive_map *) & DriveMapList.next;
3113
3114 down(&DriveMapLock);
3115
3116 list_for_each(list, &DriveMapList) {
3117 - dm = list_entry(list, drive_map_t, list);
3118 + dm = list_entry(list, struct drive_map, list);
3119 DbgPrint("NwdSetMapDrive: dm=0x%p\n"
3120 - " hash: 0x%x\n"
3121 - " namelen: %d\n"
3122 - " name: %s\n",
3123 - dm, dm->hash, dm->namelen, dm->name);
3124 + " hash: 0x%x\n"
3125 + " namelen: %d\n"
3126 + " name: %s\n",
3127 + dm, dm->hash, dm->namelen, dm->name);
3128
3129 if (drivemap->hash == dm->hash) {
3130 if (0 ==
3131 - strcmp(dm->name, drivemap->name)) {
3132 + strcmp(dm->name, drivemap->name)) {
3133 dm = NULL;
3134 break;
3135 }
3136 @@ -2174,59 +1963,57 @@ static int NwdSetMapDrive(PXPLAT pdata,
3137 }
3138
3139 if (dm) {
3140 - if ((dm == (drive_map_t *) & DriveMapList) ||
3141 - (dm->hash < drivemap->hash)) {
3142 + if ((dm == (struct drive_map *) & DriveMapList) ||
3143 + (dm->hash < drivemap->hash)) {
3144 list_add(&drivemap->list, &dm->list);
3145 } else {
3146 list_add_tail(&drivemap->list,
3147 - &dm->list);
3148 + &dm->list);
3149 }
3150 - } else {
3151 - kfree(drivemap);
3152 }
3153 + kfree(drivemap);
3154 up(&DriveMapLock);
3155 -
3156 return (retVal);
3157 }
3158
3159 -static int NwdUnMapDrive(PXPLAT pdata, session_t Session)
3160 +static int unmap_drive(struct novfs_xplat *pdata, struct novfs_schandle Session)
3161 {
3162 int retVal = NWE_REQUESTER_FAILURE;
3163 - NwcUnmapDriveEx symInfo;
3164 + struct nwc_unmap_drive_ex symInfo;
3165 char *path;
3166 - drive_map_t *dm;
3167 + struct drive_map *dm;
3168 struct list_head *list;
3169 unsigned long hash;
3170
3171 - retVal = NwcUnMapDrive(pdata, Session);
3172 +
3173 + retVal = novfs_unmap_drive(pdata, Session);
3174 if (retVal)
3175 return retVal;
3176 -
3177 if (copy_from_user(&symInfo, pdata->reqData, sizeof(symInfo)))
3178 return -EFAULT;
3179
3180 path = kmalloc(symInfo.linkLen, GFP_KERNEL);
3181 if (!path)
3182 return -ENOMEM;
3183 -
3184 - if (copy_from_user(path, ((NwcUnmapDriveEx *)pdata->reqData)->linkData, symInfo.linkLen)) {
3185 + if (copy_from_user(path,((struct nwc_unmap_drive_ex *) pdata->reqData)->linkData, symInfo.linkLen)) {
3186 kfree(path);
3187 return -EFAULT;
3188 }
3189
3190 hash = full_name_hash(path, symInfo.linkLen - 1);
3191 - DbgPrint("NwdUnMapDrive: hash=0x%x path=%s\n", hash, path);
3192 + DbgPrint("NwdUnMapDrive: hash=0x%x path=%s\n", hash,
3193 + path);
3194
3195 dm = NULL;
3196
3197 down(&DriveMapLock);
3198
3199 list_for_each(list, &DriveMapList) {
3200 - dm = list_entry(list, drive_map_t, list);
3201 + dm = list_entry(list, struct drive_map, list);
3202 DbgPrint("NwdUnMapDrive: dm=0x%p %s\n"
3203 - " hash: 0x%x\n"
3204 - " namelen: %d\n",
3205 - dm, dm->name, dm->hash, dm->namelen);
3206 + " hash: 0x%x\n"
3207 + " namelen: %d\n",
3208 + dm, dm->name, dm->hash, dm->namelen);
3209
3210 if (hash == dm->hash) {
3211 if (0 == strcmp(dm->name, path)) {
3212 @@ -2240,40 +2027,25 @@ static int NwdUnMapDrive(PXPLAT pdata, s
3213
3214 if (dm) {
3215 DbgPrint("NwdUnMapDrive: Remove dm=0x%p %s\n"
3216 - " hash: 0x%x\n"
3217 - " namelen: %d\n",
3218 - dm, dm->name, dm->hash, dm->namelen);
3219 + " hash: 0x%x\n"
3220 + " namelen: %d\n",
3221 + dm, dm->name, dm->hash, dm->namelen);
3222 list_del(&dm->list);
3223 kfree(dm);
3224 }
3225
3226 up(&DriveMapLock);
3227 -
3228 - return retVal;
3229 + return (retVal);
3230 }
3231
3232 -/*++======================================================================*/
3233 -void RemoveDriveMaps(void)
3234 -/*
3235 - *
3236 - * Arguments:
3237 - *
3238 - * Returns:
3239 - *
3240 - * Abstract:
3241 - *
3242 - * Notes:
3243 - *
3244 - * Environment:
3245 - *
3246 - *========================================================================*/
3247 +static void RemoveDriveMaps(void)
3248 {
3249 - drive_map_t *dm;
3250 + struct drive_map *dm;
3251 struct list_head *list;
3252
3253 down(&DriveMapLock);
3254 list_for_each(list, &DriveMapList) {
3255 - dm = list_entry(list, drive_map_t, list);
3256 + dm = list_entry(list, struct drive_map, list);
3257
3258 DbgPrint("RemoveDriveMap: dm=0x%p\n"
3259 " hash: 0x%x\n"
3260 @@ -2288,9 +2060,7 @@ void RemoveDriveMaps(void)
3261 up(&DriveMapLock);
3262 }
3263
3264 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
3265 -/*++======================================================================*/
3266 -int local_unlink(const char *pathname)
3267 +static int local_unlink(const char *pathname)
3268 {
3269 int error;
3270 struct dentry *dentry;
3271 @@ -2341,60 +2111,3 @@ int local_unlink(const char *pathname)
3272 return error;
3273 }
3274
3275 -#else
3276 -/*++======================================================================*/
3277 -int local_unlink(const char *pathname)
3278 -{
3279 - int error;
3280 - struct dentry *dentry;
3281 - struct nameidata nd;
3282 - struct inode *inode = NULL;
3283 -
3284 - DbgPrint("local_unlink: %s\n", pathname);
3285 - error = path_lookup(pathname, LOOKUP_PARENT, &nd);
3286 - DbgPrint("local_unlink: path_lookup %d\n", error);
3287 - if (!error) {
3288 - error = -EISDIR;
3289 - if (nd.last_type == LAST_NORM) {
3290 - down(&nd.dentry->d_inode->i_sem);
3291 - dentry =
3292 - lookup_one_len(&nd.last, nd.dentry,
3293 - sizeof(nd.last));
3294 - DbgPrint("local_unlink: lookup_hash 0x%p\n", dentry);
3295 -
3296 - error = PTR_ERR(dentry);
3297 - if (!IS_ERR(dentry)) {
3298 - if (nd.last.name[nd.last.len]) {
3299 - error =
3300 - !dentry->
3301 - d_inode ? -ENOENT : S_ISDIR(dentry->
3302 - d_inode->
3303 - i_mode)
3304 - ? -EISDIR : -ENOTDIR;
3305 - } else {
3306 - inode = dentry->d_inode;
3307 - if (inode) {
3308 - atomic_inc(&inode->i_count);
3309 - }
3310 - error =
3311 - vfs_unlink(nd.dentry->d_inode,
3312 - dentry);
3313 - DbgPrint
3314 - ("local_unlink: vfs_unlink %d\n",
3315 - error);
3316 - }
3317 - dput(dentry);
3318 - }
3319 - up(&nd.dentry->d_inode->i_sem);
3320 - }
3321 - path_release(&nd);
3322 - }
3323 -
3324 - if (inode) {
3325 - iput(inode); /* truncate the inode here */
3326 - }
3327 -
3328 - DbgPrint("local_unlink: error=%d\n", error);
3329 - return error;
3330 -}
3331 -#endif
3332 --- a/fs/novfs/file.c
3333 +++ b/fs/novfs/file.c
3334 @@ -27,35 +27,11 @@
3335 #include "commands.h"
3336 #include "nwerror.h"
3337
3338 -/*===[ Function prototypes ]==============================================*/
3339 -int Novfs_get_alltrees(struct dentry *parent);
3340 -ssize_t Novfs_tree_read(struct file *file, char *buf, size_t len, loff_t * off);
3341 -
3342 -int Novfs_Find_Name_In_List(struct qstr *Name, unsigned char * List);
3343 -
3344 -int Novfs_Create(unsigned char * Path, int DirectoryFlag, session_t SessionId);
3345 -int Novfs_Close_File(HANDLE Handle, session_t SessionId);
3346 -int Novfs_Read_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
3347 - loff_t * Offset, session_t SessionId);
3348 -int Novfs_Write_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
3349 - loff_t * Offset, session_t SessionId);
3350 -int Novfs_Write_Page(HANDLE Handle, struct page *Page, session_t SessionId);
3351 -int Novfs_Read_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
3352 - size_t * Bytes, loff_t * Offset, int User,
3353 - session_t SessionId);
3354 -int Novfs_Write_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
3355 - size_t * Bytes, loff_t * Offset, session_t SessionId);
3356 -int Novfs_Close_Stream(HANDLE ConnHandle, unsigned char * Handle, session_t SessionId);
3357 -int Novfs_Delete(unsigned char * Path, int DirectoryFlag, session_t SessionId);
3358 -int Novfs_Truncate_File(unsigned char * Path, int PathLen, session_t SessionId);
3359 -int Novfs_Truncate_File_Ex(HANDLE Handle, loff_t Offset, session_t SessionId);
3360 -int Novfs_Rename_File(int DirectoryFlag, unsigned char * OldName, int OldLen,
3361 - unsigned char * NewName, int NewLen, session_t SessionId);
3362 -int Novfs_Set_Attr(unsigned char * Path, struct iattr *Attr, session_t SessionId);
3363 -int Novfs_Get_File_Cache_Flag(unsigned char * Path, session_t SessionId);
3364 +static ssize_t novfs_tree_read(struct file * file, char *buf, size_t len, loff_t * off);
3365 +extern struct dentry_operations novfs_dentry_operations;
3366
3367 -static struct file_operations Novfs_tree_operations = {
3368 - read:Novfs_tree_read,
3369 +static struct file_operations novfs_tree_operations = {
3370 + read:novfs_tree_read,
3371 };
3372
3373 /*
3374 @@ -65,12 +41,12 @@ static struct file_operations Novfs_tree
3375 */
3376 static int StripTrailingDots = 1;
3377
3378 -int Novfs_get_alltrees(struct dentry *parent)
3379 +int novfs_get_alltrees(struct dentry *parent)
3380 {
3381 unsigned char *p;
3382 - PCOMMAND_REPLY_HEADER reply = NULL;
3383 + struct novfs_command_reply_header * reply = NULL;
3384 unsigned long replylen = 0;
3385 - COMMAND_REQUEST_HEADER cmd;
3386 + struct novfs_command_request_header cmd;
3387 int retCode;
3388 struct dentry *entry;
3389 struct qstr name;
3390 @@ -81,30 +57,30 @@ int Novfs_get_alltrees(struct dentry *pa
3391 //sg ??? cmd.SessionId = 0x1234;
3392 SC_INITIALIZE(cmd.SessionId);
3393
3394 - DbgPrint("Novfs_get_alltrees:\n");
3395 + DbgPrint("novfs_get_alltrees:\n");
3396
3397 retCode = Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
3398 - DbgPrint("Novfs_get_alltrees: relpy=0x%p replylen=%d\n", reply,
3399 + DbgPrint("novfs_get_alltrees: relpy=0x%p replylen=%d\n", reply,
3400 replylen);
3401 if (reply) {
3402 - mydump(replylen, reply);
3403 + novfs_dump(replylen, reply);
3404 if (!reply->ErrorCode
3405 - && (replylen > sizeof(COMMAND_REPLY_HEADER))) {
3406 + && (replylen > sizeof(struct novfs_command_reply_header))) {
3407 p = (char *)reply + 8;
3408 while (*p) {
3409 - DbgPrint("Novfs_get_alltrees: %s\n", p);
3410 + DbgPrint("novfs_get_alltrees: %s\n", p);
3411 name.len = strlen(p);
3412 name.name = p;
3413 name.hash = full_name_hash(name.name, name.len);
3414 entry = d_lookup(parent, &name);
3415 if (NULL == entry) {
3416 - DbgPrint("Novfs_get_alltrees: adding %s\n", p);
3417 + DbgPrint("novfs_get_alltrees: adding %s\n", p);
3418 entry = d_alloc(parent, &name);
3419 if (entry) {
3420 - entry->d_op = &Novfs_dentry_operations;
3421 - inode = Novfs_get_inode(parent->d_sb, S_IFREG | 0400, 0, 0, 0, &name);
3422 + entry->d_op = &novfs_dentry_operations;
3423 + inode = novfs_get_inode(parent->d_sb, S_IFREG | 0400, 0, 0, 0, &name);
3424 if (inode) {
3425 - inode->i_fop = &Novfs_tree_operations;
3426 + inode->i_fop = &novfs_tree_operations;
3427 d_add(entry, inode);
3428 }
3429 }
3430 @@ -117,7 +93,7 @@ int Novfs_get_alltrees(struct dentry *pa
3431 return (retCode);
3432 }
3433
3434 -ssize_t Novfs_tree_read(struct file * file, char *buf, size_t len, loff_t * off)
3435 +static ssize_t novfs_tree_read(struct file * file, char *buf, size_t len, loff_t * off)
3436 {
3437 if (file->f_pos != 0) {
3438 return (0);
3439 @@ -128,24 +104,24 @@ ssize_t Novfs_tree_read(struct file * fi
3440 return (5);
3441 }
3442
3443 -int Novfs_Get_Connected_Server_List(unsigned char ** ServerList, struct schandle *SessionId)
3444 +int novfs_get_servers(unsigned char ** ServerList, struct novfs_schandle SessionId)
3445 {
3446 - GET_CONNECTED_SERVER_LIST_REQUEST req;
3447 - PGET_CONNECTED_SERVER_LIST_REPLY reply = NULL;
3448 + struct novfs_get_connected_server_list req;
3449 + struct novfs_get_connected_server_list_reply *reply = NULL;
3450 unsigned long replylen = 0;
3451 int retCode = 0;
3452
3453 *ServerList = NULL;
3454
3455 req.Command.CommandType = VFS_COMMAND_GET_CONNECTED_SERVER_LIST;
3456 - memcpy(&req.Command.SessionId, SessionId, sizeof(*SessionId));
3457 + req.Command.SessionId = SessionId;
3458
3459 retCode =
3460 Queue_Daemon_Command(&req, sizeof(req), NULL, 0, (void *)&reply,
3461 &replylen, INTERRUPTIBLE);
3462 if (reply) {
3463 - DbgPrint("Novfs_Get_Connected_Server_List: reply\n");
3464 - replylen -= sizeof(COMMAND_REPLY_HEADER);
3465 + DbgPrint("novfs_Get_Connected_Server_List: reply\n");
3466 + replylen -= sizeof(struct novfs_command_reply_header);
3467 if (!reply->Reply.ErrorCode && replylen) {
3468 memcpy(reply, reply->List, replylen);
3469 *ServerList = (unsigned char *) reply;
3470 @@ -158,30 +134,31 @@ int Novfs_Get_Connected_Server_List(unsi
3471 return (retCode);
3472 }
3473
3474 -int Novfs_Get_Server_Volume_List(struct qstr *Server, unsigned char ** VolumeList,
3475 - struct schandle *SessionId)
3476 +int novfs_get_vols(struct qstr *Server, unsigned char ** VolumeList,
3477 + struct novfs_schandle SessionId)
3478 {
3479 - PGET_SERVER_VOLUME_LIST_REQUEST req;
3480 - PGET_SERVER_VOLUME_LIST_REPLY reply = NULL;
3481 + struct novfs_get_server_volume_list *req;
3482 + struct novfs_get_server_volume_list_reply *reply = NULL;
3483 unsigned long replylen = 0, reqlen;
3484 int retCode;
3485
3486 *VolumeList = NULL;
3487 - reqlen = sizeof(GET_SERVER_VOLUME_LIST_REQUEST) + Server->len;
3488 + reqlen = sizeof(struct novfs_get_server_volume_list) + Server->len;
3489 req = kmalloc(reqlen, GFP_KERNEL);
3490 if (!req)
3491 return -ENOMEM;
3492 req->Command.CommandType = VFS_COMMAND_GET_SERVER_VOLUME_LIST;
3493 req->Length = Server->len;
3494 memcpy(req->Name, Server->name, Server->len);
3495 - memcpy(&req->Command.SessionId, SessionId, sizeof(*SessionId));
3496 + req->Command.SessionId = SessionId;
3497
3498 - retCode = Queue_Daemon_Command(req, reqlen, NULL, 0, (void *)&reply,
3499 - &replylen, INTERRUPTIBLE);
3500 + retCode =
3501 + Queue_Daemon_Command(req, reqlen, NULL, 0, (void *)&reply,
3502 + &replylen, INTERRUPTIBLE);
3503 if (reply) {
3504 - DbgPrint("Novfs_Get_Server_Volume_List: reply\n");
3505 - mydump(replylen, reply);
3506 - replylen -= sizeof(COMMAND_REPLY_HEADER);
3507 + DbgPrint("novfs_Get_Server_Volume_List: reply\n");
3508 + novfs_dump(replylen, reply);
3509 + replylen -= sizeof(struct novfs_command_reply_header);
3510
3511 if (!reply->Reply.ErrorCode && replylen) {
3512 memcpy(reply, reply->List, replylen);
3513 @@ -193,35 +170,19 @@ int Novfs_Get_Server_Volume_List(struct
3514 }
3515 }
3516 kfree(req);
3517 - return retCode;
3518 -}
3519 -
3520 -int Novfs_Find_Name_In_List(struct qstr *Name, unsigned char * List)
3521 -{
3522 - int len;
3523 - int retCode = 0;
3524 -
3525 - while (*List) {
3526 - len = strlen(List);
3527 - if ((len == Name->len) && !strncmp(Name->name, List, len)) {
3528 - retCode = 1;
3529 - break;
3530 - }
3531 - List += (len + 1);
3532 - }
3533 return (retCode);
3534 }
3535
3536 -int Novfs_Get_File_Info(unsigned char * Path, struct entry_info *Info, struct schandle *SessionId)
3537 +int novfs_get_file_info(unsigned char * Path, struct novfs_entry_info * Info, struct novfs_schandle SessionId)
3538 {
3539 - PVERIFY_FILE_REPLY reply = NULL;
3540 + struct novfs_verify_file_reply *reply = NULL;
3541 unsigned long replylen = 0;
3542 - PVERIFY_FILE_REQUEST cmd;
3543 + struct novfs_verify_file_request * cmd;
3544 int cmdlen;
3545 int retCode = -ENOENT;
3546 int pathlen;
3547
3548 - DbgPrint("%s: Path = %s\n", __func__, Path);
3549 + DbgPrint("novfs_Get_File_Info: Path = %s\n", Path);
3550
3551 Info->mode = S_IFDIR | 0700;
3552 Info->uid = current->uid;
3553 @@ -235,12 +196,12 @@ int Novfs_Get_File_Info(unsigned char *
3554 if ('.' == Path[pathlen - 1])
3555 pathlen--;
3556 }
3557 - cmdlen = offsetof(VERIFY_FILE_REQUEST, path) + pathlen;
3558 - cmd = (PVERIFY_FILE_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
3559 + cmdlen = offsetof(struct novfs_verify_file_request,path) + pathlen;
3560 + cmd = kmalloc(cmdlen, GFP_KERNEL);
3561 if (cmd) {
3562 cmd->Command.CommandType = VFS_COMMAND_VERIFY_FILE;
3563 cmd->Command.SequenceNumber = 0;
3564 - memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
3565 + cmd->Command.SessionId = SessionId;
3566 cmd->pathLen = pathlen;
3567 memcpy(cmd->path, Path, cmd->pathLen);
3568
3569 @@ -279,11 +240,18 @@ int Novfs_Get_File_Info(unsigned char *
3570 Info->mtime.tv_nsec = 0;
3571 Info->ctime.tv_sec = reply->createTime;
3572 Info->ctime.tv_nsec = 0;
3573 - DbgPrint("%s: replylen=%d sizeof(VERIFY_FILE_REPLY)=%d\n", __func__, replylen, sizeof(VERIFY_FILE_REPLY));
3574 - if (replylen > sizeof(VERIFY_FILE_REPLY)) {
3575 - unsigned int *lp = &reply->fileMode;
3576 + DbgPrint
3577 + ("novfs_Get_File_Info: replylen=%d sizeof(VERIFY_FILE_REPLY)=%d\n",
3578 + replylen,
3579 + sizeof(struct novfs_verify_file_reply));
3580 + if (replylen >
3581 + sizeof(struct novfs_verify_file_reply)) {
3582 + unsigned int *lp =
3583 + &reply->fileMode;
3584 lp++;
3585 - DbgPrint("%s: extra data 0x%x\n", __func__, *lp);
3586 + DbgPrint
3587 + ("novfs_Get_File_Info: extra data 0x%x\n",
3588 + *lp);
3589 Info->mtime.tv_nsec = *lp;
3590 }
3591 retCode = 0;
3592 @@ -295,35 +263,37 @@ int Novfs_Get_File_Info(unsigned char *
3593 }
3594 }
3595
3596 - DbgPrint("%s: return 0x%x\n", __func__, retCode);
3597 + DbgPrint("novfs_Get_File_Info: return 0x%x\n", retCode);
3598 return (retCode);
3599 }
3600
3601 -int Novfs_GetX_File_Info(char *Path, const char *Name, char *buffer,
3602 +int novfs_getx_file_info(char *Path, const char *Name, char *buffer,
3603 ssize_t buffer_size, ssize_t * dataLen,
3604 - session_t *SessionId)
3605 + struct novfs_schandle SessionId)
3606 {
3607 - PXA_GET_REPLY reply = NULL;
3608 + struct novfs_xa_get_reply *reply = NULL;
3609 unsigned long replylen = 0;
3610 - PXA_GET_REQUEST cmd;
3611 + struct novfs_xa_get_request *cmd;
3612 int cmdlen;
3613 int retCode = -ENOENT;
3614
3615 int namelen = strlen(Name);
3616 int pathlen = strlen(Path);
3617
3618 - DbgPrint("%s: xattr: Path = %s, pathlen = %i, Name = %s, namelen = %i\n", __func__, Path, pathlen, Name, namelen);
3619 + DbgPrint
3620 + ("novfs_GetX_File_Info xattr: Path = %s, pathlen = %i, Name = %s, namelen = %i\n",
3621 + Path, pathlen, Name, namelen);
3622
3623 if (namelen > MAX_XATTR_NAME_LEN) {
3624 return ENOATTR;
3625 }
3626
3627 - cmdlen = offsetof(XA_GET_REQUEST, data) + pathlen + 1 + namelen + 1; // two '\0'
3628 - cmd = (PXA_GET_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
3629 + cmdlen = offsetof(struct novfs_xa_get_request, data) + pathlen + 1 + namelen + 1; // two '\0'
3630 + cmd = (struct novfs_xa_get_request *) kmalloc(cmdlen, GFP_KERNEL);
3631 if (cmd) {
3632 cmd->Command.CommandType = VFS_COMMAND_GET_EXTENDED_ATTRIBUTE;
3633 cmd->Command.SequenceNumber = 0;
3634 - memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
3635 + cmd->Command.SessionId = SessionId;
3636
3637 cmd->pathLen = pathlen;
3638 memcpy(cmd->data, Path, cmd->pathLen + 1); //+ '\0'
3639 @@ -331,14 +301,20 @@ int Novfs_GetX_File_Info(char *Path, con
3640 cmd->nameLen = namelen;
3641 memcpy(cmd->data + cmd->pathLen + 1, Name, cmd->nameLen + 1);
3642
3643 - DbgPrint("%s xattr: PXA_GET_REQUEST BEGIN\n", __func__);
3644 - DbgPrint("%s xattr: Queue_Daemon_Command %d\n", __func__, cmd->Command.CommandType);
3645 - DbgPrint("%s xattr: Command.SessionId = %d\n", __func__, cmd->Command.SessionId);
3646 - DbgPrint("%s xattr: pathLen = %d\n", __func__, cmd->pathLen);
3647 - DbgPrint("%s xattr: Path = %s\n", __func__, cmd->data);
3648 - DbgPrint("%s xattr: nameLen = %d\n", __func__, cmd->nameLen);
3649 - DbgPrint("%s xattr: name = %s\n", __func__, (cmd->data + cmd->pathLen + 1));
3650 - DbgPrint("%s xattr: PXA_GET_REQUEST END\n", __func__);
3651 + DbgPrint("novfs_GetX_File_Info xattr: PXA_GET_REQUEST BEGIN\n");
3652 + DbgPrint
3653 + ("novfs_GetX_File_Info xattr: Queue_Daemon_Command %d\n",
3654 + cmd->Command.CommandType);
3655 + DbgPrint("novfs_GetX_File_Info xattr: Command.SessionId = %d\n",
3656 + cmd->Command.SessionId);
3657 + DbgPrint("novfs_GetX_File_Info xattr: pathLen = %d\n",
3658 + cmd->pathLen);
3659 + DbgPrint("novfs_GetX_File_Info xattr: Path = %s\n", cmd->data);
3660 + DbgPrint("novfs_GetX_File_Info xattr: nameLen = %d\n",
3661 + cmd->nameLen);
3662 + DbgPrint("novfs_GetX_File_Info xattr: name = %s\n",
3663 + (cmd->data + cmd->pathLen + 1));
3664 + DbgPrint("novfs_GetX_File_Info xattr: PXA_GET_REQUEST END\n");
3665
3666 retCode =
3667 Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
3668 @@ -347,8 +323,13 @@ int Novfs_GetX_File_Info(char *Path, con
3669 if (reply) {
3670
3671 if (reply->Reply.ErrorCode) {
3672 - DbgPrint("%s xattr: reply->Reply.ErrorCode=%d, %X\n", __func__, reply->Reply.ErrorCode, reply->Reply.ErrorCode);
3673 - DbgPrint("%s xattr: replylen=%d\n", __func__, replylen);
3674 + DbgPrint
3675 + ("novfs_GetX_File_Info xattr: reply->Reply.ErrorCode=%d, %X\n",
3676 + reply->Reply.ErrorCode,
3677 + reply->Reply.ErrorCode);
3678 + DbgPrint
3679 + ("novfs_GetX_File_Info xattr: replylen=%d\n",
3680 + replylen);
3681
3682 //0xC9 = EA not found (C9), 0xD1 = EA access denied
3683 if ((reply->Reply.ErrorCode == 0xC9)
3684 @@ -360,26 +341,32 @@ int Novfs_GetX_File_Info(char *Path, con
3685 } else {
3686
3687 *dataLen =
3688 - replylen - sizeof(COMMAND_REPLY_HEADER);
3689 - DbgPrint("%s xattr: replylen=%u, dataLen=%u\n", __func__, replylen, *dataLen);
3690 + replylen - sizeof(struct novfs_command_reply_header);
3691 + DbgPrint
3692 + ("novfs_GetX_File_Info xattr: replylen=%u, dataLen=%u\n",
3693 + replylen, *dataLen);
3694
3695 if (buffer_size >= *dataLen) {
3696 - DbgPrint("%s xattr: copying to buffer from &reply->pData\n", __func__);
3697 + DbgPrint
3698 + ("novfs_GetX_File_Info xattr: copying to buffer from &reply->pData\n");
3699 memcpy(buffer, &reply->pData, *dataLen);
3700
3701 retCode = 0;
3702 } else {
3703 - DbgPrint("%s xattr: (!!!) buffer is smaller then reply\n", __func__);
3704 + DbgPrint
3705 + ("novfs_GetX_File_Info xattr: (!!!) buffer is smaller then reply\n");
3706 retCode = -ERANGE;
3707 }
3708 - DbgPrint("%s xattr: /dumping buffer\n", __func__);
3709 - mydump(*dataLen, buffer);
3710 - DbgPrint("%s xattr: \\after dumping buffer\n", __func__);
3711 + DbgPrint
3712 + ("novfs_GetX_File_Info xattr: /dumping buffer\n");
3713 + novfs_dump(*dataLen, buffer);
3714 + DbgPrint
3715 + ("novfs_GetX_File_Info xattr: \\after dumping buffer\n");
3716 }
3717
3718 kfree(reply);
3719 } else {
3720 - DbgPrint("%s xattr: reply = NULL\n", __func__);
3721 + DbgPrint("novfs_GetX_File_Info xattr: reply = NULL\n");
3722 }
3723 kfree(cmd);
3724
3725 @@ -388,32 +375,33 @@ int Novfs_GetX_File_Info(char *Path, con
3726 return retCode;
3727 }
3728
3729 -int Novfs_SetX_File_Info(char *Path, const char *Name, const void *Value,
3730 +int novfs_setx_file_info(char *Path, const char *Name, const void *Value,
3731 unsigned long valueLen, unsigned long *bytesWritten,
3732 - int flags, struct schandle *SessionId)
3733 + int flags, struct novfs_schandle SessionId)
3734 {
3735 - PXA_SET_REPLY reply = NULL;
3736 + struct novfs_xa_set_reply *reply = NULL;
3737 unsigned long replylen = 0;
3738 - PXA_SET_REQUEST cmd;
3739 + struct novfs_xa_set_request *cmd;
3740 int cmdlen;
3741 int retCode = -ENOENT;
3742
3743 int namelen = strlen(Name);
3744 int pathlen = strlen(Path);
3745
3746 - DbgPrint("%s xattr: Path = %s, pathlen = %i, Name = %s, namelen = %i, value len = %u\n", __func__,
3747 + DbgPrint
3748 + ("novfs_SetX_File_Info xattr: Path = %s, pathlen = %i, Name = %s, namelen = %i, value len = %u\n",
3749 Path, pathlen, Name, namelen, valueLen);
3750
3751 if (namelen > MAX_XATTR_NAME_LEN) {
3752 return ENOATTR;
3753 }
3754
3755 - cmdlen = offsetof(XA_SET_REQUEST, data) + pathlen + 1 + namelen + 1 + valueLen;
3756 - cmd = (PXA_SET_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
3757 + cmdlen = offsetof(struct novfs_xa_set_request, data) + pathlen + 1 + namelen + 1 + valueLen;
3758 + cmd = (struct novfs_xa_set_request *) kmalloc(cmdlen, GFP_KERNEL);
3759 if (cmd) {
3760 cmd->Command.CommandType = VFS_COMMAND_SET_EXTENDED_ATTRIBUTE;
3761 cmd->Command.SequenceNumber = 0;
3762 - memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
3763 + cmd->Command.SessionId = SessionId;
3764
3765 cmd->flags = flags;
3766 cmd->pathLen = pathlen;
3767 @@ -426,16 +414,22 @@ int Novfs_SetX_File_Info(char *Path, con
3768 memcpy(cmd->data + cmd->pathLen + 1 + cmd->nameLen + 1, Value,
3769 valueLen);
3770
3771 - DbgPrint("%s xattr: PXA_SET_REQUEST BEGIN\n", __func__);
3772 - DbgPrint("%s xattr: Queue_Daemon_Command %d\n", __func__, cmd->Command.CommandType);
3773 - DbgPrint("%s xattr: Command.SessionId = %d\n", __func__, cmd->Command.SessionId);
3774 - DbgPrint("%s xattr: pathLen = %d\n", __func__, cmd->pathLen);
3775 - DbgPrint("%s xattr: Path = %s\n", __func__, cmd->data);
3776 - DbgPrint("%s xattr: nameLen = %d\n", __func__, cmd->nameLen);
3777 - DbgPrint("%s xattr: name = %s\n", __func__, (cmd->data + cmd->pathLen + 1));
3778 - mydump(valueLen < 16 ? valueLen : 16, (char *)Value);
3779 + DbgPrint("novfs_SetX_File_Info xattr: PXA_SET_REQUEST BEGIN\n");
3780 + DbgPrint
3781 + ("novfs_SetX_File_Info xattr: Queue_Daemon_Command %d\n",
3782 + cmd->Command.CommandType);
3783 + DbgPrint("novfs_SetX_File_Info xattr: Command.SessionId = %d\n",
3784 + cmd->Command.SessionId);
3785 + DbgPrint("novfs_SetX_File_Info xattr: pathLen = %d\n",
3786 + cmd->pathLen);
3787 + DbgPrint("novfs_SetX_File_Info xattr: Path = %s\n", cmd->data);
3788 + DbgPrint("novfs_SetX_File_Info xattr: nameLen = %d\n",
3789 + cmd->nameLen);
3790 + DbgPrint("novfs_SetX_File_Info xattr: name = %s\n",
3791 + (cmd->data + cmd->pathLen + 1));
3792 + novfs_dump(valueLen < 16 ? valueLen : 16, (char *)Value);
3793
3794 - DbgPrint("%s xattr: PXA_SET_REQUEST END\n", __func__);
3795 + DbgPrint("novfs_SetX_File_Info xattr: PXA_SET_REQUEST END\n");
3796
3797 retCode =
3798 Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
3799 @@ -444,22 +438,30 @@ int Novfs_SetX_File_Info(char *Path, con
3800 if (reply) {
3801
3802 if (reply->Reply.ErrorCode) {
3803 - DbgPrint("%s xattr: reply->Reply.ErrorCode=%d, %X\n", __func__, reply->Reply.ErrorCode, reply->Reply.ErrorCode);
3804 - DbgPrint("%s xattr: replylen=%d\n", __func__, replylen);
3805 + DbgPrint
3806 + ("novfs_SetX_File_Info xattr: reply->Reply.ErrorCode=%d, %X\n",
3807 + reply->Reply.ErrorCode,
3808 + reply->Reply.ErrorCode);
3809 + DbgPrint
3810 + ("novfs_SetX_File_Info xattr: replylen=%d\n",
3811 + replylen);
3812
3813 retCode = -reply->Reply.ErrorCode; //-ENOENT;
3814 } else {
3815
3816 - DbgPrint("%s xattr: replylen=%u, real len = %u\n", __func__, replylen, replylen - sizeof(COMMAND_REPLY_HEADER));
3817 + DbgPrint
3818 + ("novfs_SetX_File_Info xattr: replylen=%u, real len = %u\n",
3819 + replylen,
3820 + replylen - sizeof(struct novfs_command_reply_header));
3821 memcpy(bytesWritten, &reply->pData,
3822 - replylen - sizeof(COMMAND_REPLY_HEADER));
3823 + replylen - sizeof(struct novfs_command_reply_header));
3824
3825 retCode = 0;
3826 }
3827
3828 kfree(reply);
3829 } else {
3830 - DbgPrint("%s xattr: reply = NULL\n", __func__);
3831 + DbgPrint("novfs_SetX_File_Info xattr: reply = NULL\n");
3832 }
3833 kfree(cmd);
3834
3835 @@ -468,32 +470,41 @@ int Novfs_SetX_File_Info(char *Path, con
3836 return retCode;
3837 }
3838
3839 -int Novfs_ListX_File_Info(char *Path, char *buffer, ssize_t buffer_size, ssize_t * dataLen, struct schandle *SessionId)
3840 +int novfs_listx_file_info(char *Path, char *buffer, ssize_t buffer_size,
3841 + ssize_t * dataLen, struct novfs_schandle SessionId)
3842 {
3843 - PXA_LIST_REPLY reply = NULL;
3844 + struct novfs_xa_list_reply *reply = NULL;
3845 unsigned long replylen = 0;
3846 - PVERIFY_FILE_REQUEST cmd;
3847 + struct novfs_verify_file_request *cmd;
3848 int cmdlen;
3849 int retCode = -ENOENT;
3850
3851 int pathlen = strlen(Path);
3852 - DbgPrint("%s xattr: Path = %s, pathlen = %i\n", __func__, Path, pathlen);
3853 + DbgPrint("novfs_ListX_File_Info xattr: Path = %s, pathlen = %i\n", Path,
3854 + pathlen);
3855
3856 *dataLen = 0;
3857 - cmdlen = offsetof(VERIFY_FILE_REQUEST, path) + pathlen;
3858 - cmd = (PVERIFY_FILE_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
3859 + cmdlen = offsetof(struct novfs_verify_file_request, path) + pathlen;
3860 + cmd = (struct novfs_verify_file_request *) kmalloc(cmdlen, GFP_KERNEL);
3861 if (cmd) {
3862 cmd->Command.CommandType = VFS_COMMAND_LIST_EXTENDED_ATTRIBUTES;
3863 cmd->Command.SequenceNumber = 0;
3864 - memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
3865 + cmd->Command.SessionId = SessionId;
3866 cmd->pathLen = pathlen;
3867 memcpy(cmd->path, Path, cmd->pathLen + 1); //+ '\0'
3868 - DbgPrint("%s xattr: PVERIFY_FILE_REQUEST BEGIN\n", __func__);
3869 - DbgPrint("%s xattr: Queue_Daemon_Command %d\n", __func__, cmd->Command.CommandType);
3870 - DbgPrint("%s xattr: Command.SessionId = %d\n", __func__, cmd->Command.SessionId);
3871 - DbgPrint("%s xattr: pathLen = %d\n", __func__, cmd->pathLen);
3872 - DbgPrint("%s xattr: Path = %s\n", __func__, cmd->path);
3873 - DbgPrint("%s xattr: PVERIFY_FILE_REQUEST END\n", __func__);
3874 + DbgPrint
3875 + ("novfs_ListX_File_Info xattr: PVERIFY_FILE_REQUEST BEGIN\n");
3876 + DbgPrint
3877 + ("novfs_ListX_File_Info xattr: Queue_Daemon_Command %d\n",
3878 + cmd->Command.CommandType);
3879 + DbgPrint
3880 + ("novfs_ListX_File_Info xattr: Command.SessionId = %d\n",
3881 + cmd->Command.SessionId);
3882 + DbgPrint("novfs_ListX_File_Info xattr: pathLen = %d\n",
3883 + cmd->pathLen);
3884 + DbgPrint("novfs_ListX_File_Info xattr: Path = %s\n", cmd->path);
3885 + DbgPrint
3886 + ("novfs_ListX_File_Info xattr: PVERIFY_FILE_REQUEST END\n");
3887
3888 retCode =
3889 Queue_Daemon_Command(cmd, cmdlen, NULL, 0, (void *)&reply,
3890 @@ -502,31 +513,43 @@ int Novfs_ListX_File_Info(char *Path, ch
3891 if (reply) {
3892
3893 if (reply->Reply.ErrorCode) {
3894 - DbgPrint("%s xattr: reply->Reply.ErrorCode=%d, %X\n", __func__, reply->Reply.ErrorCode, reply->Reply.ErrorCode);
3895 - DbgPrint("%s xattr: replylen=%d\n", __func__, replylen);
3896 + DbgPrint
3897 + ("novfs_ListX_File_Info xattr: reply->Reply.ErrorCode=%d, %X\n",
3898 + reply->Reply.ErrorCode,
3899 + reply->Reply.ErrorCode);
3900 + DbgPrint
3901 + ("novfs_ListX_File_Info xattr: replylen=%d\n",
3902 + replylen);
3903
3904 retCode = -ENOENT;
3905 } else {
3906 - *dataLen = replylen - sizeof(COMMAND_REPLY_HEADER);
3907 - DbgPrint("%s xattr: replylen=%u, dataLen=%u\n", __func__, replylen, *dataLen);
3908 + *dataLen =
3909 + replylen - sizeof(struct novfs_command_reply_header);
3910 + DbgPrint
3911 + ("novfs_ListX_File_Info xattr: replylen=%u, dataLen=%u\n",
3912 + replylen, *dataLen);
3913
3914 if (buffer_size >= *dataLen) {
3915 - DbgPrint("%s xattr: copying to buffer from &reply->pData\n", __func__);
3916 + DbgPrint
3917 + ("novfs_ListX_File_Info xattr: copying to buffer from &reply->pData\n");
3918 memcpy(buffer, &reply->pData, *dataLen);
3919 } else {
3920 - DbgPrint("%s xattr: (!!!) buffer is smaller then reply\n", __func__);
3921 + DbgPrint
3922 + ("novfs_ListX_File_Info xattr: (!!!) buffer is smaller then reply\n");
3923 retCode = -ERANGE;
3924 }
3925 - DbgPrint("%s xattr: /dumping buffer\n", __func__);
3926 - mydump(*dataLen, buffer);
3927 - DbgPrint("%s xattr: \\after dumping buffer\n", __func__);
3928 + DbgPrint
3929 + ("novfs_ListX_File_Info xattr: /dumping buffer\n");
3930 + novfs_dump(*dataLen, buffer);
3931 + DbgPrint
3932 + ("novfs_ListX_File_Info xattr: \\after dumping buffer\n");
3933
3934 retCode = 0;
3935 }
3936
3937 kfree(reply);
3938 } else {
3939 - DbgPrint("%s xattr: reply = NULL\n", __func__);
3940 + DbgPrint("novfs_ListX_File_Info xattr: reply = NULL\n");
3941 }
3942 kfree(cmd);
3943
3944 @@ -535,21 +558,23 @@ int Novfs_ListX_File_Info(char *Path, ch
3945 return retCode;
3946 }
3947
3948 -static int begin_directory_enumerate(unsigned char *Path, int PathLen, HANDLE *EnumHandle, struct schandle *SessionId)
3949 +static int begin_directory_enumerate(unsigned char * Path, int PathLen, void ** EnumHandle,
3950 + struct novfs_schandle SessionId)
3951 {
3952 - PBEGIN_ENUMERATE_DIRECTORY_REQUEST cmd;
3953 - PBEGIN_ENUMERATE_DIRECTORY_REPLY reply = NULL;
3954 + struct novfs_begin_enumerate_directory_request *cmd;
3955 + struct novfs_begin_enumerate_directory_reply *reply = NULL;
3956 unsigned long replylen = 0;
3957 int retCode, cmdlen;
3958
3959 *EnumHandle = 0;
3960
3961 - cmdlen = offsetof(BEGIN_ENUMERATE_DIRECTORY_REQUEST, path) + PathLen;
3962 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
3963 + cmdlen = offsetof(struct
3964 + novfs_begin_enumerate_directory_request, path) + PathLen;
3965 + cmd = kmalloc(cmdlen, GFP_KERNEL);
3966 if (cmd) {
3967 cmd->Command.CommandType = VFS_COMMAND_START_ENUMERATE;
3968 cmd->Command.SequenceNumber = 0;
3969 - memcpy(&cmd->Command.SessionId, SessionId, sizeof(*SessionId));
3970 + cmd->Command.SessionId = SessionId;
3971
3972 cmd->pathLen = PathLen;
3973 memcpy(cmd->path, Path, PathLen);
3974 @@ -576,16 +601,16 @@ static int begin_directory_enumerate(uns
3975 return (retCode);
3976 }
3977
3978 -static int end_directory_enumerate(HANDLE EnumHandle, struct schandle *SessionId)
3979 +static int end_directory_enumerate(void *EnumHandle, struct novfs_schandle SessionId)
3980 {
3981 - END_ENUMERATE_DIRECTORY_REQUEST cmd;
3982 - PEND_ENUMERATE_DIRECTORY_REPLY reply = NULL;
3983 + struct novfs_end_enumerate_directory_request cmd;
3984 + struct novfs_end_enumerate_directory_reply *reply = NULL;
3985 unsigned long replylen = 0;
3986 int retCode;
3987
3988 cmd.Command.CommandType = VFS_COMMAND_END_ENUMERATE;
3989 cmd.Command.SequenceNumber = 0;
3990 - copy_session_id(&cmd.Command.SessionId, SessionId);
3991 + cmd.Command.SessionId = SessionId;
3992
3993 cmd.enumerateHandle = EnumHandle;
3994
3995 @@ -603,95 +628,24 @@ static int end_directory_enumerate(HANDL
3996 return (retCode);
3997 }
3998
3999 -int directory_enumerate(HANDLE * EnumHandle, struct entry_info *Info,
4000 - session_t SessionId)
4001 +static int directory_enumerate_ex(void ** EnumHandle, struct novfs_schandle SessionId, int *Count,
4002 + struct novfs_entry_info **PInfo, int Interrupt)
4003 {
4004 - ENUMERATE_DIRECTORY_REQUEST cmd;
4005 - PENUMERATE_DIRECTORY_REPLY reply = NULL;
4006 - unsigned long replylen = 0;
4007 - int retCode;
4008 -
4009 - cmd.Command.CommandType = VFS_COMMAND_ENUMERATE_DIRECTORY;
4010 - cmd.Command.SequenceNumber = 0;
4011 - cmd.Command.SessionId = SessionId;
4012 -
4013 - cmd.enumerateHandle = *EnumHandle;
4014 - cmd.pathLen = 0;
4015 - cmd.path[0] = '\0';
4016 -
4017 - retCode =
4018 - Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
4019 - &replylen, INTERRUPTIBLE);
4020 -
4021 - if (reply) {
4022 - /*
4023 - * The VFS_COMMAND_ENUMERATE_DIRECTORY call can return an
4024 - * error but there could still be valid data.
4025 - */
4026 - if (!reply->Reply.ErrorCode ||
4027 - ((replylen > sizeof(COMMAND_REPLY_HEADER)) &&
4028 - (reply->nameLen > 0))) {
4029 - Info->type = 3;
4030 - Info->mode = S_IRWXU;
4031 -
4032 - if (reply->mode & NW_ATTRIBUTE_DIRECTORY) {
4033 - Info->mode |= S_IFDIR;
4034 - Info->mode |= S_IXUSR;
4035 - } else {
4036 - Info->mode |= S_IFREG;
4037 - }
4038 -
4039 - if (reply->mode & NW_ATTRIBUTE_READ_ONLY) {
4040 - Info->mode &= ~(S_IWUSR);
4041 - }
4042 -
4043 - if (reply->mode & NW_ATTRIBUTE_EXECUTE) {
4044 - Info->mode |= S_IXUSR;
4045 - }
4046 -
4047 - Info->uid = current->uid;
4048 - Info->gid = current->gid;
4049 - Info->size = reply->size;
4050 - Info->atime.tv_sec = reply->lastAccessTime;
4051 - Info->atime.tv_nsec = 0;
4052 - Info->mtime.tv_sec = reply->modifyTime;
4053 - Info->mtime.tv_nsec = 0;
4054 - Info->ctime.tv_sec = reply->createTime;
4055 - Info->ctime.tv_nsec = 0;
4056 - Info->namelength = reply->nameLen;
4057 - memcpy(Info->name, reply->name, reply->nameLen);
4058 - retCode = 0;
4059 - if (reply->Reply.ErrorCode) {
4060 - retCode = -1; /* Eof of data */
4061 - }
4062 - *EnumHandle = reply->enumerateHandle;
4063 - } else {
4064 - retCode = -ENODATA;
4065 - }
4066 - kfree(reply);
4067 - }
4068 -
4069 - return (retCode);
4070 -}
4071 -
4072 -static int directory_enumerate_ex(HANDLE *EnumHandle, struct schandle *SessionId, int *Count, struct entry_info **PInfo, int Interrupt)
4073 -{
4074 - ENUMERATE_DIRECTORY_EX_REQUEST cmd;
4075 - PENUMERATE_DIRECTORY_EX_REPLY reply = NULL;
4076 + struct novfs_enumerate_directory_ex_request cmd;
4077 + struct novfs_enumerate_directory_ex_reply *reply = NULL;
4078 unsigned long replylen = 0;
4079 int retCode = 0;
4080 - struct entry_info *info;
4081 - PENUMERATE_DIRECTORY_EX_DATA data;
4082 + struct novfs_entry_info * info;
4083 + struct novfs_enumerate_directory_ex_data *data;
4084 int isize;
4085
4086 - if (PInfo) {
4087 + if (PInfo)
4088 *PInfo = NULL;
4089 - }
4090 *Count = 0;
4091
4092 cmd.Command.CommandType = VFS_COMMAND_ENUMERATE_DIRECTORY_EX;
4093 cmd.Command.SequenceNumber = 0;
4094 - copy_session_id(&cmd.Command.SessionId, SessionId);
4095 + cmd.Command.SessionId = SessionId;
4096
4097 cmd.enumerateHandle = *EnumHandle;
4098 cmd.pathLen = 0;
4099 @@ -709,57 +663,92 @@ static int directory_enumerate_ex(HANDLE
4100 */
4101
4102 if (!reply->Reply.ErrorCode ||
4103 - ((replylen > sizeof(COMMAND_REPLY_HEADER)) &&
4104 + ((replylen > sizeof(struct novfs_command_reply_header)) &&
4105 (reply->enumCount > 0))) {
4106 DbgPrint("directory_enumerate_ex: isize=%d\n",
4107 replylen);
4108 - data = (PENUMERATE_DIRECTORY_EX_DATA) ((char *)reply + sizeof(ENUMERATE_DIRECTORY_EX_REPLY));
4109 - isize = replylen - sizeof(PENUMERATE_DIRECTORY_EX_REPLY) - reply->enumCount * offsetof(ENUMERATE_DIRECTORY_EX_DATA, name);
4110 - isize += (reply->enumCount * offsetof(struct entry_info, name));
4111 + data =
4112 + (struct novfs_enumerate_directory_ex_data *) ((char *)reply +
4113 + sizeof
4114 + (struct novfs_enumerate_directory_ex_reply));
4115 + isize =
4116 + replylen - sizeof(struct novfs_enumerate_directory_ex_reply *) -
4117 + reply->enumCount *
4118 + offsetof(struct
4119 + novfs_enumerate_directory_ex_data, name);
4120 + isize +=
4121 + (reply->enumCount *
4122 + offsetof(struct novfs_entry_info, name));
4123
4124 if (PInfo) {
4125 - *PInfo = info = Novfs_Malloc(isize, GFP_KERNEL);
4126 + *PInfo = info = kmalloc(isize, GFP_KERNEL);
4127 if (*PInfo) {
4128 - DbgPrint("directory_enumerate_ex1: data=0x%p info=0x%p\n", data, info);
4129 + DbgPrint
4130 + ("directory_enumerate_ex1: data=0x%p info=0x%p\n",
4131 + data, info);
4132 *Count = reply->enumCount;
4133 do {
4134 - DbgPrint("directory_enumerate_ex2: data=0x%p length=%d\n", data);
4135 + DbgPrint
4136 + ("directory_enumerate_ex2: data=0x%p length=%d\n",
4137 + data);
4138
4139 info->type = 3;
4140 info->mode = S_IRWXU;
4141
4142 - if (data->mode & NW_ATTRIBUTE_DIRECTORY) {
4143 + if (data->
4144 + mode &
4145 + NW_ATTRIBUTE_DIRECTORY) {
4146 info->mode |= S_IFDIR;
4147 info->mode |= S_IXUSR;
4148 } else {
4149 info->mode |= S_IFREG;
4150 }
4151
4152 - if (data->mode & NW_ATTRIBUTE_READ_ONLY) {
4153 - info->mode &= ~(S_IWUSR);
4154 + if (data->
4155 + mode &
4156 + NW_ATTRIBUTE_READ_ONLY) {
4157 + info->mode &=
4158 + ~(S_IWUSR);
4159 }
4160
4161 - if (data->mode & NW_ATTRIBUTE_EXECUTE) {
4162 + if (data->
4163 + mode & NW_ATTRIBUTE_EXECUTE)
4164 + {
4165 info->mode |= S_IXUSR;
4166 }
4167
4168 info->uid = current->euid;
4169 info->gid = current->egid;
4170 info->size = data->size;
4171 - info->atime.tv_sec = data->lastAccessTime;
4172 + info->atime.tv_sec =
4173 + data->lastAccessTime;
4174 info->atime.tv_nsec = 0;
4175 - info->mtime.tv_sec = data->modifyTime;
4176 + info->mtime.tv_sec =
4177 + data->modifyTime;
4178 info->mtime.tv_nsec = 0;
4179 - info->ctime.tv_sec = data->createTime;
4180 + info->ctime.tv_sec =
4181 + data->createTime;
4182 info->ctime.tv_nsec = 0;
4183 - info->namelength = data->nameLen;
4184 - memcpy(info->name, data->name, data->nameLen);
4185 - data = (PENUMERATE_DIRECTORY_EX_DATA)&data->name[data->nameLen];
4186 - replylen = (int)((char *)&info->name[info->namelength] - (char *)info);
4187 - DbgPrint("directory_enumerate_ex3: info=0x%p\n", info);
4188 - mydump(replylen, info);
4189 -
4190 - info = (struct entry_info *)&info->name[info->namelength];
4191 + info->namelength =
4192 + data->nameLen;
4193 + memcpy(info->name, data->name,
4194 + data->nameLen);
4195 + data =
4196 + (struct novfs_enumerate_directory_ex_data *)
4197 + & data->name[data->nameLen];
4198 + replylen =
4199 + (int)((char *)&info->
4200 + name[info->
4201 + namelength] -
4202 + (char *)info);
4203 + DbgPrint
4204 + ("directory_enumerate_ex3: info=0x%p\n",
4205 + info);
4206 + novfs_dump(replylen, info);
4207 +
4208 + info =
4209 + (struct novfs_entry_info *) & info->
4210 + name[info->namelength];
4211
4212 } while (--reply->enumCount);
4213 }
4214 @@ -778,8 +767,9 @@ static int directory_enumerate_ex(HANDLE
4215 return (retCode);
4216 }
4217
4218 -int Novfs_Get_Directory_ListEx(unsigned char * Path, HANDLE * EnumHandle, int *Count,
4219 - struct entry_info **Info, struct schandle *SessionId)
4220 +int novfs_get_dir_listex(unsigned char * Path, void ** EnumHandle, int *Count,
4221 + struct novfs_entry_info **Info,
4222 + struct novfs_schandle SessionId)
4223 {
4224 int retCode = -ENOENT;
4225
4226 @@ -788,15 +778,20 @@ int Novfs_Get_Directory_ListEx(unsigned
4227 if (Info)
4228 *Info = NULL;
4229
4230 - if ((HANDLE) - 1 == *EnumHandle) {
4231 + if ((void *) - 1 == *EnumHandle) {
4232 return (-ENODATA);
4233 }
4234
4235 - if (0 == *EnumHandle)
4236 - retCode = begin_directory_enumerate(Path, strlen(Path), EnumHandle, SessionId);
4237 + if (0 == *EnumHandle) {
4238 + retCode =
4239 + begin_directory_enumerate(Path, strlen(Path), EnumHandle,
4240 + SessionId);
4241 + }
4242
4243 if (*EnumHandle) {
4244 - retCode = directory_enumerate_ex(EnumHandle, SessionId, Count, Info, INTERRUPTIBLE);
4245 + retCode =
4246 + directory_enumerate_ex(EnumHandle, SessionId, Count, Info,
4247 + INTERRUPTIBLE);
4248 if (retCode) {
4249 end_directory_enumerate(*EnumHandle, SessionId);
4250 if (-1 == retCode) {
4251 @@ -808,11 +803,12 @@ int Novfs_Get_Directory_ListEx(unsigned
4252 return (retCode);
4253 }
4254
4255 -int Novfs_Open_File(unsigned char * Path, int Flags, struct entry_info *Info, HANDLE * Handle,
4256 - session_t SessionId)
4257 +int novfs_open_file(unsigned char * Path, int Flags, struct novfs_entry_info * Info,
4258 + void ** Handle,
4259 + struct novfs_schandle SessionId)
4260 {
4261 - POPEN_FILE_REQUEST cmd;
4262 - POPEN_FILE_REPLY reply;
4263 + struct novfs_open_file_request *cmd;
4264 + struct novfs_open_file_reply *reply;
4265 unsigned long replylen = 0;
4266 int retCode, cmdlen, pathlen;
4267
4268 @@ -825,8 +821,8 @@ int Novfs_Open_File(unsigned char * Path
4269
4270 *Handle = 0;
4271
4272 - cmdlen = offsetof(OPEN_FILE_REQUEST, path) + pathlen;
4273 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
4274 + cmdlen = offsetof(struct novfs_open_file_request, path) + pathlen;
4275 + cmd = kmalloc(cmdlen, GFP_KERNEL);
4276 if (cmd) {
4277 cmd->Command.CommandType = VFS_COMMAND_OPEN_FILE;
4278 cmd->Command.SequenceNumber = 0;
4279 @@ -903,10 +899,10 @@ int Novfs_Open_File(unsigned char * Path
4280 return (retCode);
4281 }
4282
4283 -int Novfs_Create(unsigned char * Path, int DirectoryFlag, session_t SessionId)
4284 +int novfs_create(unsigned char * Path, int DirectoryFlag, struct novfs_schandle SessionId)
4285 {
4286 - PCREATE_FILE_REQUEST cmd;
4287 - PCREATE_FILE_REPLY reply;
4288 + struct novfs_create_file_request *cmd;
4289 + struct novfs_create_file_reply *reply;
4290 unsigned long replylen = 0;
4291 int retCode, cmdlen, pathlen;
4292
4293 @@ -917,8 +913,8 @@ int Novfs_Create(unsigned char * Path, i
4294 pathlen--;
4295 }
4296
4297 - cmdlen = offsetof(CREATE_FILE_REQUEST, path) + pathlen;
4298 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
4299 + cmdlen = offsetof(struct novfs_create_file_request, path) + pathlen;
4300 + cmd = kmalloc(cmdlen, GFP_KERNEL);
4301 if (cmd) {
4302 cmd->Command.CommandType = VFS_COMMAND_CREATE_FILE;
4303 if (DirectoryFlag) {
4304 @@ -948,10 +944,10 @@ int Novfs_Create(unsigned char * Path, i
4305 return (retCode);
4306 }
4307
4308 -int Novfs_Close_File(HANDLE Handle, session_t SessionId)
4309 +int novfs_close_file(void *Handle, struct novfs_schandle SessionId)
4310 {
4311 - CLOSE_FILE_REQUEST cmd;
4312 - PCLOSE_FILE_REPLY reply;
4313 + struct novfs_close_file_request cmd;
4314 + struct novfs_close_file_reply *reply;
4315 unsigned long replylen = 0;
4316 int retCode;
4317
4318 @@ -974,11 +970,11 @@ int Novfs_Close_File(HANDLE Handle, sess
4319 return (retCode);
4320 }
4321
4322 -int Novfs_Read_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
4323 - loff_t * Offset, session_t SessionId)
4324 +int novfs_read_file(void *Handle, unsigned char * Buffer, size_t * Bytes,
4325 + loff_t * Offset, struct novfs_schandle SessionId)
4326 {
4327 - READ_FILE_REQUEST cmd;
4328 - PREAD_FILE_REPLY reply = NULL;
4329 + struct novfs_read_file_request cmd;
4330 + struct novfs_read_file_reply * reply = NULL;
4331 unsigned long replylen = 0;
4332 int retCode = 0;
4333 size_t len;
4334 @@ -986,8 +982,10 @@ int Novfs_Read_File(HANDLE Handle, unsig
4335 len = *Bytes;
4336 *Bytes = 0;
4337
4338 - if ((offsetof(READ_FILE_REPLY, data) + len) > MaxIoSize) {
4339 - len = MaxIoSize - offsetof(READ_FILE_REPLY, data);
4340 + if (offsetof(struct novfs_read_file_reply, data) + len
4341 + > novfs_max_iosize) {
4342 + len = novfs_max_iosize - offsetof(struct
4343 + novfs_read_file_reply, data);
4344 len = (len / PAGE_SIZE) * PAGE_SIZE;
4345 }
4346
4347 @@ -999,9 +997,12 @@ int Novfs_Read_File(HANDLE Handle, unsig
4348 cmd.len = len;
4349 cmd.offset = *Offset;
4350
4351 - retCode = Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
4352 + retCode =
4353 + Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
4354 + &replylen, INTERRUPTIBLE);
4355
4356 - DbgPrint("Novfs_Read_File: Queue_Daemon_Command 0x%x replylen=%d\n", retCode, replylen);
4357 + DbgPrint("novfs_Read_File: Queue_Daemon_Command 0x%x replylen=%d\n",
4358 + retCode, replylen);
4359
4360 if (!retCode) {
4361 if (reply->Reply.ErrorCode) {
4362 @@ -1011,9 +1012,12 @@ int Novfs_Read_File(HANDLE Handle, unsig
4363 retCode = -EIO;
4364 }
4365 } else {
4366 - replylen -= offsetof(READ_FILE_REPLY, data);
4367 + replylen -= offsetof(struct
4368 + novfs_read_file_reply, data);
4369 +
4370 if (replylen > 0) {
4371 - replylen -= copy_to_user(Buffer, reply->data, replylen);
4372 + replylen -=
4373 + copy_to_user(Buffer, reply->data, replylen);
4374 *Bytes = replylen;
4375 }
4376 }
4377 @@ -1023,17 +1027,18 @@ int Novfs_Read_File(HANDLE Handle, unsig
4378 kfree(reply);
4379 }
4380
4381 - DbgPrint("Novfs_Read_File *Bytes=0x%x retCode=0x%x\n", *Bytes, retCode);
4382 + DbgPrint("novfs_Read_File *Bytes=0x%x retCode=0x%x\n", *Bytes, retCode);
4383
4384 return (retCode);
4385 }
4386
4387 -int Novfs_Read_Pages(HANDLE Handle, struct data_list *DList, int DList_Cnt,
4388 - size_t * Bytes, loff_t * Offset, session_t SessionId)
4389 +int novfs_read_pages(void *Handle, struct novfs_data_list *DList,
4390 + int DList_Cnt, size_t * Bytes, loff_t * Offset,
4391 + struct novfs_schandle SessionId)
4392 {
4393 - READ_FILE_REQUEST cmd;
4394 - PREAD_FILE_REPLY reply = NULL;
4395 - READ_FILE_REPLY lreply;
4396 + struct novfs_read_file_request cmd;
4397 + struct novfs_read_file_reply * reply = NULL;
4398 + struct novfs_read_file_reply lreply;
4399 unsigned long replylen = 0;
4400 int retCode = 0;
4401 size_t len;
4402 @@ -1042,7 +1047,7 @@ int Novfs_Read_Pages(HANDLE Handle, stru
4403 *Bytes = 0;
4404
4405 DbgPrint
4406 - ("Novfs_Read_Pages: Handle=0x%p Dlst=0x%p Dlcnt=%d Bytes=%d Offset=%lld SessionId=0x%p:%p\n",
4407 + ("novfs_Read_Pages: Handle=0x%p Dlst=0x%p Dlcnt=%d Bytes=%d Offset=%lld SessionId=0x%p:%p\n",
4408 Handle, DList, DList_Cnt, len, *Offset, SessionId.hTypeId,
4409 SessionId.hId);
4410
4411 @@ -1059,14 +1064,14 @@ int Novfs_Read_Pages(HANDLE Handle, stru
4412 */
4413 DList[0].page = NULL;
4414 DList[0].offset = &lreply;
4415 - DList[0].len = offsetof(READ_FILE_REPLY, data);
4416 + DList[0].len = offsetof(struct novfs_read_file_reply, data);
4417 DList[0].rwflag = DLWRITE;
4418
4419 retCode =
4420 Queue_Daemon_Command(&cmd, sizeof(cmd), DList, DList_Cnt,
4421 (void *)&reply, &replylen, INTERRUPTIBLE);
4422
4423 - DbgPrint("Novfs_Read_Pages: Queue_Daemon_Command 0x%x\n", retCode);
4424 + DbgPrint("novfs_Read_Pages: Queue_Daemon_Command 0x%x\n", retCode);
4425
4426 if (!retCode) {
4427 if (reply) {
4428 @@ -1080,44 +1085,45 @@ int Novfs_Read_Pages(HANDLE Handle, stru
4429 retCode = -EIO;
4430 }
4431 }
4432 - *Bytes = replylen - offsetof(READ_FILE_REPLY, data);
4433 + *Bytes = replylen - offsetof(struct
4434 + novfs_read_file_reply, data);
4435 }
4436
4437 if (reply) {
4438 kfree(reply);
4439 }
4440
4441 - DbgPrint("Novfs_Read_Pages: retCode=0x%x\n", retCode);
4442 + DbgPrint("novfs_Read_Pages: retCode=0x%x\n", retCode);
4443
4444 return (retCode);
4445 }
4446
4447 -int Novfs_Write_File(HANDLE Handle, unsigned char * Buffer, size_t * Bytes,
4448 - loff_t * Offset, session_t SessionId)
4449 +int novfs_write_file(void *Handle, unsigned char * Buffer, size_t * Bytes,
4450 + loff_t * Offset, struct novfs_schandle SessionId)
4451 {
4452 - WRITE_FILE_REQUEST cmd;
4453 - PWRITE_FILE_REPLY reply = NULL;
4454 + struct novfs_write_file_request cmd;
4455 + struct novfs_write_file_reply *reply = NULL;
4456 unsigned long replylen = 0;
4457 int retCode = 0, cmdlen;
4458 size_t len;
4459
4460 unsigned long boff;
4461 struct page **pages;
4462 - struct data_list *dlist;
4463 + struct novfs_data_list *dlist;
4464 int res = 0, npage, i;
4465 - WRITE_FILE_REPLY lreply;
4466 + struct novfs_write_file_reply lreply;
4467
4468 len = *Bytes;
4469 - cmdlen = offsetof(WRITE_FILE_REQUEST, data);
4470 + cmdlen = offsetof(struct novfs_write_file_request, data);
4471
4472 *Bytes = 0;
4473
4474 memset(&lreply, 0, sizeof(lreply));
4475
4476 - DbgPrint("Novfs_Write_File cmdlen=%ld len=%ld\n", cmdlen, len);
4477 + DbgPrint("novfs_Write_File cmdlen=%ld len=%ld\n", cmdlen, len);
4478
4479 - if ((cmdlen + len) > MaxIoSize) {
4480 - len = MaxIoSize - cmdlen;
4481 + if ((cmdlen + len) > novfs_max_iosize) {
4482 + len = novfs_max_iosize - cmdlen;
4483 len = (len / PAGE_SIZE) * PAGE_SIZE;
4484 }
4485 cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
4486 @@ -1127,18 +1133,18 @@ int Novfs_Write_File(HANDLE Handle, unsi
4487 cmd.len = len;
4488 cmd.offset = *Offset;
4489
4490 - DbgPrint("Novfs_Write_File cmdlen=%ld len=%ld\n", cmdlen, len);
4491 + DbgPrint("novfs_Write_File cmdlen=%ld len=%ld\n", cmdlen, len);
4492
4493 npage =
4494 (((unsigned long)Buffer & ~PAGE_MASK) + len +
4495 (PAGE_SIZE - 1)) >> PAGE_SHIFT;
4496
4497 - dlist = Novfs_Malloc(sizeof(struct data_list) * (npage + 1), GFP_KERNEL);
4498 + dlist = kmalloc(sizeof(struct novfs_data_list) * (npage + 1), GFP_KERNEL);
4499 if (NULL == dlist) {
4500 return (-ENOMEM);
4501 }
4502
4503 - pages = Novfs_Malloc(sizeof(struct page *) * npage, GFP_KERNEL);
4504 + pages = kmalloc(sizeof(struct page *) * npage, GFP_KERNEL);
4505
4506 if (NULL == pages) {
4507 kfree(dlist);
4508 @@ -1153,7 +1159,7 @@ int Novfs_Write_File(HANDLE Handle, unsi
4509
4510 up_read(&current->mm->mmap_sem);
4511
4512 - DbgPrint("Novfs_Write_File res=%d\n", res);
4513 + DbgPrint("novfs_Write_File res=%d\n", res);
4514
4515 if (res > 0) {
4516 boff = (unsigned long)Buffer & ~PAGE_MASK;
4517 @@ -1168,12 +1174,12 @@ int Novfs_Write_File(HANDLE Handle, unsi
4518 dlist[0].len = len;
4519 }
4520
4521 - DbgPrint("Novfs_Write_File0: page=0x%p offset=0x%p len=%d\n",
4522 + DbgPrint("novfs_Write_File0: page=0x%p offset=0x%p len=%d\n",
4523 dlist[0].page, dlist[0].offset, dlist[0].len);
4524
4525 boff = dlist[0].len;
4526
4527 - DbgPrint("Novfs_Write_File len=%d boff=%d\n", len, boff);
4528 + DbgPrint("novfs_Write_File len=%d boff=%d\n", len, boff);
4529
4530 for (i = 1; (i < res) && (boff < len); i++) {
4531 flush_dcache_page(pages[i]);
4532 @@ -1188,7 +1194,7 @@ int Novfs_Write_File(HANDLE Handle, unsi
4533
4534 boff += dlist[i].len;
4535 DbgPrint
4536 - ("Novfs_Write_File%d: page=0x%p offset=0x%p len=%d\n",
4537 + ("novfs_Write_File%d: page=0x%p offset=0x%p len=%d\n",
4538 i, dlist[i].page, dlist[i].offset, dlist[i].len);
4539 }
4540
4541 @@ -1198,7 +1204,7 @@ int Novfs_Write_File(HANDLE Handle, unsi
4542 dlist[i].rwflag = DLWRITE;
4543 res++;
4544
4545 - DbgPrint("Novfs_Write_File Buffer=0x%p boff=0x%x len=%d\n",
4546 + DbgPrint("novfs_Write_File Buffer=0x%p boff=0x%x len=%d\n",
4547 Buffer, boff, len);
4548
4549 retCode =
4550 @@ -1211,7 +1217,7 @@ int Novfs_Write_File(HANDLE Handle, unsi
4551
4552 res = 0;
4553
4554 - kdata = Novfs_Malloc(len, GFP_KERNEL);
4555 + kdata = kmalloc(len, GFP_KERNEL);
4556 if (kdata) {
4557 len -= copy_from_user(kdata, Buffer, len);
4558 dlist[0].page = NULL;
4559 @@ -1233,7 +1239,7 @@ int Novfs_Write_File(HANDLE Handle, unsi
4560 }
4561 }
4562
4563 - DbgPrint("Novfs_Write_File retCode=0x%x reply=0x%p\n", retCode, reply);
4564 + DbgPrint("novfs_Write_File retCode=0x%x reply=0x%p\n", retCode, reply);
4565
4566 if (!retCode) {
4567 switch (lreply.Reply.ErrorCode) {
4568 @@ -1267,7 +1273,7 @@ int Novfs_Write_File(HANDLE Handle, unsi
4569 kfree(pages);
4570 kfree(dlist);
4571
4572 - DbgPrint("Novfs_Write_File *Bytes=0x%x retCode=0x%x\n", *Bytes,
4573 + DbgPrint("novfs_Write_File *Bytes=0x%x retCode=0x%x\n", *Bytes,
4574 retCode);
4575
4576 return (retCode);
4577 @@ -1276,7 +1282,7 @@ int Novfs_Write_File(HANDLE Handle, unsi
4578 /*
4579 * Arguments: HANDLE Handle - novfsd file handle
4580 * struct page *Page - Page to be written out
4581 - * session_t SessionId - novfsd session handle
4582 + * struct novfs_schandle SessionId - novfsd session handle
4583 *
4584 * Returns: 0 - Success
4585 * -ENOSPC - Out of space on server
4586 @@ -1285,17 +1291,17 @@ int Novfs_Write_File(HANDLE Handle, unsi
4587 *
4588 * Abstract: Write page to file.
4589 */
4590 -int Novfs_Write_Page(HANDLE Handle, struct page *Page, session_t SessionId)
4591 +int novfs_write_page(void *Handle, struct page *Page, struct novfs_schandle SessionId)
4592 {
4593 - WRITE_FILE_REQUEST cmd;
4594 - WRITE_FILE_REPLY lreply;
4595 - PWRITE_FILE_REPLY reply = NULL;
4596 + struct novfs_write_file_request cmd;
4597 + struct novfs_write_file_reply lreply;
4598 + struct novfs_write_file_reply *reply = NULL;
4599 unsigned long replylen = 0;
4600 int retCode = 0, cmdlen;
4601 - struct data_list dlst[2];
4602 + struct novfs_data_list dlst[2];
4603
4604 DbgPrint
4605 - ("Novfs_Write_Page: Handle=0x%p Page=0x%p Index=%lu SessionId=0x%llx\n",
4606 + ("novfs_Write_Page: Handle=0x%p Page=0x%p Index=%lu SessionId=0x%llx\n",
4607 Handle, Page, Page->index, SessionId);
4608
4609 dlst[0].page = NULL;
4610 @@ -1308,7 +1314,7 @@ int Novfs_Write_Page(HANDLE Handle, stru
4611 dlst[1].len = PAGE_CACHE_SIZE;
4612 dlst[1].rwflag = DLREAD;
4613
4614 - cmdlen = offsetof(WRITE_FILE_REQUEST, data);
4615 + cmdlen = offsetof(struct novfs_write_file_request, data);
4616
4617 cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
4618 cmd.Command.SequenceNumber = 0;
4619 @@ -1348,23 +1354,23 @@ int Novfs_Write_Page(HANDLE Handle, stru
4620 kfree(reply);
4621 }
4622
4623 - DbgPrint("Novfs_Write_Page retCode=0x%x\n", retCode);
4624 + DbgPrint("novfs_Write_Page retCode=0x%x\n", retCode);
4625
4626 return (retCode);
4627 }
4628
4629 -int Novfs_Write_Pages(HANDLE Handle, struct data_list *DList, int DList_Cnt,
4630 - size_t Bytes, loff_t Offset, session_t SessionId)
4631 +int novfs_write_pages(void *Handle, struct novfs_data_list *DList, int DList_Cnt,
4632 + size_t Bytes, loff_t Offset, struct novfs_schandle SessionId)
4633 {
4634 - WRITE_FILE_REQUEST cmd;
4635 - WRITE_FILE_REPLY lreply;
4636 - PWRITE_FILE_REPLY reply = NULL;
4637 + struct novfs_write_file_request cmd;
4638 + struct novfs_write_file_reply lreply;
4639 + struct novfs_write_file_reply *reply = NULL;
4640 unsigned long replylen = 0;
4641 int retCode = 0, cmdlen;
4642 size_t len;
4643
4644 DbgPrint
4645 - ("Novfs_Write_Pages: Handle=0x%p Dlst=0x%p Dlcnt=%d Bytes=%d Offset=%lld SessionId=0x%llx\n",
4646 + ("novfs_Write_Pages: Handle=0x%p Dlst=0x%p Dlcnt=%d Bytes=%d Offset=%lld SessionId=0x%llx\n",
4647 Handle, DList, DList_Cnt, Bytes, Offset, SessionId);
4648
4649 DList[0].page = NULL;
4650 @@ -1373,7 +1379,7 @@ int Novfs_Write_Pages(HANDLE Handle, str
4651 DList[0].rwflag = DLWRITE;
4652
4653 len = Bytes;
4654 - cmdlen = offsetof(WRITE_FILE_REQUEST, data);
4655 + cmdlen = offsetof(struct novfs_write_file_request, data);
4656
4657 if (len) {
4658 cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
4659 @@ -1414,17 +1420,17 @@ int Novfs_Write_Pages(HANDLE Handle, str
4660 kfree(reply);
4661 }
4662 }
4663 - DbgPrint("Novfs_Write_Pages retCode=0x%x\n", retCode);
4664 + DbgPrint("novfs_Write_Pages retCode=0x%x\n", retCode);
4665
4666 return (retCode);
4667 }
4668
4669 -int Novfs_Read_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
4670 +int novfs_read_stream(void *ConnHandle, unsigned char * Handle, u_char * Buffer,
4671 size_t * Bytes, loff_t * Offset, int User,
4672 - session_t SessionId)
4673 + struct novfs_schandle SessionId)
4674 {
4675 - READ_STREAM_REQUEST cmd;
4676 - PREAD_STREAM_REPLY reply = NULL;
4677 + struct novfs_read_stream_request cmd;
4678 + struct novfs_read_stream_reply *reply = NULL;
4679 unsigned long replylen = 0;
4680 int retCode = 0;
4681 size_t len;
4682 @@ -1432,8 +1438,10 @@ int Novfs_Read_Stream(HANDLE ConnHandle,
4683 len = *Bytes;
4684 *Bytes = 0;
4685
4686 - if ((offsetof(READ_FILE_REPLY, data) + len) > MaxIoSize) {
4687 - len = MaxIoSize - offsetof(READ_FILE_REPLY, data);
4688 + if (offsetof(struct novfs_read_file_reply, data) + len
4689 + > novfs_max_iosize) {
4690 + len = novfs_max_iosize - offsetof(struct
4691 + novfs_read_file_reply, data);
4692 len = (len / PAGE_SIZE) * PAGE_SIZE;
4693 }
4694
4695 @@ -1446,60 +1454,70 @@ int Novfs_Read_Stream(HANDLE ConnHandle,
4696 cmd.len = len;
4697 cmd.offset = *Offset;
4698
4699 - retCode = Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply, &replylen, INTERRUPTIBLE);
4700 + retCode =
4701 + Queue_Daemon_Command(&cmd, sizeof(cmd), NULL, 0, (void *)&reply,
4702 + &replylen, INTERRUPTIBLE);
4703
4704 - DbgPrint("Novfs_Read_Stream: Queue_Daemon_Command 0x%x replylen=%d\n", retCode, replylen);
4705 + DbgPrint("novfs_Read_Stream: Queue_Daemon_Command 0x%x replylen=%d\n",
4706 + retCode, replylen);
4707
4708 if (reply) {
4709 retCode = 0;
4710 if (reply->Reply.ErrorCode) {
4711 retCode = -EIO;
4712 } else {
4713 - replylen -= offsetof(READ_STREAM_REPLY, data);
4714 + replylen -= offsetof(struct
4715 + novfs_read_stream_reply, data);
4716 if (replylen > 0) {
4717 - if (User)
4718 - replylen -= copy_to_user(Buffer, reply->data, replylen);
4719 - else
4720 + if (User) {
4721 + replylen -=
4722 + copy_to_user(Buffer, reply->data,
4723 + replylen);
4724 + } else {
4725 memcpy(Buffer, reply->data, replylen);
4726 + }
4727 +
4728 *Bytes = replylen;
4729 }
4730 }
4731 kfree(reply);
4732 }
4733
4734 - DbgPrint("Novfs_Read_Stream *Bytes=0x%x retCode=0x%x\n", *Bytes, retCode);
4735 + DbgPrint("novfs_Read_Stream *Bytes=0x%x retCode=0x%x\n", *Bytes,
4736 + retCode);
4737
4738 return (retCode);
4739 }
4740
4741 -int Novfs_Write_Stream(HANDLE ConnHandle, unsigned char * Handle, unsigned char * Buffer,
4742 - size_t * Bytes, loff_t * Offset, session_t SessionId)
4743 +int novfs_write_stream(void *ConnHandle, unsigned char * Handle, u_char * Buffer,
4744 + size_t * Bytes, loff_t * Offset, struct novfs_schandle SessionId)
4745 {
4746 - PWRITE_STREAM_REQUEST cmd;
4747 - PWRITE_STREAM_REPLY reply = NULL;
4748 + struct novfs_write_stream_request * cmd;
4749 + struct novfs_write_stream_reply * reply = NULL;
4750 unsigned long replylen = 0;
4751 int retCode = 0, cmdlen;
4752 size_t len;
4753
4754 len = *Bytes;
4755 - cmdlen = len + offsetof(WRITE_STREAM_REQUEST, data);
4756 + cmdlen = len + offsetof(struct novfs_write_stream_request, data);
4757 *Bytes = 0;
4758
4759 - if (cmdlen > MaxIoSize) {
4760 - cmdlen = MaxIoSize;
4761 - len = cmdlen - offsetof(WRITE_STREAM_REQUEST, data);
4762 + if (cmdlen > novfs_max_iosize) {
4763 + cmdlen = novfs_max_iosize;
4764 + len = cmdlen - offsetof(struct
4765 + novfs_write_stream_request, data);
4766 }
4767
4768 - DbgPrint("Novfs_Write_Stream cmdlen=%d len=%d\n", cmdlen, len);
4769 + DbgPrint("novfs_Write_Stream cmdlen=%d len=%d\n", cmdlen, len);
4770
4771 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
4772 + cmd = kmalloc(cmdlen, GFP_KERNEL);
4773
4774 if (cmd) {
4775 if (Buffer && len) {
4776 len -= copy_from_user(cmd->data, Buffer, len);
4777 }
4778
4779 - DbgPrint("Novfs_Write_Stream len=%d\n", len);
4780 + DbgPrint("novfs_Write_Stream len=%d\n", len);
4781
4782 cmd->Command.CommandType = VFS_COMMAND_WRITE_STREAM;
4783 cmd->Command.SequenceNumber = 0;
4784 @@ -1532,23 +1550,23 @@ int Novfs_Write_Stream(HANDLE ConnHandle
4785 break;
4786 }
4787 DbgPrint
4788 - ("Novfs_Write_Stream reply->bytesWritten=0x%lx\n",
4789 + ("novfs_Write_Stream reply->bytesWritten=0x%lx\n",
4790 reply->bytesWritten);
4791 *Bytes = reply->bytesWritten;
4792 kfree(reply);
4793 }
4794 kfree(cmd);
4795 }
4796 - DbgPrint("Novfs_Write_Stream *Bytes=0x%x retCode=0x%x\n", *Bytes,
4797 + DbgPrint("novfs_Write_Stream *Bytes=0x%x retCode=0x%x\n", *Bytes,
4798 retCode);
4799
4800 return (retCode);
4801 }
4802
4803 -int Novfs_Close_Stream(HANDLE ConnHandle, unsigned char * Handle, session_t SessionId)
4804 +int novfs_close_stream(void *ConnHandle, unsigned char * Handle, struct novfs_schandle SessionId)
4805 {
4806 - CLOSE_STREAM_REQUEST cmd;
4807 - PCLOSE_STREAM_REPLY reply;
4808 + struct novfs_close_stream_request cmd;
4809 + struct novfs_close_stream_reply *reply;
4810 unsigned long replylen = 0;
4811 int retCode;
4812
4813 @@ -1572,10 +1590,10 @@ int Novfs_Close_Stream(HANDLE ConnHandle
4814 return (retCode);
4815 }
4816
4817 -int Novfs_Delete(unsigned char * Path, int DirectoryFlag, session_t SessionId)
4818 +int novfs_delete(unsigned char * Path, int DirectoryFlag, struct novfs_schandle SessionId)
4819 {
4820 - PDELETE_FILE_REQUEST cmd;
4821 - PDELETE_FILE_REPLY reply;
4822 + struct novfs_delete_file_request *cmd;
4823 + struct novfs_delete_file_reply *reply;
4824 unsigned long replylen = 0;
4825 int retCode, cmdlen, pathlen;
4826
4827 @@ -1586,8 +1604,8 @@ int Novfs_Delete(unsigned char * Path, i
4828 pathlen--;
4829 }
4830
4831 - cmdlen = offsetof(DELETE_FILE_REQUEST, path) + pathlen;
4832 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
4833 + cmdlen = offsetof(struct novfs_delete_file_request, path) + pathlen;
4834 + cmd = kmalloc(cmdlen, GFP_KERNEL);
4835 if (cmd) {
4836 cmd->Command.CommandType = VFS_COMMAND_DELETE_FILE;
4837 cmd->Command.SequenceNumber = 0;
4838 @@ -1618,10 +1636,11 @@ int Novfs_Delete(unsigned char * Path, i
4839 return (retCode);
4840 }
4841
4842 -int Novfs_Truncate_File(unsigned char * Path, int PathLen, session_t SessionId)
4843 +int novfs_trunc(unsigned char * Path, int PathLen,
4844 + struct novfs_schandle SessionId)
4845 {
4846 - PTRUNCATE_FILE_REQUEST cmd;
4847 - PTRUNCATE_FILE_REPLY reply;
4848 + struct novfs_truncate_file_request *cmd;
4849 + struct novfs_truncate_file_reply *reply = NULL;
4850 unsigned long replylen = 0;
4851 int retCode, cmdlen;
4852
4853 @@ -1629,8 +1648,9 @@ int Novfs_Truncate_File(unsigned char *
4854 if ('.' == Path[PathLen - 1])
4855 PathLen--;
4856 }
4857 - cmdlen = offsetof(TRUNCATE_FILE_REQUEST, path) + PathLen;
4858 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
4859 + cmdlen = offsetof(struct novfs_truncate_file_request, path)
4860 + + PathLen;
4861 + cmd = kmalloc(cmdlen, GFP_KERNEL);
4862 if (cmd) {
4863 cmd->Command.CommandType = VFS_COMMAND_TRUNCATE_FILE;
4864 cmd->Command.SequenceNumber = 0;
4865 @@ -1655,17 +1675,18 @@ int Novfs_Truncate_File(unsigned char *
4866 return (retCode);
4867 }
4868
4869 -int Novfs_Truncate_File_Ex(HANDLE Handle, loff_t Offset, session_t SessionId)
4870 +int novfs_trunc_ex(void *Handle, loff_t Offset,
4871 + struct novfs_schandle SessionId)
4872 {
4873 - WRITE_FILE_REQUEST cmd;
4874 - PWRITE_FILE_REPLY reply = NULL;
4875 + struct novfs_write_file_request cmd;
4876 + struct novfs_write_file_reply *reply = NULL;
4877 unsigned long replylen = 0;
4878 int retCode = 0, cmdlen;
4879
4880 - DbgPrint("Novfs_Truncate_File_Ex Handle=0x%p Offset=%lld\n", Handle,
4881 + DbgPrint("novfs_Truncate_File_Ex Handle=0x%p Offset=%lld\n", Handle,
4882 Offset);
4883
4884 - cmdlen = offsetof(WRITE_FILE_REQUEST, data);
4885 + cmdlen = offsetof(struct novfs_write_file_request, data);
4886
4887 cmd.Command.CommandType = VFS_COMMAND_WRITE_FILE;
4888 cmd.Command.SequenceNumber = 0;
4889 @@ -1678,7 +1699,7 @@ int Novfs_Truncate_File_Ex(HANDLE Handle
4890 Queue_Daemon_Command(&cmd, cmdlen, NULL, 0, (void *)&reply,
4891 &replylen, INTERRUPTIBLE);
4892
4893 - DbgPrint("Novfs_Truncate_File_Ex retCode=0x%x reply=0x%p\n", retCode,
4894 + DbgPrint("novfs_Truncate_File_Ex retCode=0x%x reply=0x%p\n", retCode,
4895 reply);
4896
4897 if (!retCode) {
4898 @@ -1709,20 +1730,21 @@ int Novfs_Truncate_File_Ex(HANDLE Handle
4899 kfree(reply);
4900 }
4901
4902 - DbgPrint("Novfs_Truncate_File_Ex retCode=%d\n", retCode);
4903 + DbgPrint("novfs_Truncate_File_Ex retCode=%d\n", retCode);
4904
4905 return (retCode);
4906 }
4907
4908 -int Novfs_Rename_File(int DirectoryFlag, unsigned char * OldName, int OldLen,
4909 - unsigned char * NewName, int NewLen, session_t SessionId)
4910 +int novfs_rename_file(int DirectoryFlag, unsigned char * OldName, int OldLen,
4911 + unsigned char * NewName, int NewLen,
4912 + struct novfs_schandle SessionId)
4913 {
4914 - RENAME_FILE_REQUEST cmd;
4915 - PRENAME_FILE_REPLY reply;
4916 + struct novfs_rename_file_request cmd;
4917 + struct novfs_rename_file_reply *reply;
4918 unsigned long replylen = 0;
4919 int retCode;
4920
4921 - DbgPrint("Novfs_Rename_File:\n"
4922 + DbgPrint("novfs_Rename_File:\n"
4923 " DirectoryFlag: %d\n"
4924 " OldName: %.*s\n"
4925 " NewName: %.*s\n"
4926 @@ -1761,10 +1783,11 @@ int Novfs_Rename_File(int DirectoryFlag,
4927 return (retCode);
4928 }
4929
4930 -int Novfs_Set_Attr(unsigned char * Path, struct iattr *Attr, session_t SessionId)
4931 +int novfs_set_attr(unsigned char * Path, struct iattr *Attr,
4932 + struct novfs_schandle SessionId)
4933 {
4934 - PSET_FILE_INFO_REQUEST cmd;
4935 - PSET_FILE_INFO_REPLY reply;
4936 + struct novfs_set_file_info_request *cmd;
4937 + struct novfs_set_file_info_reply *reply;
4938 unsigned long replylen = 0;
4939 int retCode, cmdlen, pathlen;
4940
4941 @@ -1775,8 +1798,8 @@ int Novfs_Set_Attr(unsigned char * Path,
4942 pathlen--;
4943 }
4944
4945 - cmdlen = offsetof(SET_FILE_INFO_REQUEST, path) + pathlen;
4946 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
4947 + cmdlen = offsetof(struct novfs_set_file_info_request,path) + pathlen;
4948 + cmd = kmalloc(cmdlen, GFP_KERNEL);
4949 if (cmd) {
4950 cmd->Command.CommandType = VFS_COMMAND_SET_FILE_INFO;
4951 cmd->Command.SequenceNumber = 0;
4952 @@ -1827,16 +1850,17 @@ int Novfs_Set_Attr(unsigned char * Path,
4953 return (retCode);
4954 }
4955
4956 -int Novfs_Get_File_Cache_Flag(unsigned char * Path, session_t SessionId)
4957 +int novfs_get_file_cache_flag(unsigned char * Path,
4958 + struct novfs_schandle SessionId)
4959 {
4960 - PGET_CACHE_FLAG_REQUEST cmd;
4961 - PGET_CACHE_FLAG_REPLY reply = NULL;
4962 + struct novfs_get_cache_flag *cmd;
4963 + struct novfs_get_cache_flag_reply *reply = NULL;
4964 unsigned long replylen = 0;
4965 int cmdlen;
4966 int retCode = 0;
4967 int pathlen;
4968
4969 - DbgPrint("Novfs_Get_File_Cache_Flag: Path = %s\n", Path);
4970 + DbgPrint("novfs_Get_File_Cache_Flag: Path = %s\n", Path);
4971
4972 if (Path && *Path) {
4973 pathlen = strlen(Path);
4974 @@ -1844,8 +1868,10 @@ int Novfs_Get_File_Cache_Flag(unsigned c
4975 if ('.' == Path[pathlen - 1])
4976 pathlen--;
4977 }
4978 - cmdlen = offsetof(GET_CACHE_FLAG_REQUEST, path) + pathlen;
4979 - cmd = (PGET_CACHE_FLAG_REQUEST) Novfs_Malloc(cmdlen, GFP_KERNEL);
4980 + cmdlen = offsetof(struct novfs_get_cache_flag, path) +
4981 + pathlen;
4982 + cmd = (struct novfs_get_cache_flag *)
4983 + kmalloc(cmdlen, GFP_KERNEL);
4984 if (cmd) {
4985 cmd->Command.CommandType = VFS_COMMAND_GET_CACHE_FLAG;
4986 cmd->Command.SequenceNumber = 0;
4987 @@ -1869,7 +1895,7 @@ int Novfs_Get_File_Cache_Flag(unsigned c
4988 }
4989 }
4990
4991 - DbgPrint("Novfs_Get_File_Cache_Flag: return %d\n", retCode);
4992 + DbgPrint("novfs_Get_File_Cache_Flag: return %d\n", retCode);
4993 return (retCode);
4994 }
4995
4996 @@ -1878,33 +1904,26 @@ int Novfs_Get_File_Cache_Flag(unsigned c
4997 * SessionId, file handle, type of lock (read/write or unlock),
4998 * start of lock area, length of lock area
4999 *
5000 - * Returns:
5001 - * 0 on success
5002 - * negative value on error
5003 - *
5004 - * Abstract:
5005 - *
5006 * Notes: lock type - fcntl
5007 */
5008 -int Novfs_Set_File_Lock(session_t SessionId, HANDLE Handle,
5009 +int novfs_set_file_lock(struct novfs_schandle SessionId, void *Handle,
5010 unsigned char fl_type, loff_t fl_start, loff_t fl_len)
5011 {
5012 - PSET_FILE_LOCK_REQUEST cmd;
5013 - PSET_FILE_LOCK_REPLY reply = NULL;
5014 + struct novfs_set_file_lock_request *cmd;
5015 + struct novfs_set_file_lock_reply *reply = NULL;
5016 unsigned long replylen = 0;
5017 int retCode;
5018
5019 retCode = -1;
5020
5021 - DbgPrint("Novfs_Set_File_Lock:\n"
5022 + DbgPrint("novfs_Set_File_Lock:\n"
5023 " SessionId: 0x%llx\n", SessionId);
5024
5025 cmd =
5026 - (PSET_FILE_LOCK_REQUEST) Novfs_Malloc(sizeof(SET_FILE_LOCK_REQUEST),
5027 - GFP_KERNEL);
5028 + (struct novfs_set_file_lock_request *) kmalloc(sizeof(struct novfs_set_file_lock_request), GFP_KERNEL);
5029
5030 if (cmd) {
5031 - DbgPrint("Novfs_Set_File_Lock 2\n");
5032 + DbgPrint("novfs_Set_File_Lock 2\n");
5033
5034 cmd->Command.CommandType = VFS_COMMAND_SET_FILE_LOCK;
5035 cmd->Command.SequenceNumber = 0;
5036 @@ -1921,32 +1940,32 @@ int Novfs_Set_File_Lock(session_t Sessio
5037 cmd->fl_start = fl_start;
5038 cmd->fl_len = fl_len;
5039
5040 - DbgPrint("Novfs_Set_File_Lock 3\n");
5041 + DbgPrint("novfs_Set_File_Lock 3\n");
5042
5043 - DbgPrint("Novfs_Set_File_Lock: BEGIN dump arguments\n");
5044 - DbgPrint("Novfs_Set_File_Lock: Queue_Daemon_Command %d\n",
5045 + DbgPrint("novfs_Set_File_Lock: BEGIN dump arguments\n");
5046 + DbgPrint("novfs_Set_File_Lock: Queue_Daemon_Command %d\n",
5047 cmd->Command.CommandType);
5048 - DbgPrint("Novfs_Set_File_Lock: cmd->handle = 0x%p\n",
5049 + DbgPrint("novfs_Set_File_Lock: cmd->handle = 0x%p\n",
5050 cmd->handle);
5051 - DbgPrint("Novfs_Set_File_Lock: cmd->fl_type = %u\n",
5052 + DbgPrint("novfs_Set_File_Lock: cmd->fl_type = %u\n",
5053 cmd->fl_type);
5054 - DbgPrint("Novfs_Set_File_Lock: cmd->fl_start = 0x%X\n",
5055 + DbgPrint("novfs_Set_File_Lock: cmd->fl_start = 0x%X\n",
5056 cmd->fl_start);
5057 - DbgPrint("Novfs_Set_File_Lock: cmd->fl_len = 0x%X\n",
5058 + DbgPrint("novfs_Set_File_Lock: cmd->fl_len = 0x%X\n",
5059 cmd->fl_len);
5060 DbgPrint
5061 - ("Novfs_Set_File_Lock: sizeof(SET_FILE_LOCK_REQUEST) = %u\n",
5062 - sizeof(SET_FILE_LOCK_REQUEST));
5063 - DbgPrint("Novfs_Set_File_Lock: END dump arguments\n");
5064 + ("novfs_Set_File_Lock: sizeof(SET_FILE_LOCK_REQUEST) = %u\n",
5065 + sizeof(struct novfs_set_file_lock_request));
5066 + DbgPrint("novfs_Set_File_Lock: END dump arguments\n");
5067
5068 retCode =
5069 - Queue_Daemon_Command(cmd, sizeof(SET_FILE_LOCK_REQUEST),
5070 + Queue_Daemon_Command(cmd, sizeof(struct novfs_set_file_lock_request),
5071 NULL, 0, (void *)&reply, &replylen,
5072 INTERRUPTIBLE);
5073 - DbgPrint("Novfs_Set_File_Lock 4\n");
5074 + DbgPrint("novfs_Set_File_Lock 4\n");
5075
5076 if (reply) {
5077 - DbgPrint("Novfs_Set_File_Lock 5, ErrorCode = %X\n",
5078 + DbgPrint("novfs_Set_File_Lock 5, ErrorCode = %X\n",
5079 reply->Reply.ErrorCode);
5080
5081 if (reply->Reply.ErrorCode) {
5082 @@ -1954,11 +1973,10 @@ int Novfs_Set_File_Lock(session_t Sessio
5083 }
5084 kfree(reply);
5085 }
5086 -
5087 kfree(cmd);
5088 }
5089
5090 - DbgPrint("Novfs_Set_File_Lock 6\n");
5091 + DbgPrint("novfs_Set_File_Lock 6\n");
5092
5093 return (retCode);
5094 }
5095 --- a/fs/novfs/inode.c
5096 +++ b/fs/novfs/inode.c
5097 @@ -37,14 +37,6 @@
5098 /*===[ Include files specific to this module ]============================*/
5099 #include "vfs.h"
5100
5101 -#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
5102 -#define FSPRIVATE u.generic_ip
5103 -#else
5104 -#define FSPRIVATE i_private
5105 -#endif
5106 -
5107 -
5108 -#define FILE_UPDATE_TIMEOUT 2
5109
5110 struct inode_data {
5111 void *Scope;
5112 @@ -54,285 +46,260 @@ struct inode_data {
5113 unsigned long cntDC;
5114 struct list_head DirCache;
5115 struct semaphore DirCacheLock;
5116 - HANDLE FileHandle;
5117 + void * FileHandle;
5118 int CacheFlag;
5119 char Name[1]; /* Needs to be last entry */
5120 };
5121
5122 -// FIXME these are wrong, but fake the compiler out for now until the proper people can be flogged...
5123 -extern void *Scope_Get_ScopefromName(struct qstr *Name);
5124 -extern void *Scope_Get_ScopefromPath(struct dentry *Dentry);
5125 -
5126 -/*===[ Function prototypes ]==============================================*/
5127 -int Novfs_Remove_from_Root(char *RemoveName);
5128 -int Novfs_Add_to_Root(char *);
5129 -char *Novfs_dget_path(struct dentry *d, char *path, unsigned int pathlen);
5130 -int verify_dentry(struct dentry *dentry, int Flags);
5131 -int invalidate_dentry(struct dentry *parent);
5132 -struct dentry *Novfs_d_lookup(struct dentry *Parent, struct qstr *Name);
5133 -int Novfs_d_add(struct dentry *p, struct dentry *d, struct inode *i, int add);
5134 -int Novfs_d_strcmp(struct qstr *s1, struct qstr *s2);
5135 -unsigned long Novfs_internal_hash(struct qstr *name);
5136 +#define FILE_UPDATE_TIMEOUT 2
5137 +
5138 +/*===[ Function prototypes ]=============================================*/
5139 +
5140 +static unsigned long novfs_internal_hash(struct qstr *name);
5141 +static int novfs_d_add(struct dentry *p, struct dentry *d, struct inode *i, int add);
5142
5143 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
5144 -int Novfs_get_sb(struct file_system_type *Fstype, int Flags,
5145 +static int novfs_get_sb(struct file_system_type *Fstype, int Flags,
5146 const char *Dev_name, void *Data, struct vfsmount *Mnt);
5147 -#else
5148 -struct super_block *Novfs_get_sb(struct file_system_type *Fstype, int Flags,
5149 - const char *Dev_name, void *Data);
5150 -#endif
5151
5152 -int Novfs_fill_super(struct super_block *SB, void *Data, int Silent);
5153 +static void novfs_kill_sb(struct super_block *SB);
5154 +
5155
5156 /*
5157 * Declared dentry_operations
5158 */
5159 -int Novfs_d_revalidate(struct dentry *, struct nameidata *);
5160 -int Novfs_d_hash(struct dentry *, struct qstr *);
5161 -int Novfs_d_compare(struct dentry *, struct qstr *, struct qstr *);
5162 -int Novfs_d_delete(struct dentry *dentry);
5163 -void Novfs_d_release(struct dentry *dentry);
5164 -void Novfs_d_iput(struct dentry *dentry, struct inode *inode);
5165 +int novfs_d_revalidate(struct dentry *, struct nameidata *);
5166 +int novfs_d_hash(struct dentry *, struct qstr *);
5167 +int novfs_d_compare(struct dentry *, struct qstr *, struct qstr *);
5168 +int novfs_d_delete(struct dentry *dentry);
5169 +void novfs_d_release(struct dentry *dentry);
5170 +void novfs_d_iput(struct dentry *dentry, struct inode *inode);
5171
5172 /*
5173 * Declared directory operations
5174 */
5175 -int Novfs_dir_open(struct inode *inode, struct file *file);
5176 -int Novfs_dir_release(struct inode *inode, struct file *file);
5177 -loff_t Novfs_dir_lseek(struct file *file, loff_t offset, int origin);
5178 -ssize_t Novfs_dir_read(struct file *file, char *buf, size_t len, loff_t * off);
5179 +int novfs_dir_open(struct inode *inode, struct file *file);
5180 +int novfs_dir_release(struct inode *inode, struct file *file);
5181 +loff_t novfs_dir_lseek(struct file *file, loff_t offset, int origin);
5182 +ssize_t novfs_dir_read(struct file *file, char *buf, size_t len, loff_t * off);
5183 void addtodentry(struct dentry *Parent, unsigned char *List, int Level);
5184 -int Novfs_filldir(void *data, const char *name, int namelen, loff_t off,
5185 +int novfs_filldir(void *data, const char *name, int namelen, loff_t off,
5186 ino_t ino, unsigned ftype);
5187 -int Novfs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir);
5188 -int Novfs_dir_fsync(struct file *file, struct dentry *dentry, int datasync);
5189 +int novfs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir);
5190 +int novfs_dir_fsync(struct file *file, struct dentry *dentry, int datasync);
5191
5192 /*
5193 * Declared address space operations
5194 */
5195 -int Novfs_a_writepage(struct page *page, struct writeback_control *wbc);
5196 -int Novfs_a_writepages(struct address_space *mapping,
5197 +int novfs_a_writepage(struct page *page, struct writeback_control *wbc);
5198 +int novfs_a_writepages(struct address_space *mapping,
5199 struct writeback_control *wbc);
5200 -int Novfs_a_prepare_write(struct file *file, struct page *page, unsigned from,
5201 +int novfs_a_prepare_write(struct file *file, struct page *page, unsigned from,
5202 unsigned to);
5203 -int Novfs_a_commit_write(struct file *file, struct page *page, unsigned offset,
5204 +int novfs_a_commit_write(struct file *file, struct page *page, unsigned offset,
5205 unsigned to);
5206 -int Novfs_a_readpage(struct file *file, struct page *page);
5207 -int Novfs_a_readpages(struct file *file, struct address_space *mapping,
5208 +int novfs_a_readpage(struct file *file, struct page *page);
5209 +int novfs_a_readpages(struct file *file, struct address_space *mapping,
5210 struct list_head *page_lst, unsigned nr_pages);
5211 -ssize_t Novfs_a_direct_IO(int rw, struct kiocb *kiocb, const struct iovec *iov,
5212 +ssize_t novfs_a_direct_IO(int rw, struct kiocb *kiocb, const struct iovec *iov,
5213 loff_t offset, unsigned long nr_segs);
5214
5215 /*
5216 * Declared file_operations
5217 */
5218 -ssize_t Novfs_f_read(struct file *, char *, size_t, loff_t *);
5219 -ssize_t Novfs_f_write(struct file *, const char *, size_t, loff_t *);
5220 -int Novfs_f_readdir(struct file *, void *, filldir_t);
5221 -int Novfs_f_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
5222 -int Novfs_f_mmap(struct file *file, struct vm_area_struct *vma);
5223 -int Novfs_f_open(struct inode *, struct file *);
5224 -#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
5225 -int Novfs_f_flush(struct file *);
5226 -#else
5227 -int Novfs_f_flush(struct file *, fl_owner_t);
5228 -#endif
5229 -int Novfs_f_release(struct inode *, struct file *);
5230 -int Novfs_f_fsync(struct file *, struct dentry *, int datasync);
5231 -int Novfs_f_lock(struct file *, int, struct file_lock *);
5232 +ssize_t novfs_f_read(struct file *, char *, size_t, loff_t *);
5233 +ssize_t novfs_f_write(struct file *, const char *, size_t, loff_t *);
5234 +int novfs_f_readdir(struct file *, void *, filldir_t);
5235 +int novfs_f_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
5236 +int novfs_f_mmap(struct file *file, struct vm_area_struct *vma);
5237 +int novfs_f_open(struct inode *, struct file *);
5238 +int novfs_f_flush(struct file *, fl_owner_t);
5239 +int novfs_f_release(struct inode *, struct file *);
5240 +int novfs_f_fsync(struct file *, struct dentry *, int datasync);
5241 +int novfs_f_lock(struct file *, int, struct file_lock *);
5242
5243 /*
5244 * Declared inode_operations
5245 */
5246 -int Novfs_i_create(struct inode *, struct dentry *, int, struct nameidata *);
5247 -struct dentry *Novfs_i_lookup(struct inode *, struct dentry *,
5248 +int novfs_i_create(struct inode *, struct dentry *, int, struct nameidata *);
5249 +struct dentry *novfs_i_lookup(struct inode *, struct dentry *,
5250 struct nameidata *);
5251 -int Novfs_i_mkdir(struct inode *, struct dentry *, int);
5252 -int Novfs_i_unlink(struct inode *dir, struct dentry *dentry);
5253 -int Novfs_i_rmdir(struct inode *, struct dentry *);
5254 -int Novfs_i_mknod(struct inode *, struct dentry *, int, dev_t);
5255 -int Novfs_i_rename(struct inode *, struct dentry *, struct inode *,
5256 +int novfs_i_mkdir(struct inode *, struct dentry *, int);
5257 +int novfs_i_unlink(struct inode *dir, struct dentry *dentry);
5258 +int novfs_i_rmdir(struct inode *, struct dentry *);
5259 +int novfs_i_mknod(struct inode *, struct dentry *, int, dev_t);
5260 +int novfs_i_rename(struct inode *, struct dentry *, struct inode *,
5261 struct dentry *);
5262 -int Novfs_i_permission(struct inode *inode, int mask);
5263 -int Novfs_i_setattr(struct dentry *, struct iattr *);
5264 -int Novfs_i_getattr(struct vfsmount *mnt, struct dentry *, struct kstat *);
5265 -int Novfs_i_revalidate(struct dentry *dentry);
5266 +int novfs_i_setattr(struct dentry *, struct iattr *);
5267 +int novfs_i_getattr(struct vfsmount *mnt, struct dentry *, struct kstat *);
5268 +int novfs_i_revalidate(struct dentry *dentry);
5269
5270 /*
5271 * Extended attributes operations
5272 */
5273
5274 -int Novfs_i_getxattr(struct dentry *dentry, const char *name, void *buffer,
5275 +int novfs_i_getxattr(struct dentry *dentry, const char *name, void *buffer,
5276 size_t size);
5277 -int Novfs_i_setxattr(struct dentry *dentry, const char *name, const void *value,
5278 +int novfs_i_setxattr(struct dentry *dentry, const char *name, const void *value,
5279 size_t value_size, int flags);
5280 -int Novfs_i_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
5281 +int novfs_i_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
5282
5283 -void update_inode(struct inode *Inode, struct entry_info *Info);
5284 +void update_inode(struct inode *Inode, struct novfs_entry_info *Info);
5285
5286 /*
5287 * Declared super_operations
5288 */
5289 -void Novfs_read_inode(struct inode *inode);
5290 -void Novfs_write_inode(struct inode *inode);
5291 -int Novfs_notify_change(struct dentry *dentry, struct iattr *attr);
5292 -void Novfs_clear_inode(struct inode *inode);
5293 -int Novfs_show_options(struct seq_file *s, struct vfsmount *m);
5294 -
5295 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
5296 -int Novfs_statfs(struct dentry *de, struct kstatfs *buf);
5297 -#else
5298 -int Novfs_statfs(struct super_block *sb, struct kstatfs *buf);
5299 -#endif
5300 +void novfs_read_inode(struct inode *inode);
5301 +void novfs_write_inode(struct inode *inode);
5302 +int novfs_notify_change(struct dentry *dentry, struct iattr *attr);
5303 +void novfs_clear_inode(struct inode *inode);
5304 +int novfs_show_options(struct seq_file *s, struct vfsmount *m);
5305 +
5306 +int novfs_statfs(struct dentry *de, struct kstatfs *buf);
5307
5308 /*
5309 * Declared control interface functions
5310 */
5311 ssize_t
5312 -Novfs_Control_read(struct file *file, char *buf, size_t nbytes, loff_t * ppos);
5313 +novfs_control_Read(struct file *file, char *buf, size_t nbytes, loff_t * ppos);
5314
5315 ssize_t
5316 -Novfs_Control_write(struct file *file, const char *buf, size_t nbytes,
5317 +novfs_control_write(struct file *file, const char *buf, size_t nbytes,
5318 loff_t * ppos);
5319
5320 -int Novfs_Control_ioctl(struct inode *inode, struct file *file,
5321 +int novfs_control_ioctl(struct inode *inode, struct file *file,
5322 unsigned int cmd, unsigned long arg);
5323
5324 int __init init_novfs(void);
5325 void __exit exit_novfs(void);
5326
5327 -int Novfs_lock_inode_cache(struct inode *i);
5328 -void Novfs_unlock_inode_cache(struct inode *i);
5329 -int Novfs_enumerate_inode_cache(struct inode *i, struct list_head **iteration,
5330 - ino_t * ino, struct entry_info *info);
5331 -int Novfs_get_entry(struct inode *i, struct qstr *name, ino_t * ino,
5332 - struct entry_info *info);
5333 -int Novfs_get_entry_by_pos(struct inode *i, loff_t pos, ino_t * ino,
5334 - struct entry_info *info);
5335 -int Novfs_get_entry_time(struct inode *i, struct qstr *name, ino_t * ino,
5336 - struct entry_info *info, u64 * EntryTime);
5337 -int Novfs_get_remove_entry(struct inode *i, ino_t * ino, struct entry_info *info);
5338 -void Novfs_invalidate_inode_cache(struct inode *i);
5339 -static struct dir_cache *Novfs_lookup_inode_cache(struct inode *i, struct qstr *name, ino_t ino);
5340 -int Novfs_lookup_validate(struct inode *i, struct qstr *name, ino_t ino);
5341 -int Novfs_add_inode_entry(struct inode *i, struct qstr *name, ino_t ino,
5342 - struct entry_info *info);
5343 -int Novfs_update_entry(struct inode *i, struct qstr *name, ino_t ino,
5344 - struct entry_info *info);
5345 -void Novfs_remove_inode_entry(struct inode *i, struct qstr *name, ino_t ino);
5346 -void Novfs_free_invalid_entries(struct inode *i);
5347 -void Novfs_free_inode_cache(struct inode *i);
5348 +int novfs_lock_inode_cache(struct inode *i);
5349 +void novfs_unlock_inode_cache(struct inode *i);
5350 +int novfs_enumerate_inode_cache(struct inode *i, struct list_head **iteration,
5351 + ino_t * ino, struct novfs_entry_info *info);
5352 +int novfs_get_entry(struct inode *i, struct qstr *name, ino_t * ino,
5353 + struct novfs_entry_info *info);
5354 +int novfs_get_entry_by_pos(struct inode *i, loff_t pos, ino_t * ino,
5355 + struct novfs_entry_info *info);
5356 +int novfs_get_entry_time(struct inode *i, struct qstr *name, ino_t * ino,
5357 + struct novfs_entry_info *info, u64 * EntryTime);
5358 +int novfs_get_remove_entry(struct inode *i, ino_t * ino, struct novfs_entry_info *info);
5359 +void novfs_invalidate_inode_cache(struct inode *i);
5360 +struct novfs_dir_cache *novfs_lookup_inode_cache(struct inode *i, struct qstr *name,
5361 + ino_t ino);
5362 +int novfs_lookup_validate(struct inode *i, struct qstr *name, ino_t ino);
5363 +int novfs_add_inode_entry(struct inode *i, struct qstr *name, ino_t ino,
5364 + struct novfs_entry_info *info);
5365 +int novfs_update_entry(struct inode *i, struct qstr *name, ino_t ino,
5366 + struct novfs_entry_info *info);
5367 +void novfs_remove_inode_entry(struct inode *i, struct qstr *name, ino_t ino);
5368 +void novfs_free_invalid_entries(struct inode *i);
5369 +void novfs_free_inode_cache(struct inode *i);
5370
5371 /*===[ Global variables ]=================================================*/
5372 -struct dentry_operations Novfs_dentry_operations = {
5373 - .d_revalidate = Novfs_d_revalidate,
5374 - .d_hash = Novfs_d_hash,
5375 - .d_compare = Novfs_d_compare,
5376 - //.d_delete = Novfs_d_delete,
5377 - .d_release = Novfs_d_release,
5378 - .d_iput = Novfs_d_iput,
5379 +struct dentry_operations novfs_dentry_operations = {
5380 + .d_revalidate = novfs_d_revalidate,
5381 + .d_hash = novfs_d_hash,
5382 + .d_compare = novfs_d_compare,
5383 + //.d_delete = novfs_d_delete,
5384 + .d_release = novfs_d_release,
5385 + .d_iput = novfs_d_iput,
5386 };
5387
5388 -struct file_operations Novfs_dir_operations = {
5389 +struct file_operations novfs_dir_operations = {
5390 .owner = THIS_MODULE,
5391 - .open = Novfs_dir_open,
5392 - .release = Novfs_dir_release,
5393 - .llseek = Novfs_dir_lseek,
5394 - .read = Novfs_dir_read,
5395 - .readdir = Novfs_dir_readdir,
5396 - .fsync = Novfs_dir_fsync,
5397 + .open = novfs_dir_open,
5398 + .release = novfs_dir_release,
5399 + .llseek = novfs_dir_lseek,
5400 + .read = novfs_dir_read,
5401 + .readdir = novfs_dir_readdir,
5402 + .fsync = novfs_dir_fsync,
5403 };
5404
5405 -static struct file_operations Novfs_file_operations = {
5406 +static struct file_operations novfs_file_operations = {
5407 .owner = THIS_MODULE,
5408 - .read = Novfs_f_read,
5409 - .write = Novfs_f_write,
5410 - .readdir = Novfs_f_readdir,
5411 - .ioctl = Novfs_f_ioctl,
5412 - .mmap = Novfs_f_mmap,
5413 - .open = Novfs_f_open,
5414 - .flush = Novfs_f_flush,
5415 - .release = Novfs_f_release,
5416 - .fsync = Novfs_f_fsync,
5417 + .read = novfs_f_read,
5418 + .write = novfs_f_write,
5419 + .readdir = novfs_f_readdir,
5420 + .ioctl = novfs_f_ioctl,
5421 + .mmap = novfs_f_mmap,
5422 + .open = novfs_f_open,
5423 + .flush = novfs_f_flush,
5424 + .release = novfs_f_release,
5425 + .fsync = novfs_f_fsync,
5426 .llseek = generic_file_llseek,
5427 - .lock = Novfs_f_lock,
5428 + .lock = novfs_f_lock,
5429 };
5430
5431 -static struct address_space_operations Novfs_nocache_aops = {
5432 - .readpage = Novfs_a_readpage,
5433 +static struct address_space_operations novfs_nocache_aops = {
5434 + .readpage = novfs_a_readpage,
5435 };
5436
5437 -struct backing_dev_info Novfs_backing_dev_info = {
5438 +struct backing_dev_info novfs_backing_dev_info = {
5439 .ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE,
5440 .state = 0,
5441 .capabilities = BDI_CAP_NO_WRITEBACK | BDI_CAP_MAP_COPY,
5442 .unplug_io_fn = default_unplug_io_fn,
5443 };
5444
5445 -static struct address_space_operations Novfs_aops = {
5446 - .readpage = Novfs_a_readpage,
5447 - .readpages = Novfs_a_readpages,
5448 - .writepage = Novfs_a_writepage,
5449 - .writepages = Novfs_a_writepages,
5450 - .prepare_write = Novfs_a_prepare_write,
5451 - .commit_write = Novfs_a_commit_write,
5452 +static struct address_space_operations novfs_aops = {
5453 + .readpage = novfs_a_readpage,
5454 + .readpages = novfs_a_readpages,
5455 + .writepage = novfs_a_writepage,
5456 + .writepages = novfs_a_writepages,
5457 + .prepare_write = novfs_a_prepare_write,
5458 + .commit_write = novfs_a_commit_write,
5459 .set_page_dirty = __set_page_dirty_nobuffers,
5460 - .direct_IO = Novfs_a_direct_IO,
5461 + .direct_IO = novfs_a_direct_IO,
5462 };
5463
5464 -static struct inode_operations Novfs_inode_operations = {
5465 - .create = Novfs_i_create,
5466 - .lookup = Novfs_i_lookup,
5467 - .unlink = Novfs_i_unlink,
5468 - .mkdir = Novfs_i_mkdir,
5469 - .rmdir = Novfs_i_rmdir,
5470 - .mknod = Novfs_i_mknod,
5471 - .rename = Novfs_i_rename,
5472 - .setattr = Novfs_i_setattr,
5473 - .getattr = Novfs_i_getattr,
5474 -/*
5475 - .getxattr = Novfs_i_getxattr,
5476 - .setxattr = Novfs_i_setxattr,
5477 - .listxattr = Novfs_i_listxattr,
5478 +static struct inode_operations novfs_inode_operations = {
5479 + .create = novfs_i_create,
5480 + .lookup = novfs_i_lookup,
5481 + .unlink = novfs_i_unlink,
5482 + .mkdir = novfs_i_mkdir,
5483 + .rmdir = novfs_i_rmdir,
5484 + .mknod = novfs_i_mknod,
5485 + .rename = novfs_i_rename,
5486 + .setattr = novfs_i_setattr,
5487 + .getattr = novfs_i_getattr,
5488 +/*
5489 + .getxattr = novfs_i_getxattr,
5490 + .setxattr = novfs_i_setxattr,
5491 + .listxattr = novfs_i_listxattr,
5492 */
5493 };
5494
5495 -static struct inode_operations Novfs_file_inode_operations = {
5496 - .setattr = Novfs_i_setattr,
5497 - .getattr = Novfs_i_getattr,
5498 -/*
5499 - .getxattr = Novfs_i_getxattr,
5500 - .setxattr = Novfs_i_setxattr,
5501 - .listxattr = Novfs_i_listxattr,
5502 +static struct inode_operations novfs_file_inode_operations = {
5503 + .setattr = novfs_i_setattr,
5504 + .getattr = novfs_i_getattr,
5505 +/*
5506 + .getxattr = novfs_i_getxattr,
5507 + .setxattr = novfs_i_setxattr,
5508 + .listxattr = novfs_i_listxattr,
5509 */
5510 };
5511
5512 -static struct super_operations Novfs_ops = {
5513 - .statfs = Novfs_statfs,
5514 - .clear_inode = Novfs_clear_inode,
5515 +static struct super_operations novfs_ops = {
5516 + .statfs = novfs_statfs,
5517 + .clear_inode = novfs_clear_inode,
5518 .drop_inode = generic_delete_inode,
5519 - .show_options = Novfs_show_options,
5520 + .show_options = novfs_show_options,
5521
5522 };
5523
5524 /* Not currently used
5525 -static struct file_operations Novfs_Control_operations = {
5526 - .read = Novfs_Control_read,
5527 - .write = Novfs_Control_write,
5528 - .ioctl = Novfs_Control_ioctl,
5529 +static struct file_operations novfs_Control_operations = {
5530 + .read = novfs_Control_read,
5531 + .write = novfs_Control_write,
5532 + .ioctl = novfs_Control_ioctl,
5533 };
5534 */
5535
5536 -static atomic_t Novfs_Inode_Number = ATOMIC_INIT(0);
5537 -
5538 -struct dentry *Novfs_root = NULL;
5539 +static atomic_t novfs_Inode_Number = ATOMIC_INIT(0);
5540
5541 -int Novfs_Version_Major = NOVFS_VFS_MAJOR;
5542 -int Novfs_Version_Minor = NOVFS_VFS_MINOR;
5543 -int Novfs_Version_Sub = NOVFS_VFS_SUB;
5544 -int Novfs_Version_Release = NOVFS_VFS_RELEASE;
5545
5546 -char *Novfs_CurrentMount = NULL;
5547 +struct dentry *novfs_root = NULL;
5548 +char *novfs_current_mnt = NULL;
5549
5550 DECLARE_MUTEX(InodeList_lock);
5551
5552 @@ -346,18 +313,13 @@ uint64_t inHAXTime;
5553 int inHAX;
5554
5555 unsigned long InodeCount = 0, DCCount = 0;
5556 -unsigned long File_update_timeout = FILE_UPDATE_TIMEOUT;
5557 -int PageCache = 0;
5558 +unsigned long novfs_update_timeout = FILE_UPDATE_TIMEOUT;
5559 +int novfs_page_cache = 0;
5560
5561 -typedef struct _Novfs_List2 {
5562 - struct list_head list;
5563 - void *data;
5564 -} Novfs_List2;
5565 -
5566 -typedef struct _File_Private2 {
5567 +struct file_private {
5568 int listedall;
5569 - HANDLE enumHandle;
5570 -} FilePrivate2;
5571 + void *enumHandle;
5572 +};
5573
5574 static void PRINT_DENTRY(const char *s, struct dentry *d)
5575 {
5576 @@ -370,8 +332,8 @@ static void PRINT_DENTRY(const char *s,
5577 " prev: 0x%p\n", &d->d_lru, d->d_lru.next,
5578 d->d_lru.prev);
5579 DbgPrint(" d_child: 0x%p\n" " next: 0x%p\n"
5580 - " prev: 0x%p\n", &d->D_CHILD, d->D_CHILD.next,
5581 - d->D_CHILD.prev);
5582 + " prev: 0x%p\n", &d->d_u.d_child,
5583 + d->d_u.d_child.next, d->d_u.d_child.prev);
5584 DbgPrint(" d_subdirs: 0x%p\n" " next: 0x%p\n"
5585 " prev: 0x%p\n", &d->d_subdirs, d->d_subdirs.next,
5586 d->d_subdirs.prev);
5587 @@ -397,144 +359,109 @@ static void PRINT_DENTRY(const char *s,
5588 }
5589
5590 /*++======================================================================*/
5591 -int Novfs_Remove_from_Root(char *RemoveName)
5592 -/*
5593 - * Arguments:
5594 - *
5595 - * Returns:
5596 - *
5597 - * Abstract:
5598 - *
5599 - * Notes:
5600 - *
5601 - * Environment:
5602 - *
5603 - *========================================================================*/
5604 +int novfs_remove_from_root(char *RemoveName)
5605 {
5606 struct qstr name;
5607 struct dentry *dentry;
5608 struct inode *dir;
5609
5610 - DbgPrint("Novfs_Remove_from_Root: %s\n", RemoveName);
5611 + DbgPrint("novfs_Remove_from_Root: %s\n", RemoveName);
5612 name.len = strlen(RemoveName);
5613 name.name = RemoveName;
5614 - Novfs_d_hash(Novfs_root, &name);
5615 + novfs_d_hash(novfs_root, &name);
5616
5617 - dentry = d_lookup(Novfs_root, &name);
5618 + dentry = d_lookup(novfs_root, &name);
5619 if (dentry) {
5620 - if (dentry->d_inode && dentry->d_inode->FSPRIVATE) {
5621 - ((struct inode_data *)(dentry->d_inode->FSPRIVATE))->Scope =
5622 - NULL;
5623 + if (dentry->d_inode && dentry->d_inode->i_private) {
5624 + struct inode_data *n_inode =
5625 + dentry->d_inode->i_private;
5626 + n_inode->Scope = NULL;
5627 }
5628 dput(dentry);
5629 }
5630
5631 - dir = Novfs_root->d_inode;
5632 + dir = novfs_root->d_inode;
5633
5634 - Novfs_lock_inode_cache(dir);
5635 - Novfs_remove_inode_entry(dir, &name, 0);
5636 - Novfs_unlock_inode_cache(dir);
5637 + novfs_lock_inode_cache(dir);
5638 + novfs_remove_inode_entry(dir, &name, 0);
5639 + novfs_unlock_inode_cache(dir);
5640
5641 return (0);
5642 }
5643
5644 /*++======================================================================*/
5645 -int Novfs_Add_to_Root(char *AddName)
5646 -/*
5647 - * Arguments:
5648 - *
5649 - * Returns:
5650 - *
5651 - * Abstract:
5652 - *
5653 - * Notes:
5654 - *
5655 - * Environment:
5656 - *
5657 - *========================================================================*/
5658 +int novfs_add_to_root(char *AddName)
5659 {
5660 struct qstr name;
5661 struct inode *dir;
5662 - struct entry_info info;
5663 + struct novfs_entry_info info;
5664 ino_t ino;
5665
5666 - DbgPrint("Novfs_Add_to_Root: %s\n", AddName);
5667 + DbgPrint("novfs_Add_to_Root: %s\n", AddName);
5668 name.len = strlen(AddName);
5669 name.name = AddName;
5670 - Novfs_d_hash(Novfs_root, &name);
5671 + novfs_d_hash(novfs_root, &name);
5672
5673 - dir = Novfs_root->d_inode;
5674 + dir = novfs_root->d_inode;
5675
5676 - Novfs_lock_inode_cache(dir);
5677 + novfs_lock_inode_cache(dir);
5678
5679 ino = 0;
5680
5681 - if (!Novfs_lookup_inode_cache(dir, &name, 0)) {
5682 + if (!novfs_lookup_inode_cache(dir, &name, 0)) {
5683 info.mode = S_IFDIR | 0700;
5684 info.size = 0;
5685 info.atime = info.ctime = info.mtime = CURRENT_TIME;
5686
5687 - ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
5688 - Novfs_add_inode_entry(dir, &name, ino, &info);
5689 + ino = (ino_t)atomic_inc_return(&novfs_Inode_Number);
5690 + novfs_add_inode_entry(dir, &name, ino, &info);
5691 }
5692
5693 - Novfs_unlock_inode_cache(dir);
5694 + novfs_unlock_inode_cache(dir);
5695
5696 return (0);
5697 }
5698
5699 /*++======================================================================*/
5700 -int Novfs_Add_to_Root2(char *AddName)
5701 -/*
5702 - * Arguments:
5703 - *
5704 - * Returns:
5705 - *
5706 - * Abstract:
5707 - *
5708 - * Notes:
5709 - *
5710 - * Environment:
5711 - *
5712 - *========================================================================*/
5713 +int novfs_Add_to_Root2(char *AddName)
5714 {
5715 struct dentry *entry;
5716 struct qstr name;
5717 struct inode *inode;
5718 void *scope;
5719
5720 - DbgPrint("Novfs_Add_to_Root: %s\n", AddName);
5721 + DbgPrint("novfs_Add_to_Root: %s\n", AddName);
5722 name.len = strlen(AddName);
5723 name.name = AddName;
5724
5725 - Novfs_d_hash(Novfs_root, &name);
5726 + novfs_d_hash(novfs_root, &name);
5727
5728 - entry = Novfs_d_lookup(Novfs_root, &name);
5729 - DbgPrint("Novfs_Add_to_Root: Novfs_d_lookup 0x%p\n", entry);
5730 + entry = d_lookup(novfs_root, &name);
5731 + DbgPrint("novfs_Add_to_Root: novfs_d_lookup 0x%p\n", entry);
5732 if (NULL == entry) {
5733 - scope = Scope_Lookup();
5734 + scope = novfs_scope_lookup();
5735
5736 - entry = d_alloc(Novfs_root, &name);
5737 - DbgPrint("Novfs_Add_to_Root: d_alloc 0x%p\n", entry);
5738 + entry = d_alloc(novfs_root, &name);
5739 + DbgPrint("novfs_Add_to_Root: d_alloc 0x%p\n", entry);
5740 if (entry) {
5741 - entry->d_op = &Novfs_dentry_operations;
5742 - entry->d_time = jiffies + (File_update_timeout * HZ);
5743 + entry->d_op = &novfs_dentry_operations;
5744 + entry->d_time = jiffies + (novfs_update_timeout * HZ);
5745 /*
5746 - * done in Novfs_d_add now... entry->d_fsdata = (void *)Novfs_internal_hash( &name );
5747 + * done in novfs_d_add now... entry->d_fsdata = (void *)novfs_internal_hash( &name );
5748 */
5749 inode =
5750 - Novfs_get_inode(Novfs_root->d_sb, S_IFDIR | 0700, 0, Scope_Get_Uid(scope), 0, &name);
5751 - DbgPrint("Novfs_Add_to_Root: Inode=0x%p\n", inode);
5752 + novfs_get_inode(novfs_root->d_sb, S_IFDIR | 0700, 0, novfs_scope_get_uid(scope), 0, &name);
5753 + DbgPrint("novfs_Add_to_Root: Inode=0x%p\n", inode);
5754 if (inode) {
5755 inode->i_atime =
5756 inode->i_ctime =
5757 inode->i_mtime = CURRENT_TIME;
5758 - if (!Novfs_d_add(Novfs_root, entry, inode, 1)) {
5759 - if (inode->FSPRIVATE) {
5760 - ((struct inode_data *) inode->
5761 - FSPRIVATE)->Flags = USER_INODE;
5762 + if (!novfs_d_add(novfs_root, entry, inode, 1)) {
5763 + if (inode->i_private) {
5764 + struct inode_data *n_inode = inode->i_private;
5765 + n_inode->Flags = USER_INODE;
5766 }
5767 - PRINT_DENTRY("After Novfs_d_add",
5768 + PRINT_DENTRY("After novfs_d_add",
5769 entry);
5770 } else {
5771 dput(entry);
5772 @@ -544,27 +471,12 @@ int Novfs_Add_to_Root2(char *AddName)
5773 }
5774 } else {
5775 dput(entry);
5776 - PRINT_DENTRY("Novfs_Add_to_Root: After dput Dentry", entry);
5777 + PRINT_DENTRY("novfs_Add_to_Root: After dput Dentry", entry);
5778 }
5779 return (0);
5780 }
5781
5782 -/*++======================================================================*/
5783 -char *Novfs_dget_path(struct dentry *Dentry, char *Buf, unsigned int Buflen)
5784 -/*
5785 - * Arguments: struct dentry *Dentry - starting entry
5786 - * char *Buf - pointer to memory buffer
5787 - * unsigned int Buflen - size of memory buffer
5788 - *
5789 - * Returns: pointer to path.
5790 - *
5791 - * Abstract: Walks the dentry chain building a path.
5792 - *
5793 - * Notes:
5794 - *
5795 - * Environment:
5796 - *
5797 - *========================================================================*/
5798 +char *novfs_dget_path(struct dentry *Dentry, char *Buf, unsigned int Buflen)
5799 {
5800 char *retval = &Buf[Buflen];
5801 struct dentry *p = Dentry;
5802 @@ -591,34 +503,17 @@ char *Novfs_dget_path(struct dentry *Den
5803 }
5804
5805 if (retval)
5806 - DbgPrint("Novfs_dget_path: %s\n", retval);
5807 + DbgPrint("novfs_dget_path: %s\n", retval);
5808 return (retval);
5809 }
5810
5811 -/*++======================================================================*/
5812 int verify_dentry(struct dentry *dentry, int Flags)
5813 -/*
5814 - * Arguments: struct dentry *dentry - entry to verify
5815 - *
5816 - * Returns: zero - Inode cache has been updated. If not in the cache
5817 - * then file doesn't exist.
5818 - * !zero - Error
5819 - *
5820 - * Abstract: This routine will verify if the file that dentry is pointing
5821 - * at exist and if it does it will put it in the inode cache of
5822 - * the parent.
5823 - *
5824 - * Notes:
5825 - *
5826 - * Environment:
5827 - *
5828 - *========================================================================*/
5829 {
5830 int retVal = -ENOENT;
5831 struct inode *dir;
5832 - struct entry_info *info = NULL;
5833 + struct novfs_entry_info *info = NULL;
5834 struct inode_data *id;
5835 - session_t session;
5836 + struct novfs_schandle session;
5837 char *path, *list = NULL, *cp;
5838 ino_t ino = 0;
5839 struct qstr name;
5840 @@ -633,19 +528,19 @@ int verify_dentry(struct dentry *dentry,
5841 }
5842
5843 if (dentry && dentry->d_parent &&
5844 - (dir = dentry->d_parent->d_inode) && (id = dir->FSPRIVATE)) {
5845 + (dir = dentry->d_parent->d_inode) && (id = dir->i_private)) {
5846 parent = dget_parent(dentry);
5847
5848 - info = Novfs_Malloc(sizeof(struct entry_info) + PATH_LENGTH_BUFFER, GFP_KERNEL);
5849 + info = kmalloc(sizeof(struct novfs_entry_info) + PATH_LENGTH_BUFFER, GFP_KERNEL);
5850
5851 if (info) {
5852 - if (Novfs_lock_inode_cache(dir)) {
5853 + if (novfs_lock_inode_cache(dir)) {
5854 name.len = dentry->d_name.len;
5855 name.name = dentry->d_name.name;
5856 - name.hash = Novfs_internal_hash(&name);
5857 - if (!Novfs_get_entry_time(dir, &name, &ino, info, &ctime)) {
5858 + name.hash = novfs_internal_hash(&name);
5859 + if (!novfs_get_entry_time(dir, &name, &ino, info, &ctime)) {
5860 inode = dentry->d_inode;
5861 - if (inode && inode->FSPRIVATE &&
5862 + if (inode && inode->i_private &&
5863 ((inode->i_size != info->size) ||
5864 (inode->i_mtime.tv_sec !=
5865 info->mtime.tv_sec)
5866 @@ -654,30 +549,31 @@ int verify_dentry(struct dentry *dentry,
5867 /*
5868 * Values don't match so update.
5869 */
5870 - ((struct inode_data *) inode->FSPRIVATE)->Flags |= UPDATE_INODE;
5871 + struct inode_data *n_inode = inode->i_private;
5872 + n_inode->Flags |= UPDATE_INODE;
5873 }
5874
5875 ctime = get_jiffies_64() - ctime;
5876 - if (Flags || ctime < (u64) (File_update_timeout * HZ)) {
5877 + if (Flags || ctime < (u64) (novfs_update_timeout * HZ)) {
5878 retVal = 0;
5879 - Novfs_unlock_inode_cache(dir);
5880 + novfs_unlock_inode_cache(dir);
5881 dput(parent);
5882 kfree(info);
5883 return (0);
5884 }
5885 }
5886 - Novfs_unlock_inode_cache(dir);
5887 + novfs_unlock_inode_cache(dir);
5888 }
5889
5890 if (IS_ROOT(dentry->d_parent)) {
5891 - session = Scope_Get_SessionId(Scope_Get_ScopefromName(&dentry->d_name));
5892 - } else {
5893 - session = Scope_Get_SessionId(id->Scope);
5894 - }
5895 + session = novfs_scope_get_sessionId(
5896 + novfs_get_scope_from_name(&dentry->d_name));
5897 + } else
5898 + session = novfs_scope_get_sessionId(id->Scope);
5899
5900 if (!SC_PRESENT(session)) {
5901 - id->Scope = Scope_Get_ScopefromPath(dentry);
5902 - session = Scope_Get_SessionId(id->Scope);
5903 + id->Scope = novfs_get_scope(dentry);
5904 + session = novfs_scope_get_sessionId(id->Scope);
5905 }
5906
5907 ino = 0;
5908 @@ -685,62 +581,65 @@ int verify_dentry(struct dentry *dentry,
5909
5910 if (IS_ROOT(dentry->d_parent)) {
5911 DbgPrint("verify_dentry: parent is Root directory\n");
5912 - list = Scope_Get_ScopeUsers();
5913 + list = novfs_get_scopeusers();
5914
5915 - iLock = Novfs_lock_inode_cache(dir);
5916 - Novfs_invalidate_inode_cache(dir);
5917 + iLock = novfs_lock_inode_cache(dir);
5918 + novfs_invalidate_inode_cache(dir);
5919
5920 if (list) {
5921 cp = list;
5922 while (*cp) {
5923 name.name = cp;
5924 name.len = strlen(cp);
5925 - name.hash = Novfs_internal_hash(&name);
5926 + name.hash = novfs_internal_hash(&name);
5927 cp += (name.len + 1);
5928 ino = 0;
5929 - if (Novfs_get_entry(dir, &name, &ino, info)) {
5930 + if (novfs_get_entry(dir, &name, &ino, info)) {
5931 info->mode = S_IFDIR | 0700;
5932 info->size = 0;
5933 info->atime = info->ctime = info->mtime = CURRENT_TIME;
5934 - ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
5935 - Novfs_add_inode_entry(dir, &name, ino, info);
5936 + ino = (ino_t)atomic_inc_return(&novfs_Inode_Number);
5937 + novfs_add_inode_entry(dir, &name, ino, info);
5938 }
5939 }
5940 }
5941 - Novfs_free_invalid_entries(dir);
5942 + novfs_free_invalid_entries(dir);
5943 } else {
5944
5945 path =
5946 - Novfs_dget_path(dentry, info->name,
5947 + novfs_dget_path(dentry, info->name,
5948 PATH_LENGTH_BUFFER);
5949 if (path) {
5950 if (dentry->d_name.len <=
5951 NW_MAX_PATH_LENGTH) {
5952 name.hash =
5953 - Novfs_internal_hash
5954 + novfs_internal_hash
5955 (&dentry->d_name);
5956 name.len = dentry->d_name.len;
5957 name.name = dentry->d_name.name;
5958
5959 - retVal = Novfs_Get_File_Info(path, info, &session);
5960 + retVal =
5961 + novfs_get_file_info(path,
5962 + info,
5963 + session);
5964 if (0 == retVal) {
5965 dentry->d_time =
5966 jiffies +
5967 - (File_update_timeout
5968 + (novfs_update_timeout
5969 * HZ);
5970 iLock =
5971 - Novfs_lock_inode_cache
5972 + novfs_lock_inode_cache
5973 (dir);
5974 - if (Novfs_update_entry
5975 + if (novfs_update_entry
5976 (dir, &name, 0,
5977 info)) {
5978 if (dentry->
5979 d_inode) {
5980 ino = dentry->d_inode->i_ino;
5981 } else {
5982 - ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
5983 + ino = (ino_t)atomic_inc_return(&novfs_Inode_Number);
5984 }
5985 - Novfs_add_inode_entry
5986 + novfs_add_inode_entry
5987 (dir, &name,
5988 ino, info);
5989 }
5990 @@ -758,14 +657,14 @@ int verify_dentry(struct dentry *dentry,
5991 ~S_DEAD;
5992 if (dentry->
5993 d_inode->
5994 - FSPRIVATE) {
5995 - ((struct inode_data *) dentry->d_inode->FSPRIVATE)->Scope = id->Scope;
5996 + i_private) {
5997 + ((struct inode_data *) dentry->d_inode->i_private)->Scope = id->Scope;
5998 }
5999 }
6000 } else if (-EINTR != retVal) {
6001 retVal = 0;
6002 - iLock = Novfs_lock_inode_cache(dir);
6003 - Novfs_remove_inode_entry(dir, &name, 0);
6004 + iLock = novfs_lock_inode_cache(dir);
6005 + novfs_remove_inode_entry(dir, &name, 0);
6006 if (dentry->d_inode
6007 && !(dentry->d_inode->i_flags & S_DEAD)) {
6008 dentry->d_inode->i_flags |= S_DEAD;
6009 @@ -789,7 +688,7 @@ int verify_dentry(struct dentry *dentry,
6010 retVal = -ENOMEM;
6011 }
6012 if (iLock) {
6013 - Novfs_unlock_inode_cache(dir);
6014 + novfs_unlock_inode_cache(dir);
6015 }
6016 dput(parent);
6017 }
6018 @@ -804,67 +703,37 @@ int verify_dentry(struct dentry *dentry,
6019 return (retVal);
6020 }
6021
6022 -/*++======================================================================*/
6023 -struct dentry *Novfs_d_lookup(struct dentry *Parent, struct qstr *Name)
6024 -/*
6025 - * Arguments:
6026 - *
6027 - * Returns:
6028 - *
6029 - * Abstract:
6030 - *
6031 - * Notes:
6032 - *
6033 - * Environment:
6034 - *
6035 - *========================================================================*/
6036 -{
6037 - return (d_lookup(Parent, Name));
6038 -}
6039
6040 -/*++======================================================================*/
6041 -int Novfs_d_add(struct dentry *Parent, struct dentry *d, struct inode *i, int a)
6042 -/*
6043 - * Arguments:
6044 - *
6045 - * Returns:
6046 - *
6047 - * Abstract:
6048 - *
6049 - * Notes:
6050 - *
6051 - * Environment:
6052 - *
6053 - *========================================================================*/
6054 +static int novfs_d_add(struct dentry *Parent, struct dentry *d, struct inode *i, int a)
6055 {
6056 void *scope;
6057 struct inode_data *id = NULL;
6058
6059 char *path, *buf;
6060
6061 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6062 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6063 if (buf) {
6064 - path = Novfs_dget_path(d, buf, PATH_LENGTH_BUFFER);
6065 + path = novfs_dget_path(d, buf, PATH_LENGTH_BUFFER);
6066 if (path) {
6067 - DbgPrint("Novfs_d_add: inode=0x%p ino=%d path %s\n", i,
6068 + DbgPrint("novfs_d_add: inode=0x%p ino=%d path %s\n", i,
6069 i->i_ino, path);
6070 }
6071 kfree(buf);
6072 }
6073
6074 - if (Parent && Parent->d_inode && Parent->d_inode->FSPRIVATE) {
6075 - id = (struct inode_data *) Parent->d_inode->FSPRIVATE;
6076 + if (Parent && Parent->d_inode && Parent->d_inode->i_private) {
6077 + id = (struct inode_data *) Parent->d_inode->i_private;
6078 }
6079
6080 if (id && id->Scope) {
6081 scope = id->Scope;
6082 } else {
6083 - scope = Scope_Get_ScopefromPath(d);
6084 + scope = novfs_get_scope(d);
6085 }
6086
6087 - ((struct inode_data *) i->FSPRIVATE)->Scope = scope;
6088 + ((struct inode_data *) i->i_private)->Scope = scope;
6089
6090 - d->d_time = jiffies + (File_update_timeout * HZ);
6091 + d->d_time = jiffies + (novfs_update_timeout * HZ);
6092 if (a) {
6093 d_add(d, i);
6094 } else {
6095 @@ -874,29 +743,14 @@ int Novfs_d_add(struct dentry *Parent, s
6096 return (0);
6097 }
6098
6099 -/*++======================================================================*/
6100 -int Novfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
6101 -/*
6102 - * Arguments: struct dentry *dentry - pointer to dentry to revalidate.
6103 - * struct nameidata *nd - pointer to nameidata.
6104 - *
6105 - * Returns: zero - dentry is not valid.
6106 - * !zero - valid entry
6107 - *
6108 - * Abstract:
6109 - *
6110 - * Notes:
6111 - *
6112 - * Environment:
6113 - *
6114 - *========================================================================*/
6115 +int novfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
6116 {
6117 int retCode = 0;
6118 struct inode *dir;
6119 struct inode_data *id;
6120 struct qstr name;
6121
6122 - DbgPrint("Novfs_d_revalidate: 0x%p %.*s\n"
6123 + DbgPrint("novfs_d_revalidate: 0x%p %.*s\n"
6124 " d_count: %d\n"
6125 " d_inode: 0x%p\n",
6126 dentry, dentry->d_name.len, dentry->d_name.name,
6127 @@ -908,7 +762,7 @@ int Novfs_d_revalidate(struct dentry *de
6128 if (dentry->d_inode &&
6129 dentry->d_parent &&
6130 (dir = dentry->d_parent->d_inode) &&
6131 - (id = dir->FSPRIVATE)) {
6132 + (id = dir->i_private)) {
6133 /*
6134 * Check timer to see if in valid time limit
6135 */
6136 @@ -919,20 +773,20 @@ int Novfs_d_revalidate(struct dentry *de
6137 name.len = dentry->d_name.len;
6138 name.name = dentry->d_name.name;
6139 name.hash =
6140 - Novfs_internal_hash(&dentry->d_name);
6141 + novfs_internal_hash(&dentry->d_name);
6142 dentry->d_time = 0;
6143
6144 if (0 == verify_dentry(dentry, 0)) {
6145 - if (Novfs_lock_inode_cache(dir)) {
6146 - if (Novfs_lookup_inode_cache
6147 + if (novfs_lock_inode_cache(dir)) {
6148 + if (novfs_lookup_inode_cache
6149 (dir, &name, 0)) {
6150 dentry->d_time =
6151 jiffies +
6152 - (File_update_timeout
6153 + (novfs_update_timeout
6154 * HZ);
6155 retCode = 1;
6156 }
6157 - Novfs_unlock_inode_cache(dir);
6158 + novfs_unlock_inode_cache(dir);
6159 }
6160 }
6161 } else {
6162 @@ -949,26 +803,13 @@ int Novfs_d_revalidate(struct dentry *de
6163 */
6164 }
6165
6166 - DbgPrint("Novfs_d_revalidate: return 0x%x %.*s\n", retCode,
6167 + DbgPrint("novfs_d_revalidate: return 0x%x %.*s\n", retCode,
6168 dentry->d_name.len, dentry->d_name.name);
6169
6170 return (retCode);
6171 }
6172
6173 -/*++======================================================================*/
6174 -unsigned long Novfs_internal_hash(struct qstr *name)
6175 -/*
6176 - * Arguments:
6177 - *
6178 - * Returns:
6179 - *
6180 - * Abstract:
6181 - *
6182 - * Notes:
6183 - *
6184 - * Environment:
6185 - *
6186 - *========================================================================*/
6187 +static unsigned long novfs_internal_hash(struct qstr *name)
6188 {
6189 unsigned long hash = 0;
6190 unsigned int len = name->len;
6191 @@ -984,48 +825,22 @@ unsigned long Novfs_internal_hash(struct
6192 return (hash);
6193 }
6194
6195 -/*++======================================================================*/
6196 -int Novfs_d_hash(struct dentry *dentry, struct qstr *name)
6197 -/*
6198 - * Arguments:
6199 - *
6200 - * Returns:
6201 - *
6202 - * Abstract:
6203 - *
6204 - * Notes:
6205 - *
6206 - * Environment:
6207 - *
6208 - *========================================================================*/
6209 +int novfs_d_hash(struct dentry *dentry, struct qstr *name)
6210 {
6211 - DbgPrint("Novfs_d_hash: %.*s\n", name->len, name->name);
6212 + DbgPrint("novfs_d_hash: %.*s\n", name->len, name->name);
6213
6214 - name->hash = Novfs_internal_hash(name);
6215 + name->hash = novfs_internal_hash(name);
6216
6217 return (0);
6218 }
6219
6220 -/*++======================================================================*/
6221 -int Novfs_d_strcmp(struct qstr *s1, struct qstr *s2)
6222 -/*
6223 - * Arguments:
6224 - *
6225 - * Returns:
6226 - *
6227 - * Abstract:
6228 - *
6229 - * Notes:
6230 - *
6231 - * Environment:
6232 - *
6233 - *========================================================================*/
6234 +int novfs_d_strcmp(struct qstr *s1, struct qstr *s2)
6235 {
6236 int retCode = 1;
6237 unsigned char *str1, *str2;
6238 unsigned int len;
6239
6240 - DbgPrint("Novfs_d_strcmp: s1=%.*s s2=%.*s\n", s1->len, s1->name,
6241 + DbgPrint("novfs_d_strcmp: s1=%.*s s2=%.*s\n", s1->len, s1->name,
6242 s2->len, s2->name);
6243
6244 if (s1->len && (s1->len == s2->len) && (s1->hash == s2->hash)) {
6245 @@ -1042,51 +857,25 @@ int Novfs_d_strcmp(struct qstr *s1, stru
6246 }
6247 }
6248
6249 - DbgPrint("Novfs_d_strcmp: retCode=0x%x\n", retCode);
6250 + DbgPrint("novfs_d_strcmp: retCode=0x%x\n", retCode);
6251 return (retCode);
6252 }
6253
6254 -/*++======================================================================*/
6255 -int Novfs_d_compare(struct dentry *parent, struct qstr *s1, struct qstr *s2)
6256 -/*
6257 - * Arguments:
6258 - *
6259 - * Returns:
6260 - *
6261 - * Abstract:
6262 - *
6263 - * Notes:
6264 - *
6265 - * Environment:
6266 - *
6267 - *========================================================================*/
6268 +int novfs_d_compare(struct dentry *parent, struct qstr *s1, struct qstr *s2)
6269 {
6270 int retCode;
6271
6272 - retCode = Novfs_d_strcmp(s1, s2);
6273 + retCode = novfs_d_strcmp(s1, s2);
6274
6275 - DbgPrint("Novfs_d_compare: retCode=0x%x\n", retCode);
6276 + DbgPrint("novfs_d_compare: retCode=0x%x\n", retCode);
6277 return (retCode);
6278 }
6279
6280 -/*++======================================================================*/
6281 -int Novfs_d_delete(struct dentry *dentry)
6282 -/*
6283 - * Arguments:
6284 - *
6285 - * Returns:
6286 - *
6287 - * Abstract:
6288 - *
6289 - * Notes:
6290 - *
6291 - * Environment:
6292 - *
6293 - *========================================================================*/
6294 +int novfs_d_delete(struct dentry *dentry)
6295 {
6296 int retVal = 0;
6297
6298 - DbgPrint("Novfs_d_delete: 0x%p %.*s\n"
6299 + DbgPrint("novfs_d_delete: 0x%p %.*s\n"
6300 " d_count: %d\n"
6301 " d_inode: 0x%p\n",
6302 dentry, dentry->d_name.len, dentry->d_name.name,
6303 @@ -1101,42 +890,16 @@ int Novfs_d_delete(struct dentry *dentry
6304 return (retVal);
6305 }
6306
6307 -/*++======================================================================*/
6308 -void Novfs_d_release(struct dentry *dentry)
6309 -/*
6310 - * Arguments:
6311 - *
6312 - * Returns:
6313 - *
6314 - * Abstract:
6315 - *
6316 - * Notes:
6317 - *
6318 - * Environment:
6319 - *
6320 - *========================================================================*/
6321 +void novfs_d_release(struct dentry *dentry)
6322 {
6323 - DbgPrint("Novfs_d_release: 0x%p %.*s\n", dentry, dentry->d_name.len,
6324 + DbgPrint("novfs_d_release: 0x%p %.*s\n", dentry, dentry->d_name.len,
6325 dentry->d_name.name);
6326 }
6327
6328 -/*++======================================================================*/
6329 -void Novfs_d_iput(struct dentry *dentry, struct inode *inode)
6330 -/*
6331 - * Arguments:
6332 - *
6333 - * Returns:
6334 - *
6335 - * Abstract:
6336 - *
6337 - * Notes:
6338 - *
6339 - * Environment:
6340 - *
6341 - *========================================================================*/
6342 +void novfs_d_iput(struct dentry *dentry, struct inode *inode)
6343 {
6344 DbgPrint
6345 - ("Novfs_d_iput: Inode=0x%p Ino=%d Dentry=0x%p i_state=%d Name=%.*s\n",
6346 + ("novfs_d_iput: Inode=0x%p Ino=%d Dentry=0x%p i_state=%d Name=%.*s\n",
6347 inode, inode->i_ino, dentry, inode->i_state, dentry->d_name.len,
6348 dentry->d_name.name);
6349
6350 @@ -1144,37 +907,24 @@ void Novfs_d_iput(struct dentry *dentry,
6351
6352 }
6353
6354 -/*++======================================================================*/
6355 -int Novfs_dir_open(struct inode *dir, struct file *file)
6356 -/*
6357 - * Arguments:
6358 - *
6359 - * Returns:
6360 - *
6361 - * Abstract:
6362 - *
6363 - * Notes:
6364 - *
6365 - * Environment:
6366 - *
6367 - *========================================================================*/
6368 +int novfs_dir_open(struct inode *dir, struct file *file)
6369 {
6370 char *path, *buf;
6371 - FilePrivate2 *file_private = NULL;
6372 + struct file_private *file_private = NULL;
6373
6374 - DbgPrint("Novfs_dir_open: Inode 0x%p %d Name %.*s\n", dir, dir->i_ino,
6375 + DbgPrint("novfs_dir_open: Inode 0x%p %d Name %.*s\n", dir, dir->i_ino,
6376 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
6377
6378 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6379 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6380 if (buf) {
6381 - path = Novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
6382 + path = novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
6383 if (path) {
6384 - DbgPrint("Novfs_dir_open: path %s\n", path);
6385 + DbgPrint("novfs_dir_open: path %s\n", path);
6386 }
6387 kfree(buf);
6388 }
6389
6390 - file_private = Novfs_Malloc(sizeof(FilePrivate2), GFP_KERNEL);
6391 + file_private = kmalloc(sizeof(struct file_private), GFP_KERNEL);
6392 file_private->listedall = 0;
6393 file_private->enumHandle = NULL;
6394
6395 @@ -1183,25 +933,12 @@ int Novfs_dir_open(struct inode *dir, st
6396 return (0);
6397 }
6398
6399 -/*++======================================================================*/
6400 -int Novfs_dir_release(struct inode *dir, struct file *file)
6401 -/*
6402 - * Arguments:
6403 - *
6404 - * Returns:
6405 - *
6406 - * Abstract:
6407 - *
6408 - * Notes:
6409 - *
6410 - * Environment:
6411 - *
6412 - *========================================================================*/
6413 +int novfs_dir_release(struct inode *dir, struct file *file)
6414 {
6415 - FilePrivate2 *file_private;
6416 - file_private = (FilePrivate2 *) file->private_data;
6417 + struct file_private *file_private;
6418 + file_private = (struct file_private *) file->private_data;
6419
6420 - DbgPrint("Novfs_dir_release: Inode 0x%p %d Name %.*s\n", dir,
6421 + DbgPrint("novfs_dir_release: Inode 0x%p %d Name %.*s\n", dir,
6422 dir->i_ino, file->f_dentry->d_name.len,
6423 file->f_dentry->d_name.name);
6424
6425 @@ -1213,24 +950,11 @@ int Novfs_dir_release(struct inode *dir,
6426 return (0);
6427 }
6428
6429 -/*++======================================================================*/
6430 -loff_t Novfs_dir_lseek(struct file * file, loff_t offset, int origin)
6431 -/*
6432 - * Arguments:
6433 - *
6434 - * Returns:
6435 - *
6436 - * Abstract:
6437 - *
6438 - * Notes:
6439 - *
6440 - * Environment:
6441 - *
6442 - *========================================================================*/
6443 +loff_t novfs_dir_lseek(struct file * file, loff_t offset, int origin)
6444 {
6445 - FilePrivate2 *file_private = NULL;
6446 + struct file_private *file_private = NULL;
6447
6448 - DbgPrint("Novfs_dir_lseek: offset %lld %d Name %.*s\n", offset, origin,
6449 + DbgPrint("novfs_dir_lseek: offset %lld %d Name %.*s\n", offset, origin,
6450 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
6451 //printk("<1> seekdir file = %.*s offset = %i\n", file->f_dentry->d_name.len, file->f_dentry->d_name.name, (int)offset);
6452
6453 @@ -1240,7 +964,7 @@ loff_t Novfs_dir_lseek(struct file * fil
6454
6455 file->f_pos = 0;
6456
6457 - file_private = (FilePrivate2 *) file->private_data;
6458 + file_private = (struct file_private *) file->private_data;
6459 file_private->listedall = 0;
6460 file_private->enumHandle = NULL;
6461
6462 @@ -1248,25 +972,12 @@ loff_t Novfs_dir_lseek(struct file * fil
6463 //return(default_llseek(file, offset, origin));
6464 }
6465
6466 -/*++======================================================================*/
6467 -ssize_t Novfs_dir_read(struct file * file, char *buf, size_t len, loff_t * off)
6468 -/*
6469 - * Arguments:
6470 - *
6471 - * Returns:
6472 - *
6473 - * Abstract:
6474 - *
6475 - * Notes:
6476 - *
6477 - * Environment:
6478 - *
6479 - *========================================================================*/
6480 +ssize_t novfs_dir_read(struct file * file, char *buf, size_t len, loff_t * off)
6481 {
6482 /*
6483 int rlen = 0;
6484
6485 - DbgPrint("Novfs_dir_readdir: dentry path %.*s buf=0x%p len=%d off=%lld\n", file->f_dentry->d_name.len, file->f_dentry->d_name.name, buf, len, *off);
6486 + DbgPrint("novfs_dir_readdir: dentry path %.*s buf=0x%p len=%d off=%lld\n", file->f_dentry->d_name.len, file->f_dentry->d_name.name, buf, len, *off);
6487
6488 if (0 == *off)
6489 {
6490 @@ -1276,19 +987,19 @@ ssize_t Novfs_dir_read(struct file * fil
6491 }
6492 return(rlen);
6493 */
6494 - DbgPrint("Novfs_dir_read: %lld %d Name %.*s\n", *off, len,
6495 + DbgPrint("novfs_dir_read: %lld %d Name %.*s\n", *off, len,
6496 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
6497 return (generic_read_dir(file, buf, len, off));
6498 }
6499
6500 -static void Novfs_Dump_Info(struct entry_info *info)
6501 +static void novfs_Dump_Info(struct novfs_entry_info *info)
6502 {
6503 char atime_buf[32], mtime_buf[32], ctime_buf[32];
6504 char namebuf[512];
6505 int len = 0;
6506
6507 if (info == NULL) {
6508 - DbgPrint("Novfs_dir_readdir : Dump_Info info == NULL\n");
6509 + DbgPrint("novfs_dir_readdir : Dump_Info info == NULL\n");
6510 return;
6511 }
6512
6513 @@ -1304,42 +1015,29 @@ static void Novfs_Dump_Info(struct entry
6514 ctime_r(&info->atime.tv_sec, atime_buf);
6515 ctime_r(&info->mtime.tv_sec, mtime_buf);
6516 ctime_r(&info->ctime.tv_sec, ctime_buf);
6517 - DbgPrint("Novfs_dir_readdir : type = %i\n", info->type);
6518 - DbgPrint("Novfs_dir_readdir : mode = %x\n", info->mode);
6519 - DbgPrint("Novfs_dir_readdir : uid = %d\n", info->uid);
6520 - DbgPrint("Novfs_dir_readdir : gid = %d\n", info->gid);
6521 - DbgPrint("Novfs_dir_readdir : size = %i\n", info->size);
6522 - DbgPrint("Novfs_dir_readdir : atime = %s\n", atime_buf);
6523 - DbgPrint("Novfs_dir_readdir : mtime = %s\n", mtime_buf);
6524 - DbgPrint("Novfs_dir_readdir : ctime = %s\n", ctime_buf);
6525 - DbgPrint("Novfs_dir_readdir : namelength = %i\n", info->namelength);
6526 - DbgPrint("Novfs_dir_readdir : name = %s\n", namebuf);
6527 + DbgPrint("novfs_dir_readdir : type = %i\n", info->type);
6528 + DbgPrint("novfs_dir_readdir : mode = %x\n", info->mode);
6529 + DbgPrint("novfs_dir_readdir : uid = %d\n", info->uid);
6530 + DbgPrint("novfs_dir_readdir : gid = %d\n", info->gid);
6531 + DbgPrint("novfs_dir_readdir : size = %i\n", info->size);
6532 + DbgPrint("novfs_dir_readdir : atime = %s\n", atime_buf);
6533 + DbgPrint("novfs_dir_readdir : mtime = %s\n", mtime_buf);
6534 + DbgPrint("novfs_dir_readdir : ctime = %s\n", ctime_buf);
6535 + DbgPrint("novfs_dir_readdir : namelength = %i\n", info->namelength);
6536 + DbgPrint("novfs_dir_readdir : name = %s\n", namebuf);
6537 }
6538
6539 -/*++======================================================================*/
6540 void processList(struct file *file, void *dirent, filldir_t filldir, char *list,
6541 - int type, session_t SessionId)
6542 -/*
6543 - * Arguments:
6544 - *
6545 - * Returns:
6546 - *
6547 - * Abstract:
6548 - *
6549 - * Notes:
6550 - *
6551 - * Environment:
6552 - *
6553 - *========================================================================*/
6554 + int type, struct novfs_schandle SessionId)
6555 {
6556 unsigned char *path, *buf = NULL, *cp;
6557 struct qstr name;
6558 - struct entry_info *pinfo = NULL;
6559 + struct novfs_entry_info *pinfo = NULL;
6560
6561 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6562 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6563 path = buf;
6564 if (buf) {
6565 - path = Novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
6566 + path = novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
6567 if (path) {
6568 strcpy(buf, path);
6569 }
6570 @@ -1351,14 +1049,14 @@ void processList(struct file *file, void
6571 cp = list;
6572 while (*cp) {
6573 name.name = cp;
6574 - DbgPrint("Novfs_dir_readdir : name.name = %s\n",
6575 + DbgPrint("novfs_dir_readdir : name.name = %s\n",
6576 name.name);
6577 name.len = strlen(cp);
6578 - name.hash = Novfs_internal_hash(&name);
6579 + name.hash = novfs_internal_hash(&name);
6580 cp += (name.len + 1);
6581
6582 pinfo =
6583 - Novfs_Malloc(sizeof(struct entry_info) +
6584 + kmalloc(sizeof(struct novfs_entry_info) +
6585 PATH_LENGTH_BUFFER, GFP_KERNEL);
6586 pinfo->mode = S_IFDIR | 0700;
6587 pinfo->size = 0;
6588 @@ -1367,7 +1065,7 @@ void processList(struct file *file, void
6589 strcpy(pinfo->name, name.name);
6590 pinfo->namelength = name.len;
6591
6592 - Novfs_Dump_Info(pinfo);
6593 + novfs_Dump_Info(pinfo);
6594
6595 filldir(dirent, pinfo->name, pinfo->namelength,
6596 file->f_pos, file->f_pos, pinfo->mode >> 12);
6597 @@ -1383,26 +1081,28 @@ void processList(struct file *file, void
6598 }
6599
6600 int processEntries(struct file *file, void *dirent, filldir_t filldir,
6601 - HANDLE * enumHandle, session_t sessionId)
6602 + void ** enumHandle, struct novfs_schandle sessionId)
6603 {
6604 unsigned char *path = NULL, *buf = NULL;
6605 int count = 0, status = 0;
6606 - struct entry_info *pinfo = NULL;
6607 - struct entry_info *pInfoMem = NULL;
6608 + struct novfs_entry_info *pinfo = NULL;
6609 + struct novfs_entry_info *pInfoMem = NULL;
6610
6611 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6612 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
6613 if (!buf) {
6614 return -ENOMEM;
6615 }
6616
6617 - path = Novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
6618 + path = novfs_dget_path(file->f_dentry, buf, PATH_LENGTH_BUFFER);
6619 if (!path) {
6620 kfree(buf);
6621 return -ENOMEM;
6622 }
6623 //NWSearchfiles
6624 count = 0;
6625 - status = Novfs_Get_Directory_ListEx(path, enumHandle, &count, &pinfo, &sessionId);
6626 + status =
6627 + novfs_get_dir_listex(path, enumHandle, &count, &pinfo,
6628 + sessionId);
6629 pInfoMem = pinfo;
6630
6631 if ((count == -1) || (count == 0) || (status != 0)) {
6632 @@ -1416,7 +1116,7 @@ int processEntries(struct file *file, vo
6633 file->f_pos, pinfo->mode >> 12);
6634 file->f_pos += 1;
6635
6636 - pinfo = (struct entry_info *)(pinfo->name + pinfo->namelength);
6637 + pinfo = (struct novfs_entry_info *) (pinfo->name + pinfo->namelength);
6638 }
6639
6640 kfree(pInfoMem);
6641 @@ -1424,32 +1124,19 @@ int processEntries(struct file *file, vo
6642 return 0;
6643 }
6644
6645 -/*++======================================================================*/
6646 -int Novfs_dir_readdir(struct file *file, void *dirent, filldir_t filldir)
6647 -/*
6648 - * Arguments:
6649 - *
6650 - * Returns:
6651 - *
6652 - * Abstract:
6653 - *
6654 - * Notes:
6655 - *
6656 - * Environment:
6657 - *
6658 - *========================================================================*/
6659 +int novfs_dir_readdir(struct file *file, void *dirent, filldir_t filldir)
6660 {
6661 unsigned char *list = NULL;
6662 int status = 0; //-ENOMEM;
6663 struct inode *inode = file->f_dentry->d_inode;
6664 - session_t sessionId;
6665 + struct novfs_schandle sessionId;
6666 uid_t uid;
6667 int type = 0;
6668 - FilePrivate2 *file_private = NULL;
6669 + struct file_private *file_private = NULL;
6670 int lComm;
6671
6672 - file_private = (FilePrivate2 *) file->private_data;
6673 - DbgPrint("Novfs_dir_readdir: Name %.*s\n", file->f_dentry->d_name.len,
6674 + file_private = (struct file_private *) file->private_data;
6675 + DbgPrint("novfs_dir_readdir: Name %.*s\n", file->f_dentry->d_name.len,
6676 file->f_dentry->d_name.name);
6677
6678 //printk("<1> file = %.*s\n", file->f_dentry->d_name.len, file->f_dentry->d_name.name);
6679 @@ -1510,16 +1197,18 @@ int Novfs_dir_readdir(struct file *file,
6680 }
6681
6682 inode = file->f_dentry->d_inode;
6683 - if (inode && inode->FSPRIVATE) {
6684 + if (inode && inode->i_private) {
6685 sessionId =
6686 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)-> Scope);
6687 + novfs_scope_get_sessionId(((struct inode_data *) inode->i_private)->
6688 + Scope);
6689 if (0 == SC_PRESENT(sessionId)) {
6690 - ((struct inode_data *)inode->FSPRIVATE)->Scope =
6691 - Scope_Get_ScopefromPath(file->f_dentry);
6692 + ((struct inode_data *) inode->i_private)->Scope =
6693 + novfs_get_scope(file->f_dentry);
6694 sessionId =
6695 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
6696 + novfs_scope_get_sessionId(((struct inode_data *) inode->
6697 + i_private)->Scope);
6698 }
6699 - uid = Scope_Get_Uid(((struct inode_data *)inode->FSPRIVATE)->Scope);
6700 + uid = novfs_scope_get_uid(((struct inode_data *) inode->i_private)->Scope);
6701 } else {
6702 SC_INITIALIZE(sessionId);
6703 uid = current->euid;
6704 @@ -1530,19 +1219,19 @@ int Novfs_dir_readdir(struct file *file,
6705 IS_ROOT(file->f_dentry->d_parent->d_parent)) // Server
6706 {
6707 if (IS_ROOT(file->f_dentry)) {
6708 - DbgPrint("Novfs_dir_readdir: Root directory\n");
6709 - list = Scope_Get_ScopeUsers();
6710 + DbgPrint("novfs_dir_readdir: Root directory\n");
6711 + list = novfs_get_scopeusers();
6712 type = USER_LIST;
6713 } else if (IS_ROOT(file->f_dentry->d_parent)) {
6714 DbgPrint
6715 - ("Novfs_dir_readdir: Parent is Root directory\n");
6716 - Novfs_Get_Connected_Server_List(&list, &sessionId);
6717 + ("novfs_dir_readdir: Parent is Root directory\n");
6718 + novfs_get_servers(&list, sessionId);
6719 type = SERVER_LIST;
6720 } else {
6721 DbgPrint
6722 - ("Novfs_dir_readdir: Parent-Parent is Root directory\n");
6723 - Novfs_Get_Server_Volume_List(&file->f_dentry->d_name,
6724 - &list, &sessionId);
6725 + ("novfs_dir_readdir: Parent-Parent is Root directory\n");
6726 + novfs_get_vols(&file->f_dentry->d_name,
6727 + &list, sessionId);
6728 type = VOLUME_LIST;
6729 }
6730
6731 @@ -1580,76 +1269,46 @@ int Novfs_dir_readdir(struct file *file,
6732 return 1;
6733 }
6734
6735 -/*++======================================================================*/
6736 -int Novfs_dir_fsync(struct file *file, struct dentry *dentry, int datasync)
6737 -/*
6738 - * Arguments:
6739 - *
6740 - * Returns:
6741 - *
6742 - * Abstract:
6743 - *
6744 - * Notes:
6745 - *
6746 - * Environment:
6747 - *
6748 - *========================================================================*/
6749 +int novfs_dir_fsync(struct file *file, struct dentry *dentry, int datasync)
6750 {
6751 - DbgPrint("Novfs_dir_fsync: Name %.*s\n", file->f_dentry->d_name.len,
6752 + DbgPrint("novfs_dir_fsync: Name %.*s\n", file->f_dentry->d_name.len,
6753 file->f_dentry->d_name.name);
6754 return (simple_sync_file(file, dentry, datasync));
6755 }
6756
6757 -/*++======================================================================*/
6758 -ssize_t Novfs_f_read(struct file * file, char *buf, size_t len, loff_t * off)
6759 -/*
6760 - * Arguments:
6761 - *
6762 - * Returns:
6763 - *
6764 - * Abstract:
6765 - *
6766 - * Notes:
6767 - *
6768 - * Environment:
6769 - *
6770 - *========================================================================*/
6771 +ssize_t novfs_f_read(struct file * file, char *buf, size_t len, loff_t * off)
6772 {
6773 size_t thisread, totalread = 0;
6774 loff_t offset = *off;
6775 struct inode *inode;
6776 - session_t session;
6777 + struct novfs_schandle session;
6778 struct inode_data *id;
6779
6780 if (file->f_dentry &&
6781 (inode = file->f_dentry->d_inode) &&
6782 - (id = (struct inode_data *)inode->FSPRIVATE)) {
6783 + (id = (struct inode_data *) inode->i_private)) {
6784
6785 - DbgPrint("Novfs_f_read(0x%p 0x%p %d %lld %.*s)\n",
6786 + DbgPrint("novfs_f_read(0x%p 0x%p %d %lld %.*s)\n",
6787 file->private_data,
6788 buf, len, offset,
6789 file->f_dentry->d_name.len,
6790 file->f_dentry->d_name.name);
6791
6792 - if (PageCache && !(file->f_flags & O_DIRECT) && id->CacheFlag) {
6793 -#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
6794 - totalread = generic_file_read(file, buf, len, off);
6795 -#else
6796 + if (novfs_page_cache && !(file->f_flags & O_DIRECT) && id->CacheFlag) {
6797 totalread = do_sync_read(file, buf, len, off);
6798 -#endif
6799 } else {
6800 - session = Scope_Get_SessionId(id->Scope);
6801 + session = novfs_scope_get_sessionId(id->Scope);
6802 if (0 == SC_PRESENT(session)) {
6803 id->Scope =
6804 - Scope_Get_ScopefromPath(file->f_dentry);
6805 - session = Scope_Get_SessionId(id->Scope);
6806 + novfs_get_scope(file->f_dentry);
6807 + session = novfs_scope_get_sessionId(id->Scope);
6808 }
6809
6810 while (len > 0 && (offset < i_size_read(inode))) {
6811 int retval;
6812 thisread = len;
6813 retval =
6814 - Novfs_Read_File(file->private_data, buf,
6815 + novfs_read_file(file->private_data, buf,
6816 &thisread, &offset,
6817 session);
6818 if (retval || !thisread) {
6819 @@ -1658,7 +1317,7 @@ ssize_t Novfs_f_read(struct file * file,
6820 }
6821 break;
6822 }
6823 - DbgPrint("Novfs_f_read thisread = 0x%x\n",
6824 + DbgPrint("novfs_f_read thisread = 0x%x\n",
6825 thisread);
6826 len -= thisread;
6827 buf += thisread;
6828 @@ -1668,77 +1327,60 @@ ssize_t Novfs_f_read(struct file * file,
6829 *off = offset;
6830 }
6831 }
6832 - DbgPrint("Novfs_f_read return = %d\n", totalread);
6833 + DbgPrint("novfs_f_read return = %d\n", totalread);
6834
6835 return (totalread);
6836 }
6837
6838 -/*++======================================================================*/
6839 -ssize_t Novfs_f_write(struct file * file, const char *buf, size_t len,
6840 +ssize_t novfs_f_write(struct file * file, const char *buf, size_t len,
6841 loff_t * off)
6842 -/*
6843 - * Arguments:
6844 - *
6845 - * Returns:
6846 - *
6847 - * Abstract:
6848 - *
6849 - * Notes:
6850 - *
6851 - * Environment:
6852 - *
6853 - *========================================================================*/
6854 {
6855 ssize_t thiswrite, totalwrite = 0;
6856 loff_t offset = *off;
6857 - session_t session;
6858 + struct novfs_schandle session;
6859 struct inode *inode;
6860 int status;
6861 struct inode_data *id;
6862
6863 if (file->f_dentry &&
6864 (inode = file->f_dentry->d_inode) &&
6865 - (id = file->f_dentry->d_inode->FSPRIVATE)) {
6866 - DbgPrint("Novfs_f_write(0x%p 0x%p 0x%p %d %lld %.*s)\n",
6867 + (id = file->f_dentry->d_inode->i_private)) {
6868 + DbgPrint("novfs_f_write(0x%p 0x%p 0x%p %d %lld %.*s)\n",
6869 file->private_data, inode, id->FileHandle, len, offset,
6870 file->f_dentry->d_name.len,
6871 file->f_dentry->d_name.name);
6872
6873 - if (PageCache &&
6874 + if (novfs_page_cache &&
6875 !(file->f_flags & O_DIRECT) &&
6876 id->CacheFlag && !(file->f_flags & O_WRONLY)) {
6877 -#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
6878 - totalwrite = generic_file_write(file, buf, len, off);
6879 -#else
6880 totalwrite = do_sync_write(file, buf, len, off);
6881 -#endif
6882 } else {
6883 if (file->f_flags & O_APPEND) {
6884 offset = i_size_read(inode);
6885 DbgPrint
6886 - ("Novfs_f_write appending to end %lld %.*s\n",
6887 + ("novfs_f_write appending to end %lld %.*s\n",
6888 offset, file->f_dentry->d_name.len,
6889 file->f_dentry->d_name.name);
6890 }
6891
6892 - session = Scope_Get_SessionId(id->Scope);
6893 + session = novfs_scope_get_sessionId(id->Scope);
6894 if (0 == SC_PRESENT(session)) {
6895 id->Scope =
6896 - Scope_Get_ScopefromPath(file->f_dentry);
6897 - session = Scope_Get_SessionId(id->Scope);
6898 + novfs_get_scope(file->f_dentry);
6899 + session = novfs_scope_get_sessionId(id->Scope);
6900 }
6901
6902 while (len > 0) {
6903 thiswrite = len;
6904 if ((status =
6905 - Novfs_Write_File(file->private_data,
6906 + novfs_write_file(file->private_data,
6907 (unsigned char *)buf,
6908 &thiswrite, &offset,
6909 session)) || !thiswrite) {
6910 totalwrite = status;
6911 break;
6912 }
6913 - DbgPrint("Novfs_f_write thiswrite = 0x%x\n",
6914 + DbgPrint("novfs_f_write thiswrite = 0x%x\n",
6915 thiswrite);
6916 len -= thiswrite;
6917 buf += thiswrite;
6918 @@ -1757,69 +1399,43 @@ ssize_t Novfs_f_write(struct file * file
6919 *off = offset;
6920 }
6921 }
6922 - DbgPrint("Novfs_f_write return = 0x%x\n", totalwrite);
6923 + DbgPrint("novfs_f_write return = 0x%x\n", totalwrite);
6924
6925 return (totalwrite);
6926 }
6927
6928 -int Novfs_f_readdir(struct file *file, void *data, filldir_t fill)
6929 +int novfs_f_readdir(struct file *file, void *data, filldir_t fill)
6930 {
6931 return -EISDIR;
6932 }
6933
6934 -int Novfs_f_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
6935 +int novfs_f_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
6936 unsigned long arg)
6937 {
6938 - DbgPrint("Novfs_f_ioctl: file=0x%p cmd=0x%x arg=0x%p\n", file, cmd,
6939 + DbgPrint("novfs_f_ioctl: file=0x%p cmd=0x%x arg=0x%p\n", file, cmd,
6940 arg);
6941
6942 return -ENOSYS;
6943 }
6944
6945 -/*++======================================================================*/
6946 -int Novfs_f_mmap(struct file *file, struct vm_area_struct *vma)
6947 -/*
6948 - * Arguments:
6949 - *
6950 - * Returns:
6951 - *
6952 - * Abstract:
6953 - *
6954 - * Notes:
6955 - *
6956 - * Environment:
6957 - *
6958 - *========================================================================*/
6959 +int novfs_f_mmap(struct file *file, struct vm_area_struct *vma)
6960 {
6961 int retCode = -EINVAL;
6962
6963 - DbgPrint("Novfs_f_mmap: file=0x%p %.*s\n", file,
6964 + DbgPrint("novfs_f_mmap: file=0x%p %.*s\n", file,
6965 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
6966
6967 retCode = generic_file_mmap(file, vma);
6968
6969 - DbgPrint("Novfs_f_mmap: retCode=0x%x\n", retCode);
6970 + DbgPrint("novfs_f_mmap: retCode=0x%x\n", retCode);
6971 return (retCode);
6972 }
6973
6974 -/*++======================================================================*/
6975 -int Novfs_f_open(struct inode *inode, struct file *file)
6976 -/*
6977 - * Arguments:
6978 - *
6979 - * Returns:
6980 - *
6981 - * Abstract:
6982 - *
6983 - * Notes:
6984 - *
6985 - * Environment:
6986 - *
6987 - *========================================================================*/
6988 +int novfs_f_open(struct inode *inode, struct file *file)
6989 {
6990 - struct entry_info *info = NULL;
6991 + struct novfs_entry_info *info = NULL;
6992 int retCode = -ENOENT;
6993 - session_t session;
6994 + struct novfs_schandle session;
6995 char *path;
6996 struct dentry *parent;
6997 ino_t ino;
6998 @@ -1827,32 +1443,35 @@ int Novfs_f_open(struct inode *inode, st
6999 int errInfo;
7000
7001 DbgPrint
7002 - ("Novfs_f_open: inode=0x%p file=0x%p dentry=0x%p dentry->d_inode=0x%p %.*s\n",
7003 + ("novfs_f_open: inode=0x%p file=0x%p dentry=0x%p dentry->d_inode=0x%p %.*s\n",
7004 inode, file, file->f_dentry, file->f_dentry->d_inode,
7005 file->f_dentry->d_name.len, file->f_dentry->d_name.name);
7006 if (file->f_dentry) {
7007 DbgPrint
7008 - ("Novfs_f_open: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
7009 + ("novfs_f_open: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
7010 file->f_dentry->d_name.len, file->f_dentry->d_name.name,
7011 file->f_flags, file->f_mode, inode->i_mode);
7012 }
7013
7014 - if (inode && inode->FSPRIVATE) {
7015 - id = (struct inode_data *) file->f_dentry->d_inode->FSPRIVATE;
7016 - session = Scope_Get_SessionId(id->Scope);
7017 + if (inode && inode->i_private) {
7018 + id = (struct inode_data *) file->f_dentry->d_inode->i_private;
7019 + session = novfs_scope_get_sessionId(id->Scope);
7020 if (0 == SC_PRESENT(session)) {
7021 - id->Scope = Scope_Get_ScopefromPath(file->f_dentry);
7022 - session = Scope_Get_SessionId(id->Scope);
7023 + id->Scope = novfs_get_scope(file->f_dentry);
7024 + session = novfs_scope_get_sessionId(id->Scope);
7025 }
7026
7027 - info = Novfs_Malloc(sizeof(struct entry_info) + PATH_LENGTH_BUFFER, GFP_KERNEL);
7028 + info = kmalloc(sizeof(struct novfs_entry_info) +
7029 + PATH_LENGTH_BUFFER, GFP_KERNEL);
7030 if (info) {
7031 path =
7032 - Novfs_dget_path(file->f_dentry, info->name,
7033 + novfs_dget_path(file->f_dentry, info->name,
7034 PATH_LENGTH_BUFFER);
7035 if (path) {
7036 if (file->f_flags & O_TRUNC) {
7037 - errInfo = Novfs_Get_File_Info(path, info, &session);
7038 + errInfo =
7039 + novfs_get_file_info(path, info,
7040 + session);
7041
7042 if (errInfo || info->size == 0) {
7043 // clear O_TRUNC flag, bug #275366
7044 @@ -1861,15 +1480,15 @@ int Novfs_f_open(struct inode *inode, st
7045 }
7046 }
7047
7048 - DbgPrint("Novfs_f_open: %s\n", path);
7049 - retCode = Novfs_Open_File(path,
7050 + DbgPrint("novfs_f_open: %s\n", path);
7051 + retCode = novfs_open_file(path,
7052 file->
7053 f_flags & ~O_EXCL,
7054 info,
7055 &file->private_data,
7056 session);
7057
7058 - DbgPrint("Novfs_f_open: 0x%x 0x%p\n", retCode,
7059 + DbgPrint("novfs_f_open: 0x%x 0x%p\n", retCode,
7060 file->private_data);
7061 if (!retCode) {
7062 /*
7063 @@ -1877,28 +1496,31 @@ int Novfs_f_open(struct inode *inode, st
7064 */
7065 //id->FileHandle = file->private_data;
7066 id->CacheFlag =
7067 - Novfs_Get_File_Cache_Flag(path,
7068 + novfs_get_file_cache_flag(path,
7069 session);
7070
7071 - if (!Novfs_Get_File_Info(path, info, &session))
7072 + if (!novfs_get_file_info
7073 + (path, info, session)) {
7074 update_inode(inode, info);
7075 + }
7076
7077 parent = dget_parent(file->f_dentry);
7078
7079 if (parent && parent->d_inode) {
7080 struct inode *dir =
7081 parent->d_inode;
7082 - Novfs_lock_inode_cache(dir);
7083 + novfs_lock_inode_cache(dir);
7084 ino = 0;
7085 - if (Novfs_get_entry
7086 + if (novfs_get_entry
7087 (dir,
7088 &file->f_dentry->d_name,
7089 &ino, info)) {
7090 - ((struct inode_data *)inode->FSPRIVATE)->Flags |=
7091 + ((struct inode_data *) inode->
7092 + i_private)->Flags |=
7093 UPDATE_INODE;
7094 }
7095
7096 - Novfs_unlock_inode_cache(dir);
7097 + novfs_unlock_inode_cache(dir);
7098 }
7099 dput(parent);
7100 }
7101 @@ -1906,25 +1528,12 @@ int Novfs_f_open(struct inode *inode, st
7102 kfree(info);
7103 }
7104 }
7105 - DbgPrint("Novfs_f_open: retCode=0x%x\n", retCode);
7106 + DbgPrint("novfs_f_open: retCode=0x%x\n", retCode);
7107 return (retCode);
7108 }
7109
7110 -/*++======================================================================*/
7111 -int Novfs_flush_mapping(HANDLE Handle, struct address_space *mapping,
7112 - session_t Session)
7113 -/*
7114 - * Arguments:
7115 - *
7116 - * Returns:
7117 - *
7118 - * Abstract:
7119 - *
7120 - * Notes:
7121 - *
7122 - * Environment:
7123 - *
7124 - *========================================================================*/
7125 +int novfs_flush_mapping(void *Handle, struct address_space *mapping,
7126 + struct novfs_schandle Session)
7127 {
7128 struct pagevec pagevec;
7129 unsigned nrpages;
7130 @@ -1944,20 +1553,20 @@ int Novfs_flush_mapping(HANDLE Handle, s
7131 struct page *page;
7132 int i;
7133
7134 - DbgPrint("Novfs_flush_mapping: %u\n", nrpages);
7135 + DbgPrint("novfs_flush_mapping: %u\n", nrpages);
7136
7137 done = 0;
7138 for (i = 0; !rc && (i < nrpages); i++) {
7139 page = pagevec.pages[i];
7140
7141 - DbgPrint("Novfs_flush_mapping: page 0x%p %lu\n",
7142 + DbgPrint("novfs_flush_mapping: page 0x%p %lu\n",
7143 page, page->index);
7144
7145 lock_page(page);
7146 page_cache_get(page);
7147 if (page->mapping == mapping) {
7148 if (clear_page_dirty_for_io(page)) {
7149 - rc = Novfs_Write_Page(Handle,
7150 + rc = novfs_write_page(Handle,
7151 page,
7152 Session);
7153 if (!rc) {
7154 @@ -1978,61 +1587,44 @@ int Novfs_flush_mapping(HANDLE Handle, s
7155 }
7156 } while (!rc && !done);
7157
7158 - DbgPrint("Novfs_flush_mapping: return %d\n", rc);
7159 + DbgPrint("novfs_flush_mapping: return %d\n", rc);
7160
7161 return (rc);
7162 }
7163
7164 -/*++======================================================================*/
7165 -#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
7166 -int Novfs_f_flush(struct file *file)
7167 -#else
7168 -int Novfs_f_flush(struct file *file, fl_owner_t ownid)
7169 -#endif
7170 -/*
7171 - * Arguments:
7172 - *
7173 - * Returns:
7174 - *
7175 - * Abstract:
7176 - *
7177 - * Notes:
7178 - *
7179 - * Environment:
7180 - *
7181 - *========================================================================*/
7182 +int novfs_f_flush(struct file *file, fl_owner_t ownid)
7183 {
7184
7185 int rc = 0;
7186 #ifdef FLUSH
7187 struct inode *inode;
7188 - session_t session;
7189 + struct novfs_schandle session;
7190 struct inode_data *id;
7191
7192 - DbgPrint("Novfs_f_flush: Called from 0x%p\n",
7193 + DbgPrint("novfs_f_flush: Called from 0x%p\n",
7194 __builtin_return_address(0));
7195 if (file->f_dentry && (inode = file->f_dentry->d_inode)
7196 - && (id = file->f_dentry->d_inode->FSPRIVATE)) {
7197 + && (id = file->f_dentry->d_inode->i_private)) {
7198
7199 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
7200 inode = file->f_dentry->d_inode;
7201 DbgPrint
7202 - ("Novfs_f_flush: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
7203 + ("novfs_f_flush: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
7204 file->f_dentry->d_name.len,
7205 file->f_dentry->d_name.name, file->f_flags,
7206 file->f_mode, inode->i_mode);
7207
7208 - session = Scope_Get_SessionId(id->Scope);
7209 + session = novfs_scope_get_sessionId(id->Scope);
7210 if (0 == SC_PRESENT(session)) {
7211 id->Scope =
7212 - Scope_Get_ScopefromPath(file->f_dentry);
7213 - session = Scope_Get_SessionId(id->Scope);
7214 + novfs_get_scope(file->f_dentry);
7215 + session = novfs_scope_get_sessionId(id->Scope);
7216 }
7217
7218 if (inode &&
7219 inode->i_mapping && inode->i_mapping->nrpages) {
7220
7221 - DbgPrint("Novfs_f_flush: %.*s pages=%lu\n",
7222 + DbgPrint("novfs_f_flush: %.*s pages=%lu\n",
7223 file->f_dentry->d_name.len,
7224 file->f_dentry->d_name.name,
7225 inode->i_mapping->nrpages);
7226 @@ -2047,7 +1639,7 @@ int Novfs_f_flush(struct file *file, fl_
7227 d_inode->
7228 i_mapping);
7229 } else {
7230 - rc = Novfs_flush_mapping(file->
7231 + rc = novfs_flush_mapping(file->
7232 private_data,
7233 file->
7234 f_dentry->
7235 @@ -2062,46 +1654,33 @@ int Novfs_f_flush(struct file *file, fl_
7236 return (rc);
7237 }
7238
7239 -/*++======================================================================*/
7240 -int Novfs_f_release(struct inode *inode, struct file *file)
7241 -/*
7242 - * Arguments:
7243 - *
7244 - * Returns:
7245 - *
7246 - * Abstract:
7247 - *
7248 - * Notes:
7249 - *
7250 - * Environment:
7251 - *
7252 - *========================================================================*/
7253 +int novfs_f_release(struct inode *inode, struct file *file)
7254 {
7255 int retCode = -EACCES;
7256 - session_t session;
7257 + struct novfs_schandle session;
7258 struct inode_data *id;
7259
7260 - DbgPrint("Novfs_f_release: path=%.*s handle=%p\n",
7261 + DbgPrint("novfs_f_release: path=%.*s handle=%p\n",
7262 file->f_dentry->d_name.len,
7263 file->f_dentry->d_name.name, file->private_data);
7264
7265 - if (inode && (id = inode->FSPRIVATE)) {
7266 - session = Scope_Get_SessionId(id->Scope);
7267 + if (inode && (id = inode->i_private)) {
7268 + session = novfs_scope_get_sessionId(id->Scope);
7269 if (0 == SC_PRESENT(session)) {
7270 - id->Scope = Scope_Get_ScopefromPath(file->f_dentry);
7271 - session = Scope_Get_SessionId(id->Scope);
7272 + id->Scope = novfs_get_scope(file->f_dentry);
7273 + session = novfs_scope_get_sessionId(id->Scope);
7274 }
7275
7276 if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
7277 DbgPrint
7278 - ("Novfs_f_release: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
7279 + ("novfs_f_release: %.*s f_flags=0%o f_mode=0%o i_mode=0%o\n",
7280 file->f_dentry->d_name.len,
7281 file->f_dentry->d_name.name, file->f_flags,
7282 file->f_mode, inode->i_mode);
7283
7284 if (inode->i_mapping && inode->i_mapping->nrpages) {
7285
7286 - DbgPrint("Novfs_f_release: %.*s pages=%lu\n",
7287 + DbgPrint("novfs_f_release: %.*s pages=%lu\n",
7288 file->f_dentry->d_name.len,
7289 file->f_dentry->d_name.name,
7290 inode->i_mapping->nrpages);
7291 @@ -2111,7 +1690,7 @@ int Novfs_f_release(struct inode *inode,
7292 filemap_fdatawrite(file->f_dentry->
7293 d_inode->i_mapping);
7294 } else {
7295 - Novfs_flush_mapping(file->private_data,
7296 + novfs_flush_mapping(file->private_data,
7297 file->f_dentry->
7298 d_inode->i_mapping,
7299 session);
7300 @@ -2123,40 +1702,27 @@ int Novfs_f_release(struct inode *inode,
7301 invalidate_remote_inode(file->f_dentry->d_inode);
7302 }
7303
7304 - retCode = Novfs_Close_File(file->private_data, session);
7305 + retCode = novfs_close_file(file->private_data, session);
7306 //id->FileHandle = 0;
7307 }
7308 return (retCode);
7309 }
7310
7311 -int Novfs_f_fsync(struct file *file, struct dentry *dentry, int datasync)
7312 +int novfs_f_fsync(struct file *file, struct dentry *dentry, int datasync)
7313 {
7314 return 0;
7315 }
7316
7317 -/*++======================================================================*/
7318 -int Novfs_f_llseek(struct file *file, loff_t offset, int origin)
7319 -/*
7320 - * Arguments:
7321 - *
7322 - * Returns:
7323 - *
7324 - * Abstract:
7325 - *
7326 - * Notes:
7327 - *
7328 - * Environment:
7329 - *
7330 - *========================================================================*/
7331 +int novfs_f_llseek(struct file *file, loff_t offset, int origin)
7332 {
7333 - DbgPrint("Novfs_f_llseek: File=0x%p Name=%.*s offset=%lld origin=%d\n",
7334 + DbgPrint("novfs_f_llseek: File=0x%p Name=%.*s offset=%lld origin=%d\n",
7335 file, file->f_dentry->d_name.len, file->f_dentry->d_name.name,
7336 offset, origin);
7337 return (generic_file_llseek(file, offset, origin));
7338 }
7339
7340 /*++======================================================================*/
7341 -int Novfs_f_lock(struct file *file, int cmd, struct file_lock *lock)
7342 +int novfs_f_lock(struct file *file, int cmd, struct file_lock *lock)
7343 /*
7344 * Arguments:
7345 * "file" - pointer to file structure - contains file handle in "file->private_data"
7346 @@ -2179,24 +1745,23 @@ int Novfs_f_lock(struct file *file, int
7347 * but xtier functions in novfsd "NCFsdLockFile" and "NCFsdUnlockFile"
7348 * receive arguments in u64 type.
7349 *
7350 - * Environment:
7351 *
7352 *========================================================================*/
7353 {
7354 int err_code;
7355
7356 struct inode *inode;
7357 - session_t session;
7358 + struct novfs_schandle session;
7359 struct inode_data *id;
7360 loff_t len;
7361
7362 - DbgPrint("Novfs_f_lock(0x%p): begin in Novfs_f_lock 0x%p\n",
7363 + DbgPrint("novfs_f_lock(0x%p): begin in novfs_f_lock 0x%p\n",
7364 __builtin_return_address(0), file->private_data);
7365 DbgPrint
7366 - ("Novfs_f_lock: cmd = %d, F_GETLK = %d, F_SETLK = %d, F_SETLKW = %d\n",
7367 + ("novfs_f_lock: cmd = %d, F_GETLK = %d, F_SETLK = %d, F_SETLKW = %d\n",
7368 cmd, F_GETLK, F_SETLK, F_SETLKW);
7369 DbgPrint
7370 - ("Novfs_f_lock: lock->fl_start = 0x%llX, lock->fl_end = 0x%llX\n",
7371 + ("novfs_f_lock: lock->fl_start = 0x%llX, lock->fl_end = 0x%llX\n",
7372 lock->fl_start, lock->fl_end);
7373
7374 err_code = -1;
7375 @@ -2209,17 +1774,17 @@ int Novfs_f_lock(struct file *file, int
7376
7377 if (file->f_dentry &&
7378 (inode = file->f_dentry->d_inode) &&
7379 - (id = (struct inode_data *)inode->FSPRIVATE)) {
7380 - DbgPrint("Novfs_f_lock: (0x%p 0x%p %.*s)\n",
7381 + (id = (struct inode_data *) inode->i_private)) {
7382 + DbgPrint("novfs_f_lock: (0x%p 0x%p %.*s)\n",
7383 file->private_data, inode,
7384 file->f_dentry->d_name.len,
7385 file->f_dentry->d_name.name);
7386
7387 - session = Scope_Get_SessionId(id->Scope);
7388 + session = novfs_scope_get_sessionId(id->Scope);
7389 if (0 == SC_PRESENT(session)) {
7390 id->Scope =
7391 - Scope_Get_ScopefromPath(file->f_dentry);
7392 - session = Scope_Get_SessionId(id->Scope);
7393 + novfs_get_scope(file->f_dentry);
7394 + session = novfs_scope_get_sessionId(id->Scope);
7395 }
7396
7397 /* fl_type = F_RDLCK, F_WRLCK, F_UNLCK */
7398 @@ -2230,7 +1795,7 @@ int Novfs_f_lock(struct file *file, int
7399 #endif
7400
7401 err_code =
7402 - Novfs_Set_File_Lock(session,
7403 + novfs_set_file_lock(session,
7404 file->private_data,
7405 lock->fl_type,
7406 lock->fl_start, len);
7407 @@ -2241,7 +1806,7 @@ int Novfs_f_lock(struct file *file, int
7408 case F_SETLKW64:
7409 #endif
7410 err_code =
7411 - Novfs_Set_File_Lock(session,
7412 + novfs_set_file_lock(session,
7413 file->private_data,
7414 lock->fl_type,
7415 lock->fl_start, len);
7416 @@ -2259,16 +1824,16 @@ int Novfs_f_lock(struct file *file, int
7417
7418 default:
7419 printk
7420 - ("<1> novfs in Novfs_f_lock, not implemented cmd = %d\n",
7421 + ("<1> novfs in novfs_f_lock, not implemented cmd = %d\n",
7422 cmd);
7423 DbgPrint
7424 - ("Novfs_f_lock: novfs in Novfs_f_lock, not implemented cmd = %d\n",
7425 + ("novfs_f_lock: novfs in novfs_f_lock, not implemented cmd = %d\n",
7426 cmd);
7427 break;
7428 }
7429 }
7430
7431 - DbgPrint("Novfs_f_lock: lock->fl_type = %u, err_code 0x%X\n",
7432 + DbgPrint("novfs_f_lock: lock->fl_type = %u, err_code 0x%X\n",
7433 lock->fl_type, err_code);
7434
7435 if ((err_code != 0) && (err_code != -1)
7436 @@ -2283,21 +1848,9 @@ int Novfs_f_lock(struct file *file, int
7437 }
7438
7439 /*++======================================================================*/
7440 -static void Novfs_copy_cache_pages(struct address_space *mapping,
7441 +static void novfs_copy_cache_pages(struct address_space *mapping,
7442 struct list_head *pages, int bytes_read,
7443 char *data, struct pagevec *plru_pvec)
7444 -/*
7445 - * Arguments:
7446 - *
7447 - * Returns:
7448 - *
7449 - * Abstract:
7450 - *
7451 - * Notes:
7452 - *
7453 - * Environment:
7454 - *
7455 - *========================================================================*/
7456 {
7457 struct page *page;
7458 char *target;
7459 @@ -2340,30 +1893,17 @@ static void Novfs_copy_cache_pages(struc
7460 return;
7461 }
7462
7463 -/*++======================================================================*/
7464 -int Novfs_a_writepage(struct page *page, struct writeback_control *wbc)
7465 -/*
7466 - * Arguments:
7467 - *
7468 - * Returns:
7469 - *
7470 - * Abstract:
7471 - *
7472 - * Notes:
7473 - *
7474 - * Environment:
7475 - *
7476 - *========================================================================*/
7477 +int novfs_a_writepage(struct page *page, struct writeback_control *wbc)
7478 {
7479 int retCode = -EFAULT;
7480 struct inode *inode = page->mapping->host;
7481 - struct inode_data *id = inode->FSPRIVATE;
7482 + struct inode_data *id = inode->i_private;
7483 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT);
7484 - session_t session;
7485 - struct data_list dlst[2];
7486 + struct novfs_schandle session;
7487 + struct novfs_data_list dlst[2];
7488 size_t len = PAGE_CACHE_SIZE;
7489
7490 - session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
7491 + session = novfs_scope_get_sessionId(((struct inode_data *) inode->i_private)->Scope);
7492
7493 page_cache_get(page);
7494
7495 @@ -2384,7 +1924,7 @@ int Novfs_a_writepage(struct page *page,
7496 len = (size_t) (i_size_read(inode) - pos);
7497 }
7498
7499 - retCode = Novfs_Write_Pages(id->FileHandle, dlst, 2, len, pos, session);
7500 + retCode = novfs_write_pages(id->FileHandle, dlst, 2, len, pos, session);
7501 if (!retCode) {
7502 SetPageUptodate(page);
7503 }
7504 @@ -2395,32 +1935,18 @@ int Novfs_a_writepage(struct page *page,
7505 return (retCode);
7506 }
7507
7508 -/*++======================================================================*/
7509 -int Novfs_a_writepages(struct address_space *mapping,
7510 +int novfs_a_writepages(struct address_space *mapping,
7511 struct writeback_control *wbc)
7512 -/*
7513 - * Arguments:
7514 - *
7515 - * Returns:
7516 - *
7517 - * Abstract:
7518 - *
7519 - * Notes:
7520 - *
7521 - * Environment:
7522 - *
7523 - *========================================================================*/
7524 {
7525 int retCode = 0;
7526 struct inode *inode = mapping->host;
7527 - session_t session;
7528 - HANDLE fh = 0;
7529 + struct novfs_schandle session;
7530 + void *fh = NULL;
7531 struct inode_data *id = NULL;
7532
7533 - int max_page_lookup = MaxIoSize / PAGE_CACHE_SIZE;
7534 + int max_page_lookup = novfs_max_iosize / PAGE_CACHE_SIZE;
7535
7536 - struct data_list *dlist;
7537 - struct data_list *dlptr;
7538 + struct novfs_data_list *dlist, *dlptr;
7539 struct page **pages;
7540
7541 int dlist_idx, i = 0;
7542 @@ -2430,31 +1956,32 @@ int Novfs_a_writepages(struct address_sp
7543
7544 SC_INITIALIZE(session);
7545 DbgPrint
7546 - ("Novfs_a_writepages: inode=0x%p mapping=0x%p wbc=0x%p nr_to_write=%d\n",
7547 + ("novfs_a_writepages: inode=0x%p mapping=0x%p wbc=0x%p nr_to_write=%d\n",
7548 inode, mapping, wbc, wbc->nr_to_write);
7549
7550 if (inode) {
7551 DbgPrint(" Inode=0x%p Ino=%d Id=0x%p\n", inode, inode->i_ino,
7552 - inode->FSPRIVATE);
7553 + inode->i_private);
7554
7555 - if (NULL != (id = inode->FSPRIVATE)) {
7556 + if (NULL != (id = inode->i_private)) {
7557 session =
7558 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
7559 - fh = ((struct inode_data *)inode->FSPRIVATE)->FileHandle;
7560 + novfs_scope_get_sessionId(((struct inode_data *) inode->
7561 + i_private)->Scope);
7562 + fh = ((struct inode_data *) inode->i_private)->FileHandle;
7563 }
7564 }
7565
7566 - dlist = Novfs_Malloc(sizeof(struct data_list) * max_page_lookup, GFP_KERNEL);
7567 + dlist = kmalloc(sizeof(struct novfs_data_list) * max_page_lookup, GFP_KERNEL);
7568 pages =
7569 - Novfs_Malloc(sizeof(struct page *) * max_page_lookup, GFP_KERNEL);
7570 + kmalloc(sizeof(struct page *) * max_page_lookup, GFP_KERNEL);
7571
7572 if (id)
7573 DbgPrint
7574 - ("Novfs_a_writepages: inode=0x%p fh=0x%p dlist=0x%p pages=0x%p %s\n",
7575 + ("novfs_a_writepages: inode=0x%p fh=0x%p dlist=0x%p pages=0x%p %s\n",
7576 inode, fh, dlist, pages, id->Name);
7577 else
7578 DbgPrint
7579 - ("Novfs_a_writepages: inode=0x%p fh=0x%p dlist=0x%p pages=0x%p\n",
7580 + ("novfs_a_writepages: inode=0x%p fh=0x%p dlist=0x%p pages=0x%p\n",
7581 inode, fh, dlist, pages);
7582
7583 if (dlist && pages) {
7584 @@ -2481,13 +2008,13 @@ int Novfs_a_writepages(struct address_sp
7585 dlist_idx = 0;
7586 dlptr = &dlist[1];
7587
7588 - DbgPrint("Novfs_a_writepages1: nr_pages=%d\n",
7589 + DbgPrint("novfs_a_writepages1: nr_pages=%d\n",
7590 nr_pages);
7591 if (!nr_pages) {
7592 memset(pages, 0,
7593 sizeof(struct page *) * max_page_lookup);
7594
7595 - AS_TREE_LOCK(&mapping->tree_lock);
7596 + read_lock_irq(&mapping->tree_lock);
7597
7598 /*
7599 * Need to ask for one less then max_page_lookup or we
7600 @@ -2503,7 +2030,7 @@ int Novfs_a_writepages(struct address_sp
7601 1,
7602 PAGECACHE_TAG_DIRTY);
7603
7604 - DbgPrint("Novfs_a_writepages2: nr_pages=%d\n",
7605 + DbgPrint("novfs_a_writepages2: nr_pages=%d\n",
7606 nr_pages);
7607 /*
7608 * Check to see if there are dirty pages and there is a valid
7609 @@ -2513,7 +2040,7 @@ int Novfs_a_writepages(struct address_sp
7610 set_bit(AS_EIO, &mapping->flags);
7611 done = 1;
7612 DbgPrint
7613 - ("Novfs_a_writepage: set_bit AS_EIO\n");
7614 + ("novfs_a_writepage: set_bit AS_EIO\n");
7615 break;
7616 }
7617
7618 @@ -2521,7 +2048,7 @@ int Novfs_a_writepages(struct address_sp
7619 page_cache_get(pages[i]);
7620 }
7621
7622 - AS_TREE_UNLOCK(&mapping->tree_lock);
7623 + read_unlock_irq(&mapping->tree_lock);
7624
7625 if (nr_pages) {
7626 index = pages[nr_pages - 1]->index + 1;
7627 @@ -2561,7 +2088,7 @@ int Novfs_a_writepages(struct address_sp
7628 */
7629
7630 DbgPrint
7631 - ("Novfs_a_writepages: pos=0x%llx index=%d page->index=%d next_index=%d\n",
7632 + ("novfs_a_writepages: pos=0x%llx index=%d page->index=%d next_index=%d\n",
7633 pos, index, page->index, next_index);
7634
7635 if (page->index != next_index) {
7636 @@ -2588,11 +2115,11 @@ int Novfs_a_writepages(struct address_sp
7637 dlptr[dlist_idx].rwflag = DLREAD;
7638 dlist_idx++;
7639 DbgPrint
7640 - ("Novfs_a_writepages: Add page=0x%p index=0x%lx\n",
7641 + ("novfs_a_writepages: Add page=0x%p index=0x%lx\n",
7642 page, page->index);
7643 }
7644
7645 - DbgPrint("Novfs_a_writepages: dlist_idx=%d\n",
7646 + DbgPrint("novfs_a_writepages: dlist_idx=%d\n",
7647 dlist_idx);
7648 if (dlist_idx) {
7649 tsize = dlist_idx * PAGE_CACHE_SIZE;
7650 @@ -2605,7 +2132,7 @@ int Novfs_a_writepages(struct address_sp
7651 }
7652
7653 retCode =
7654 - Novfs_Write_Pages(fh, dlist, dlist_idx + 1,
7655 + novfs_write_pages(fh, dlist, dlist_idx + 1,
7656 tsize, pos, session);
7657 switch (retCode) {
7658 case 0:
7659 @@ -2630,7 +2157,7 @@ int Novfs_a_writepages(struct address_sp
7660 dlptr[dlist_idx -
7661 1].page);
7662 DbgPrint
7663 - ("Novfs_a_writepages: release page=0x%p index=0x%lx\n",
7664 + ("novfs_a_writepages: release page=0x%p index=0x%lx\n",
7665 dlptr[dlist_idx - 1].page,
7666 ((struct page *)
7667 dlptr[dlist_idx -
7668 @@ -2649,7 +2176,7 @@ int Novfs_a_writepages(struct address_sp
7669 mapping->writeback_index = index;
7670
7671 } else {
7672 - DbgPrint("Novfs_a_writepage: set_bit AS_EIO\n");
7673 + DbgPrint("novfs_a_writepage: set_bit AS_EIO\n");
7674 set_bit(AS_EIO, &mapping->flags);
7675 }
7676 if (dlist)
7677 @@ -2657,25 +2184,12 @@ int Novfs_a_writepages(struct address_sp
7678 if (pages)
7679 kfree(pages);
7680
7681 - DbgPrint("Novfs_a_writepage: retCode=%d\n", retCode);
7682 + DbgPrint("novfs_a_writepage: retCode=%d\n", retCode);
7683 return (0);
7684
7685 }
7686
7687 -/*++======================================================================*/
7688 -int Novfs_a_readpage(struct file *file, struct page *page)
7689 -/*
7690 - * Arguments:
7691 - *
7692 - * Returns:
7693 - *
7694 - * Abstract:
7695 - *
7696 - * Notes:
7697 - *
7698 - * Environment:
7699 - *
7700 - *========================================================================*/
7701 +int novfs_a_readpage(struct file *file, struct page *page)
7702 {
7703 int retCode = 0;
7704 void *pbuf;
7705 @@ -2683,10 +2197,10 @@ int Novfs_a_readpage(struct file *file,
7706 struct dentry *dentry = NULL;
7707 loff_t offset;
7708 size_t len;
7709 - session_t session;
7710 + struct novfs_schandle session;
7711
7712 SC_INITIALIZE(session);
7713 - DbgPrint("Novfs_a_readpage: File=0x%p Name=%.*s Page=0x%p", file,
7714 + DbgPrint("novfs_a_readpage: File=0x%p Name=%.*s Page=0x%p", file,
7715 file->f_dentry->d_name.len, file->f_dentry->d_name.name, page);
7716
7717 dentry = file->f_dentry;
7718 @@ -2702,14 +2216,16 @@ int Novfs_a_readpage(struct file *file,
7719 if (inode) {
7720 DbgPrint(" Inode=0x%p Ino=%d", inode, inode->i_ino);
7721
7722 - if (inode->FSPRIVATE) {
7723 + if (inode->i_private) {
7724 session =
7725 - Scope_Get_SessionId(((struct inode_data *)inode->
7726 - FSPRIVATE)->Scope);
7727 + novfs_scope_get_sessionId(((struct inode_data *) inode->
7728 + i_private)->Scope);
7729 if (0 == SC_PRESENT(session)) {
7730 - ((struct inode_data *)inode->FSPRIVATE)->Scope =
7731 - Scope_Get_ScopefromPath(file->f_dentry);
7732 - session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
7733 + ((struct inode_data *) inode->i_private)->Scope =
7734 + novfs_get_scope(file->f_dentry);
7735 + session =
7736 + novfs_scope_get_sessionId(((struct inode_data *) inode->
7737 + i_private)->Scope);
7738 }
7739 }
7740 }
7741 @@ -2717,7 +2233,7 @@ int Novfs_a_readpage(struct file *file,
7742 DbgPrint("\n");
7743
7744 if (!PageUptodate(page)) {
7745 - struct data_list dlst[2];
7746 + struct novfs_data_list dlst[2];
7747
7748 offset = page->index << PAGE_CACHE_SHIFT;
7749 len = PAGE_CACHE_SIZE;
7750 @@ -2730,10 +2246,10 @@ int Novfs_a_readpage(struct file *file,
7751 dlst[1].len = PAGE_CACHE_SIZE;
7752 dlst[1].rwflag = DLWRITE;
7753
7754 - DbgPrint("Novfs_a_readpage: calling= Novfs_Read_Pages %lld\n",
7755 + DbgPrint("novfs_a_readpage: calling= novfs_Read_Pages %lld\n",
7756 offset);
7757 retCode =
7758 - Novfs_Read_Pages(file->private_data, dlst, 2, &len, &offset,
7759 + novfs_read_pages(file->private_data, dlst, 2, &len, &offset,
7760 session);
7761 if (len && (len < PAGE_CACHE_SIZE)) {
7762 pbuf = kmap_atomic(page, KM_USER0);
7763 @@ -2746,31 +2262,18 @@ int Novfs_a_readpage(struct file *file,
7764 }
7765 unlock_page(page);
7766
7767 - DbgPrint("Novfs_a_readpage: retCode=%d\n", retCode);
7768 + DbgPrint("novfs_a_readpage: retCode=%d\n", retCode);
7769 return (retCode);
7770
7771 }
7772
7773 -/*++======================================================================*/
7774 -int Novfs_a_readpages(struct file *file, struct address_space *mapping,
7775 +int novfs_a_readpages(struct file *file, struct address_space *mapping,
7776 struct list_head *page_lst, unsigned nr_pages)
7777 -/*
7778 - * Arguments:
7779 - *
7780 - * Returns:
7781 - *
7782 - * Abstract:
7783 - *
7784 - * Notes:
7785 - *
7786 - * Environment:
7787 - *
7788 - *========================================================================*/
7789 {
7790 int retCode = 0;
7791 struct inode *inode = NULL;
7792 struct dentry *dentry = NULL;
7793 - session_t session;
7794 + struct novfs_schandle session;
7795 loff_t offset;
7796 size_t len;
7797
7798 @@ -2781,7 +2284,7 @@ int Novfs_a_readpages(struct file *file,
7799 char *rbuf, done = 0;
7800 SC_INITIALIZE(session);
7801
7802 - DbgPrint("Novfs_a_readpages: File=0x%p Name=%.*s Pages=%d\n", file,
7803 + DbgPrint("novfs_a_readpages: File=0x%p Name=%.*s Pages=%d\n", file,
7804 file->f_dentry->d_name.len, file->f_dentry->d_name.name,
7805 nr_pages);
7806
7807 @@ -2798,21 +2301,21 @@ int Novfs_a_readpages(struct file *file,
7808 if (inode) {
7809 DbgPrint(" Inode=0x%p Ino=%d\n", inode, inode->i_ino);
7810
7811 - if (inode->FSPRIVATE) {
7812 + if (inode->i_private) {
7813 session =
7814 - Scope_Get_SessionId(((struct inode_data *)inode->
7815 - FSPRIVATE)->Scope);
7816 + novfs_scope_get_sessionId(((struct inode_data *) inode->
7817 + i_private)->Scope);
7818 if (0 == SC_PRESENT(session)) {
7819 - ((struct inode_data *) inode->FSPRIVATE)->Scope =
7820 - Scope_Get_ScopefromPath(file->f_dentry);
7821 + ((struct inode_data *) inode->i_private)->Scope =
7822 + novfs_get_scope(file->f_dentry);
7823 session =
7824 - Scope_Get_SessionId(((struct inode_data *) inode->
7825 - FSPRIVATE)->Scope);
7826 + novfs_scope_get_sessionId(((struct inode_data *) inode->
7827 + i_private)->Scope);
7828 }
7829 }
7830 }
7831
7832 - rbuf = (char *)Novfs_Malloc(MaxIoSize, GFP_KERNEL);
7833 + rbuf = kmalloc(novfs_max_iosize, GFP_KERNEL);
7834 if (rbuf) {
7835 pagevec_init(&lru_pvec, 0);
7836 for (page_idx = 0; page_idx < nr_pages && !done;) {
7837 @@ -2832,7 +2335,7 @@ int Novfs_a_readpages(struct file *file,
7838 */
7839 list_for_each_entry_reverse(tpage, page_lst, lru) {
7840 if ((next_index != tpage->index) ||
7841 - (len >= MaxIoSize - PAGE_SIZE)) {
7842 + (len >= novfs_max_iosize - PAGE_SIZE)) {
7843 break;
7844 }
7845 len += PAGE_SIZE;
7846 @@ -2840,7 +2343,7 @@ int Novfs_a_readpages(struct file *file,
7847 }
7848
7849 if (len && !done) {
7850 - struct data_list dllst[2];
7851 + struct novfs_data_list dllst[2];
7852
7853 dllst[1].page = NULL;
7854 dllst[1].offset = rbuf;
7855 @@ -2848,12 +2351,12 @@ int Novfs_a_readpages(struct file *file,
7856 dllst[1].rwflag = DLWRITE;
7857
7858 DbgPrint
7859 - ("Novfs_a_readpages: calling Novfs_Read_Pages %lld\n",
7860 + ("novfs_a_readpages: calling novfs_Read_Pages %lld\n",
7861 offset);
7862 - if (!Novfs_Read_Pages
7863 + if (!novfs_read_pages
7864 (file->private_data, dllst, 2, &len,
7865 &offset, session)) {
7866 - Novfs_copy_cache_pages(mapping,
7867 + novfs_copy_cache_pages(mapping,
7868 page_lst, len,
7869 rbuf, &lru_pvec);
7870 page_idx += len >> PAGE_CACHE_SHIFT;
7871 @@ -2886,37 +2389,24 @@ int Novfs_a_readpages(struct file *file,
7872 retCode = -ENOMEM;
7873 }
7874
7875 - DbgPrint("Novfs_a_readpages: retCode=%d\n", retCode);
7876 + DbgPrint("novfs_a_readpages: retCode=%d\n", retCode);
7877 return (retCode);
7878
7879 }
7880
7881 -/*++======================================================================*/
7882 -int Novfs_a_prepare_write(struct file *file, struct page *page, unsigned from,
7883 +int novfs_a_prepare_write(struct file *file, struct page *page, unsigned from,
7884 unsigned to)
7885 -/*
7886 - * Arguments:
7887 - *
7888 - * Returns:
7889 - *
7890 - * Abstract:
7891 - *
7892 - * Notes:
7893 - *
7894 - * Environment:
7895 - *
7896 - *========================================================================*/
7897 {
7898 int retVal = 0;
7899 loff_t offset = (loff_t) page->index << PAGE_CACHE_SHIFT;
7900 size_t len = PAGE_CACHE_SIZE;
7901 - session_t session;
7902 - struct data_list dllst[2];
7903 + struct novfs_schandle session;
7904 + struct novfs_data_list dllst[2];
7905 struct inode *inode = file->f_dentry->d_inode;
7906 SC_INITIALIZE(session);
7907
7908 DbgPrint
7909 - ("Novfs_a_prepare_write: File=0x%p Page=0x%p offset=0x%llx From=%u To=%u filesize=%lld\n",
7910 + ("novfs_a_prepare_write: File=0x%p Page=0x%p offset=0x%llx From=%u To=%u filesize=%lld\n",
7911 file, page, offset, from, to,
7912 i_size_read(file->f_dentry->d_inode));
7913 if (!PageUptodate(page)) {
7914 @@ -2935,12 +2425,18 @@ int Novfs_a_prepare_write(struct file *f
7915 * Get session.
7916 */
7917 if (file->f_dentry && file->f_dentry->d_inode) {
7918 - if (file->f_dentry->d_inode->FSPRIVATE) {
7919 + if (file->f_dentry->d_inode->i_private) {
7920 session =
7921 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
7922 + novfs_scope_get_sessionId(((struct inode_data *)
7923 + inode->
7924 + i_private)->
7925 + Scope);
7926 if (0 == SC_PRESENT(session)) {
7927 - ((struct inode_data *)inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(file->f_dentry);
7928 - session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
7929 + ((struct inode_data *) inode->
7930 + i_private)->Scope =
7931 + novfs_get_scope(file->f_dentry);
7932 + session =
7933 + novfs_scope_get_sessionId(((struct inode_data *) inode->i_private)->Scope);
7934 }
7935 }
7936 }
7937 @@ -2963,9 +2459,9 @@ int Novfs_a_prepare_write(struct file *f
7938 dllst[1].rwflag = DLWRITE;
7939
7940 DbgPrint
7941 - ("Novfs_a_prepare_write: calling Novfs_Read_Pages %lld\n",
7942 + ("novfs_a_prepare_write: calling novfs_Read_Pages %lld\n",
7943 offset);
7944 - Novfs_Read_Pages(file->private_data, dllst, 2,
7945 + novfs_read_pages(file->private_data, dllst, 2,
7946 &len, &offset, session);
7947
7948 /*
7949 @@ -2987,50 +2483,37 @@ int Novfs_a_prepare_write(struct file *f
7950 memset(adr + to, 0, PAGE_CACHE_SIZE - to);
7951 kunmap_atomic(adr, KM_USER0);
7952
7953 - DbgPrint("Novfs_a_prepare_write: memset 0x%p\n", adr);
7954 + DbgPrint("novfs_a_prepare_write: memset 0x%p\n", adr);
7955 }
7956 flush_dcache_page(page);
7957 SetPageUptodate(page);
7958 }
7959 -// DbgPrint("Novfs_a_prepare_write: return %d\n", retVal);
7960 +// DbgPrint("novfs_a_prepare_write: return %d\n", retVal);
7961 return (retVal);
7962 }
7963
7964 -/*++======================================================================*/
7965 -int Novfs_a_commit_write(struct file *file, struct page *page, unsigned offset,
7966 +int novfs_a_commit_write(struct file *file, struct page *page, unsigned offset,
7967 unsigned to)
7968 -/*
7969 - * Arguments:
7970 - *
7971 - * Returns:
7972 - *
7973 - * Abstract:
7974 - *
7975 - * Notes:
7976 - *
7977 - * Environment:
7978 - *
7979 - *========================================================================*/
7980 {
7981 int retCode = 0;
7982 struct inode *inode = page->mapping->host;
7983 loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
7984 - session_t session;
7985 + struct novfs_schandle session;
7986 struct inode_data *id;
7987 - struct data_list dlst[1];
7988 + struct novfs_data_list dlst[1];
7989 size_t len = to - offset;
7990
7991 SC_INITIALIZE(session);
7992
7993 DbgPrint
7994 - ("Novfs_a_commit_write: File=0x%p Page=0x%p offset=0x%x To=%u filesize=%lld\n",
7995 + ("novfs_a_commit_write: File=0x%p Page=0x%p offset=0x%x To=%u filesize=%lld\n",
7996 file, page, offset, to, i_size_read(file->f_dentry->d_inode));
7997 if (file->f_dentry->d_inode
7998 - && (id = file->f_dentry->d_inode->FSPRIVATE)) {
7999 - session = Scope_Get_SessionId(id->Scope);
8000 + && (id = file->f_dentry->d_inode->i_private)) {
8001 + session = novfs_scope_get_sessionId(id->Scope);
8002 if (0 == SC_PRESENT(session)) {
8003 - id->Scope = Scope_Get_ScopefromPath(file->f_dentry);
8004 - session = Scope_Get_SessionId(id->Scope);
8005 + id->Scope = novfs_get_scope(file->f_dentry);
8006 + session = novfs_scope_get_sessionId(id->Scope);
8007 }
8008
8009 /*
8010 @@ -3055,7 +2538,7 @@ int Novfs_a_commit_write(struct file *fi
8011 dlst[0].rwflag = DLREAD;
8012
8013 retCode =
8014 - Novfs_Write_Pages(id->FileHandle, dlst, 1, len, pos,
8015 + novfs_write_pages(id->FileHandle, dlst, 1, len, pos,
8016 session);
8017
8018 } else {
8019 @@ -3067,51 +2550,32 @@ int Novfs_a_commit_write(struct file *fi
8020 }
8021
8022 /*++======================================================================*/
8023 -ssize_t Novfs_a_direct_IO(int rw, struct kiocb * kiocb,
8024 +ssize_t novfs_a_direct_IO(int rw, struct kiocb * kiocb,
8025 const struct iovec * iov,
8026 loff_t offset, unsigned long nr_segs)
8027 /*
8028 - * Arguments:
8029 - *
8030 - * Returns:
8031 - *
8032 - * Abstract:
8033 *
8034 * Notes: This is a dummy function so that we can allow a file
8035 - * to get the direct IO flag set. Novfs_f_read and
8036 - * Novfs_f_write will do the work. Maybe not the best
8037 + * to get the direct IO flag set. novfs_f_read and
8038 + * novfs_f_write will do the work. Maybe not the best
8039 * way to do but it was the easiest to implement.
8040 *
8041 - * Environment:
8042 - *
8043 *========================================================================*/
8044 {
8045 return (-EIO);
8046 }
8047
8048 /*++======================================================================*/
8049 -int Novfs_i_create(struct inode *dir, struct dentry *dentry, int mode,
8050 +int novfs_i_create(struct inode *dir, struct dentry *dentry, int mode,
8051 struct nameidata *nd)
8052 -/*
8053 - * Arguments:
8054 - *
8055 - * Returns:
8056 - *
8057 - * Abstract:
8058 - *
8059 - * Notes:
8060 - *
8061 - * Environment:
8062 - *
8063 - *========================================================================*/
8064 {
8065 char *path, *buf;
8066 - struct entry_info info;
8067 - HANDLE handle;
8068 - session_t session;
8069 + struct novfs_entry_info info;
8070 + void *handle;
8071 + struct novfs_schandle session;
8072 int retCode = -EACCES;
8073
8074 - DbgPrint("Novfs_i_create: mode=0%o flags=0%o %.*s\n", mode,
8075 + DbgPrint("novfs_i_create: mode=0%o flags=0%o %.*s\n", mode,
8076 nd->NDOPENFLAGS, dentry->d_name.len, dentry->d_name.name);
8077
8078 if (IS_ROOT(dentry) || /* Root */
8079 @@ -3122,38 +2586,42 @@ int Novfs_i_create(struct inode *dir, st
8080 }
8081
8082 if (mode | S_IFREG) {
8083 - if (dir->FSPRIVATE) {
8084 + if (dir->i_private) {
8085 session =
8086 - Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->
8087 + novfs_scope_get_sessionId(((struct inode_data *) dir->i_private)->
8088 Scope);
8089 if (0 == SC_PRESENT(session)) {
8090 - ((struct inode_data *) dir->FSPRIVATE)->Scope =
8091 - Scope_Get_ScopefromPath(dentry);
8092 - session = Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->Scope);
8093 + ((struct inode_data *) dir->i_private)->Scope =
8094 + novfs_get_scope(dentry);
8095 + session =
8096 + novfs_scope_get_sessionId(((struct inode_data *) dir->
8097 + i_private)->Scope);
8098 }
8099
8100 - buf =
8101 - (char *)Novfs_Malloc(PATH_LENGTH_BUFFER,
8102 - GFP_KERNEL);
8103 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8104 if (buf) {
8105 path =
8106 - Novfs_dget_path(dentry, buf,
8107 + novfs_dget_path(dentry, buf,
8108 PATH_LENGTH_BUFFER);
8109 if (path) {
8110 retCode =
8111 - Novfs_Open_File(path,
8112 + novfs_open_file(path,
8113 nd->
8114 NDOPENFLAGS |
8115 O_RDWR, &info,
8116 &handle, session);
8117 if (!retCode && handle) {
8118 - Novfs_Close_File(handle,
8119 + novfs_close_file(handle,
8120 session);
8121 - if (!Novfs_i_mknod
8122 + if (!novfs_i_mknod
8123 (dir, dentry,
8124 mode | S_IFREG, 0)) {
8125 if (dentry->d_inode) {
8126 - ((struct inode_data *)dentry->d_inode->FSPRIVATE)->Flags |= UPDATE_INODE;
8127 + ((struct inode_data *)
8128 + dentry->
8129 + d_inode->
8130 + i_private)->
8131 + Flags |= UPDATE_INODE;
8132 }
8133 }
8134 }
8135 @@ -3165,20 +2633,7 @@ int Novfs_i_create(struct inode *dir, st
8136 return (retCode);
8137 }
8138
8139 -/*++======================================================================*/
8140 -void update_inode(struct inode *Inode, struct entry_info *Info)
8141 -/*
8142 - * Arguments:
8143 - *
8144 - * Returns:
8145 - *
8146 - * Abstract:
8147 - *
8148 - * Notes:
8149 - *
8150 - * Environment:
8151 - *
8152 - *========================================================================*/
8153 +void update_inode(struct inode *Inode, struct novfs_entry_info *Info)
8154 {
8155 static char dbuf[128];
8156
8157 @@ -3219,35 +2674,24 @@ void update_inode(struct inode *Inode, s
8158 Inode->i_mtime = Info->mtime;
8159
8160 if (Inode->i_size && Inode->i_sb->s_blocksize) {
8161 - Inode->i_blocks = (unsigned long) (Info->size >> (loff_t) Inode->i_blkbits);
8162 + Inode->i_blocks =
8163 + (unsigned long) (Info->size >> (loff_t) Inode->i_blkbits);
8164 Inode->i_bytes = Info->size & (Inode->i_sb->s_blocksize - 1);
8165
8166 - DbgPrint("update_inode: i_sb->s_blocksize=%d\n", Inode->i_sb->s_blocksize);
8167 + DbgPrint("update_inode: i_sb->s_blocksize=%d\n",
8168 + Inode->i_sb->s_blocksize);
8169 DbgPrint("update_inode: i_blkbits=%d\n", Inode->i_blkbits);
8170 DbgPrint("update_inode: i_blocks=%d\n", Inode->i_blocks);
8171 DbgPrint("update_inode: i_bytes=%d\n", Inode->i_bytes);
8172 }
8173 }
8174
8175 -/*++======================================================================*/
8176 -struct dentry *Novfs_i_lookup(struct inode *dir, struct dentry *dentry,
8177 +struct dentry *novfs_i_lookup(struct inode *dir, struct dentry *dentry,
8178 struct nameidata *nd)
8179 -/*
8180 - * Arguments:
8181 - *
8182 - * Returns:
8183 - *
8184 - * Abstract:
8185 - *
8186 - * Notes:
8187 - *
8188 - * Environment:
8189 - *
8190 - *========================================================================*/
8191 {
8192 struct dentry *retVal = ERR_PTR(-ENOENT);
8193 struct dentry *parent;
8194 - struct entry_info *info = NULL;
8195 + struct novfs_entry_info *info = NULL;
8196 struct inode_data *id;
8197 struct inode *inode = NULL;
8198 uid_t uid = current->euid;
8199 @@ -3255,49 +2699,49 @@ struct dentry *Novfs_i_lookup(struct ino
8200 struct qstr name;
8201 char *buf;
8202
8203 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8204 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8205 if (buf) {
8206 char *path;
8207 - path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
8208 + path = novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
8209 if (path) {
8210 DbgPrint
8211 - ("Novfs_i_lookup: dir 0x%p %d hash %d inode 0x%0p %s\n",
8212 + ("novfs_i_lookup: dir 0x%p %d hash %d inode 0x%0p %s\n",
8213 dir, dir->i_ino, dentry->d_name.hash,
8214 dentry->d_inode, path);
8215 }
8216 kfree(buf);
8217 } else {
8218 DbgPrint
8219 - ("Novfs_i_lookup: dir 0x%p %d name %.*s hash %d inode 0x%0p\n",
8220 + ("novfs_i_lookup: dir 0x%p %d name %.*s hash %d inode 0x%0p\n",
8221 dir, dir->i_ino, dentry->d_name.len, dentry->d_name.name,
8222 dentry->d_name.hash, dentry->d_inode);
8223 }
8224
8225 if ((dentry->d_name.len == 7)
8226 && (0 == strncmp(dentry->d_name.name, " !xover", 7))) {
8227 - dentry->d_op = &Novfs_dentry_operations;
8228 + dentry->d_op = &novfs_dentry_operations;
8229 igrab(dir);
8230 d_add(dentry, dir);
8231 return NULL;
8232 }
8233 if ((dentry->d_name.len == 7)
8234 && (0 == strncmp(dentry->d_name.name, "z!xover", 7))) {
8235 - dentry->d_op = &Novfs_dentry_operations;
8236 + dentry->d_op = &novfs_dentry_operations;
8237 igrab(dir);
8238 d_add(dentry, dir);
8239 return NULL;
8240 }
8241
8242 - if (dir && (id = dir->FSPRIVATE)) {
8243 + if (dir && (id = dir->i_private)) {
8244 retVal = 0;
8245 if (IS_ROOT(dentry)) {
8246 - DbgPrint("Novfs_i_lookup: Root entry=0x%p\n",
8247 - Novfs_root);
8248 - inode = Novfs_root->d_inode;
8249 + DbgPrint("novfs_i_lookup: Root entry=0x%p\n",
8250 + novfs_root);
8251 + inode = novfs_root->d_inode;
8252 return (0);
8253 } else {
8254 info =
8255 - Novfs_Malloc(sizeof(struct entry_info) +
8256 + kmalloc(sizeof(struct novfs_entry_info) +
8257 PATH_LENGTH_BUFFER, GFP_KERNEL);
8258 if (info) {
8259 if (NULL ==
8260 @@ -3305,10 +2749,10 @@ struct dentry *Novfs_i_lookup(struct ino
8261 ERR_PTR(verify_dentry(dentry, 1)))) {
8262 name.name = dentry->d_name.name;
8263 name.len = dentry->d_name.len;
8264 - name.hash = Novfs_internal_hash(&name);
8265 + name.hash = novfs_internal_hash(&name);
8266
8267 - if (Novfs_lock_inode_cache(dir)) {
8268 - if (!Novfs_get_entry
8269 + if (novfs_lock_inode_cache(dir)) {
8270 + if (!novfs_get_entry
8271 (dir, &name, &ino, info)) {
8272 inode =
8273 ilookup(dentry->
8274 @@ -3319,21 +2763,21 @@ struct dentry *Novfs_i_lookup(struct ino
8275 info);
8276 }
8277 }
8278 - Novfs_unlock_inode_cache(dir);
8279 + novfs_unlock_inode_cache(dir);
8280 }
8281
8282 if (!inode && ino) {
8283 - uid = Scope_Get_Uid(id->Scope);
8284 - if (Novfs_lock_inode_cache(dir)) {
8285 - inode = Novfs_get_inode (dentry->d_sb, info->mode, 0, uid, ino, &name);
8286 + uid = novfs_scope_get_uid(id->Scope);
8287 + if (novfs_lock_inode_cache(dir)) {
8288 + inode = novfs_get_inode (dentry->d_sb, info->mode, 0, uid, ino, &name);
8289 if (inode) {
8290 - if (!Novfs_get_entry(dir, &dentry->d_name, &ino, info)) {
8291 + if (!novfs_get_entry(dir, &dentry->d_name, &ino, info)) {
8292 update_inode
8293 (inode,
8294 info);
8295 }
8296 }
8297 - Novfs_unlock_inode_cache
8298 + novfs_unlock_inode_cache
8299 (dir);
8300 }
8301 }
8302 @@ -3343,10 +2787,10 @@ struct dentry *Novfs_i_lookup(struct ino
8303 }
8304
8305 if (!retVal) {
8306 - dentry->d_op = &Novfs_dentry_operations;
8307 + dentry->d_op = &novfs_dentry_operations;
8308 if (inode) {
8309 parent = dget_parent(dentry);
8310 - Novfs_d_add(dentry->d_parent, dentry, inode, 1);
8311 + novfs_d_add(dentry->d_parent, dentry, inode, 1);
8312 dput(parent);
8313 } else {
8314 d_add(dentry, inode);
8315 @@ -3357,42 +2801,29 @@ struct dentry *Novfs_i_lookup(struct ino
8316 kfree(info);
8317
8318 DbgPrint
8319 - ("Novfs_i_lookup: inode=0x%p dentry->d_inode=0x%p return=0x%p\n",
8320 + ("novfs_i_lookup: inode=0x%p dentry->d_inode=0x%p return=0x%p\n",
8321 dir, dentry->d_inode, retVal);
8322
8323 return (retVal);
8324 }
8325
8326 -/*++======================================================================*/
8327 -int Novfs_i_unlink(struct inode *dir, struct dentry *dentry)
8328 -/*
8329 - * Arguments:
8330 - *
8331 - * Returns:
8332 - *
8333 - * Abstract:
8334 - *
8335 - * Notes:
8336 - *
8337 - * Environment:
8338 - *
8339 - *========================================================================*/
8340 +int novfs_i_unlink(struct inode *dir, struct dentry *dentry)
8341 {
8342 int retCode = -ENOENT;
8343 struct inode *inode;
8344 - session_t session;
8345 + struct novfs_schandle session;
8346 char *path, *buf;
8347 uint64_t t64;
8348
8349 - DbgPrint("Novfs_i_unlink: dir=0x%p dir->i_ino=%d %.*s\n", dir,
8350 + DbgPrint("novfs_i_unlink: dir=0x%p dir->i_ino=%d %.*s\n", dir,
8351 dir->i_ino, dentry->d_name.len, dentry->d_name.name);
8352 - DbgPrint("Novfs_i_unlink: IS_ROOT(dentry)=%d\n", IS_ROOT(dentry));
8353 - DbgPrint("Novfs_i_unlink: IS_ROOT(dentry->d_parent)=%d\n",
8354 + DbgPrint("novfs_i_unlink: IS_ROOT(dentry)=%d\n", IS_ROOT(dentry));
8355 + DbgPrint("novfs_i_unlink: IS_ROOT(dentry->d_parent)=%d\n",
8356 IS_ROOT(dentry->d_parent));
8357 - DbgPrint("Novfs_i_unlink: IS_ROOT(dentry->d_parent->d_parent)=%d\n",
8358 + DbgPrint("novfs_i_unlink: IS_ROOT(dentry->d_parent->d_parent)=%d\n",
8359 IS_ROOT(dentry->d_parent->d_parent));
8360 DbgPrint
8361 - ("Novfs_i_unlink: IS_ROOT(dentry->d_parent->d_parent->d_parent)=%d\n",
8362 + ("novfs_i_unlink: IS_ROOT(dentry->d_parent->d_parent->d_parent)=%d\n",
8363 IS_ROOT(dentry->d_parent->d_parent->d_parent));
8364
8365 if (IS_ROOT(dentry) || /* Root */
8366 @@ -3405,44 +2836,46 @@ int Novfs_i_unlink(struct inode *dir, st
8367 inode = dentry->d_inode;
8368 if (inode) {
8369 DbgPrint
8370 - ("Novfs_i_unlink: dir=0x%p dir->i_ino=%d inode=0x%p ino=%d\n",
8371 + ("novfs_i_unlink: dir=0x%p dir->i_ino=%d inode=0x%p ino=%d\n",
8372 dir, dir->i_ino, inode, inode->i_ino);
8373 - if (inode->FSPRIVATE) {
8374 + if (inode->i_private) {
8375 session =
8376 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
8377 + novfs_scope_get_sessionId(((struct inode_data *) inode->
8378 + i_private)->Scope);
8379 if (0 == SC_PRESENT(session)) {
8380 - ((struct inode_data *)inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(dentry);
8381 - session = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
8382 + ((struct inode_data *) inode->i_private)->Scope =
8383 + novfs_get_scope(dentry);
8384 + session =
8385 + novfs_scope_get_sessionId(((struct inode_data *) inode->
8386 + i_private)->Scope);
8387 }
8388
8389 - buf =
8390 - (char *)Novfs_Malloc(PATH_LENGTH_BUFFER,
8391 - GFP_KERNEL);
8392 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8393 if (buf) {
8394 path =
8395 - Novfs_dget_path(dentry, buf,
8396 + novfs_dget_path(dentry, buf,
8397 PATH_LENGTH_BUFFER);
8398 if (path) {
8399 DbgPrint
8400 - ("Novfs_i_unlink: path %s mode 0%o\n",
8401 + ("novfs_i_unlink: path %s mode 0%o\n",
8402 path, inode->i_mode);
8403 if (IS_ROOT(dentry->d_parent->d_parent)) {
8404 - retCode = do_logout(&dentry->d_name, &session);
8405 + retCode = novfs_daemon_logout(&dentry->d_name, &session);
8406 } else {
8407 retCode =
8408 - Novfs_Delete(path,
8409 + novfs_delete(path,
8410 S_ISDIR(inode->
8411 i_mode),
8412 session);
8413 }
8414 if (!retCode || IS_DEADDIR(inode)) {
8415 - Novfs_remove_inode_entry(dir,
8416 + novfs_remove_inode_entry(dir,
8417 &dentry->
8418 d_name,
8419 0);
8420 dentry->d_time = 0;
8421 t64 = 0;
8422 - Scope_Set_UserSpace(&t64, &t64,
8423 + novfs_scope_set_userspace(&t64, &t64,
8424 &t64, &t64);
8425 retCode = 0;
8426 }
8427 @@ -3452,33 +2885,20 @@ int Novfs_i_unlink(struct inode *dir, st
8428 }
8429 }
8430
8431 - DbgPrint("Novfs_i_unlink: retCode 0x%x\n", retCode);
8432 + DbgPrint("novfs_i_unlink: retCode 0x%x\n", retCode);
8433 return (retCode);
8434 }
8435
8436 -/*++======================================================================*/
8437 -int Novfs_i_mkdir(struct inode *dir, struct dentry *dentry, int mode)
8438 -/*
8439 - * Arguments:
8440 - *
8441 - * Returns:
8442 - *
8443 - * Abstract:
8444 - *
8445 - * Notes:
8446 - *
8447 - * Environment:
8448 - *
8449 - *========================================================================*/
8450 +int novfs_i_mkdir(struct inode *dir, struct dentry *dentry, int mode)
8451 {
8452 char *path, *buf;
8453 - session_t session;
8454 + struct novfs_schandle session;
8455 int retCode = 0;
8456 struct inode *inode;
8457 - struct entry_info info;
8458 + struct novfs_entry_info info;
8459 uid_t uid;
8460
8461 - DbgPrint("Novfs_i_mkdir: dir=0x%p ino=%d dentry=0x%p %.*s mode=0%lo\n",
8462 + DbgPrint("novfs_i_mkdir: dir=0x%p ino=%d dentry=0x%p %.*s mode=0%lo\n",
8463 dir, dir->i_ino, dentry, dentry->d_name.len,
8464 dentry->d_name.name, mode);
8465
8466 @@ -3491,46 +2911,53 @@ int Novfs_i_mkdir(struct inode *dir, str
8467
8468 mode |= S_IFDIR;
8469 mode &= (S_IFMT | S_IRWXU);
8470 - if (dir->FSPRIVATE) {
8471 + if (dir->i_private) {
8472 session =
8473 - Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->Scope);
8474 + novfs_scope_get_sessionId(((struct inode_data *) dir->i_private)->Scope);
8475 if (0 == SC_PRESENT(session)) {
8476 - ((struct inode_data *)dir->FSPRIVATE)->Scope =
8477 - Scope_Get_ScopefromPath(dentry);
8478 + ((struct inode_data *) dir->i_private)->Scope =
8479 + novfs_get_scope(dentry);
8480 session =
8481 - Scope_Get_SessionId(((struct inode_data *)dir->FSPRIVATE)->Scope);
8482 + novfs_scope_get_sessionId(((struct inode_data *) dir->i_private)->
8483 + Scope);
8484 }
8485
8486 - uid = Scope_Get_Uid(((struct inode_data *)dir->FSPRIVATE)->Scope);
8487 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8488 + uid = novfs_scope_get_uid(((struct inode_data *) dir->i_private)->Scope);
8489 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8490 if (buf) {
8491 - path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
8492 + path = novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
8493 if (path) {
8494 - DbgPrint("Novfs_i_mkdir: path %s\n", path);
8495 + DbgPrint("novfs_i_mkdir: path %s\n", path);
8496 retCode =
8497 - Novfs_Create(path, S_ISDIR(mode), session);
8498 + novfs_create(path, S_ISDIR(mode), session);
8499 if (!retCode) {
8500 - retCode = Novfs_Get_File_Info(path, &info, &session);
8501 + retCode =
8502 + novfs_get_file_info(path, &info,
8503 + session);
8504 if (!retCode) {
8505 - retCode = Novfs_i_mknod(dir, dentry, mode, 0);
8506 + retCode =
8507 + novfs_i_mknod(dir, dentry,
8508 + mode, 0);
8509 inode = dentry->d_inode;
8510 if (inode) {
8511 update_inode(inode,
8512 &info);
8513 - ((struct inode_data *)inode->FSPRIVATE)->Flags &= ~UPDATE_INODE;
8514 + ((struct inode_data *) inode->
8515 + i_private)->Flags &=
8516 + ~UPDATE_INODE;
8517
8518 dentry->d_time =
8519 jiffies +
8520 - (File_update_timeout
8521 + (novfs_update_timeout
8522 * HZ);
8523
8524 - Novfs_lock_inode_cache
8525 + novfs_lock_inode_cache
8526 (dir);
8527 - if (Novfs_update_entry
8528 + if (novfs_update_entry
8529 (dir,
8530 &dentry->d_name, 0,
8531 &info)) {
8532 - Novfs_add_inode_entry
8533 + novfs_add_inode_entry
8534 (dir,
8535 &dentry->
8536 d_name,
8537 @@ -3538,7 +2965,7 @@ int Novfs_i_mkdir(struct inode *dir, str
8538 i_ino,
8539 &info);
8540 }
8541 - Novfs_unlock_inode_cache
8542 + novfs_unlock_inode_cache
8543 (dir);
8544 }
8545
8546 @@ -3551,39 +2978,13 @@ int Novfs_i_mkdir(struct inode *dir, str
8547
8548 return (retCode);
8549 }
8550 -
8551 -/*++======================================================================*/
8552 -int Novfs_i_rmdir(struct inode *inode, struct dentry *dentry)
8553 -/*
8554 - * Arguments:
8555 - *
8556 - * Returns:
8557 - *
8558 - * Abstract:
8559 - *
8560 - * Notes:
8561 - *
8562 - * Environment:
8563 - *
8564 - *========================================================================*/
8565 +
8566 +int novfs_i_rmdir(struct inode *inode, struct dentry *dentry)
8567 {
8568 - return (Novfs_i_unlink(inode, dentry));
8569 + return (novfs_i_unlink(inode, dentry));
8570 }
8571
8572 -/*++======================================================================*/
8573 -int Novfs_i_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
8574 -/*
8575 - * Arguments:
8576 - *
8577 - * Returns:
8578 - *
8579 - * Abstract:
8580 - *
8581 - * Notes:
8582 - *
8583 - * Environment:
8584 - *
8585 - *========================================================================*/
8586 +int novfs_i_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
8587 {
8588 struct inode *inode = NULL;
8589 int retCode = -EACCES;
8590 @@ -3597,44 +2998,44 @@ int Novfs_i_mknod(struct inode *dir, str
8591 return (-EACCES);
8592 }
8593
8594 - if (((struct inode_data *)dir->FSPRIVATE)) {
8595 - uid = Scope_Get_Uid(((struct inode_data *)dir->FSPRIVATE)->Scope);
8596 + if (((struct inode_data *) dir->i_private)) {
8597 + uid = novfs_scope_get_uid(((struct inode_data *) dir->i_private)->Scope);
8598 if (mode & (S_IFREG | S_IFDIR)) {
8599 inode =
8600 - Novfs_get_inode(dir->i_sb, mode, dev, uid, 0, &dentry->d_name);
8601 + novfs_get_inode(dir->i_sb, mode, dev, uid, 0, &dentry->d_name);
8602 }
8603 }
8604 if (inode) {
8605 - struct entry_info info;
8606 + struct novfs_entry_info info;
8607
8608 - dentry->d_op = &Novfs_dentry_operations;
8609 + dentry->d_op = &novfs_dentry_operations;
8610 parent = dget_parent(dentry);
8611 - Novfs_d_add(parent, dentry, inode, 0);
8612 + novfs_d_add(parent, dentry, inode, 0);
8613 memset(&info, 0, sizeof(info));
8614 info.mode = inode->i_mode;
8615 - Novfs_lock_inode_cache(dir);
8616 - Novfs_add_inode_entry(dir, &dentry->d_name, inode->i_ino,
8617 + novfs_lock_inode_cache(dir);
8618 + novfs_add_inode_entry(dir, &dentry->d_name, inode->i_ino,
8619 &info);
8620 - Novfs_unlock_inode_cache(dir);
8621 + novfs_unlock_inode_cache(dir);
8622
8623 dput(parent);
8624
8625 retCode = 0;
8626 }
8627 - DbgPrint("Novfs_i_mknod: return 0x%x\n", retCode);
8628 + DbgPrint("novfs_i_mknod: return 0x%x\n", retCode);
8629 return retCode;
8630 }
8631
8632 -int Novfs_i_rename(struct inode *odir, struct dentry *od, struct inode *ndir,
8633 +int novfs_i_rename(struct inode *odir, struct dentry *od, struct inode *ndir,
8634 struct dentry *nd)
8635 {
8636 int retCode = -ENOTEMPTY;
8637 char *newpath, *newbuf, *newcon;
8638 char *oldpath, *oldbuf, *oldcon;
8639 struct qstr newname, oldname;
8640 - struct entry_info *info = NULL;
8641 + struct novfs_entry_info *info = NULL;
8642 int oldlen, newlen;
8643 - session_t session;
8644 + struct novfs_schandle session;
8645 ino_t ino;
8646
8647 if (IS_ROOT(od) || /* Root */
8648 @@ -3644,29 +3045,29 @@ int Novfs_i_rename(struct inode *odir, s
8649 return (-EACCES);
8650 }
8651
8652 - DbgPrint("Novfs_i_rename: odir=0x%p ino=%d ndir=0x%p ino=%d\n", odir,
8653 + DbgPrint("novfs_i_rename: odir=0x%p ino=%d ndir=0x%p ino=%d\n", odir,
8654 odir->i_ino, ndir, ndir->i_ino);
8655
8656 - oldbuf = Novfs_Malloc(PATH_LENGTH_BUFFER * 2, GFP_KERNEL);
8657 + oldbuf = kmalloc(PATH_LENGTH_BUFFER * 2, GFP_KERNEL);
8658 newbuf = oldbuf + PATH_LENGTH_BUFFER;
8659 if (oldbuf && newbuf) {
8660 - oldpath = Novfs_dget_path(od, oldbuf, PATH_LENGTH_BUFFER);
8661 - newpath = Novfs_dget_path(nd, newbuf, PATH_LENGTH_BUFFER);
8662 + oldpath = novfs_dget_path(od, oldbuf, PATH_LENGTH_BUFFER);
8663 + newpath = novfs_dget_path(nd, newbuf, PATH_LENGTH_BUFFER);
8664 if (oldpath && newpath) {
8665 oldlen = PATH_LENGTH_BUFFER - (int)(oldpath - oldbuf);
8666 newlen = PATH_LENGTH_BUFFER - (int)(newpath - newbuf);
8667
8668 DbgPrint
8669 - ("Novfs_i_rename: od=0x%p od->inode=0x%p od->inode->i_ino=%d %s\n",
8670 + ("novfs_i_rename: od=0x%p od->inode=0x%p od->inode->i_ino=%d %s\n",
8671 od, od->d_inode, od->d_inode->i_ino, oldpath);
8672 if (nd->d_inode) {
8673 DbgPrint
8674 - ("Novfs_i_rename: nd=0x%p nd->inode=0x%p nd->inode->i_ino=%d %s\n",
8675 + ("novfs_i_rename: nd=0x%p nd->inode=0x%p nd->inode->i_ino=%d %s\n",
8676 nd, nd->d_inode, nd->d_inode->i_ino,
8677 newpath);
8678 } else {
8679 DbgPrint
8680 - ("Novfs_i_rename: nd=0x%p nd->inode=0x%p %s\n",
8681 + ("novfs_i_rename: nd=0x%p nd->inode=0x%p %s\n",
8682 nd, nd->d_inode, newpath);
8683 }
8684
8685 @@ -3675,9 +3076,9 @@ int Novfs_i_rename(struct inode *odir, s
8686 */
8687 newcon = strchr(newpath + 1, '\\');
8688 oldcon = strchr(oldpath + 1, '\\');
8689 - DbgPrint("Novfs_i_rename: newcon=0x%p newpath=0x%p\n",
8690 + DbgPrint("novfs_i_rename: newcon=0x%p newpath=0x%p\n",
8691 newcon, newpath);
8692 - DbgPrint("Novfs_i_rename: oldcon=0x%p oldpath=0x%p\n",
8693 + DbgPrint("novfs_i_rename: oldcon=0x%p oldpath=0x%p\n",
8694 oldcon, oldpath);
8695 retCode = -EXDEV;
8696 if (newcon && oldcon
8697 @@ -3685,8 +3086,8 @@ int Novfs_i_rename(struct inode *odir, s
8698 (int)(oldcon - oldpath))) {
8699 newcon = strchr(newcon + 1, '\\');
8700 oldcon = strchr(oldcon + 1, '\\');
8701 - DbgPrint("Novfs_i_rename2: newcon=0x%p newpath=0x%p\n", newcon, newpath);
8702 - DbgPrint("Novfs_i_rename2: oldcon=0x%p oldpath=0x%p\n", oldcon, oldpath);
8703 + DbgPrint("novfs_i_rename2: newcon=0x%p newpath=0x%p\n", newcon, newpath);
8704 + DbgPrint("novfs_i_rename2: oldcon=0x%p oldpath=0x%p\n", oldcon, oldpath);
8705 if (newcon && oldcon &&
8706 ((int)(newcon - newpath) == (int)(oldcon - oldpath))) {
8707 newname.name = newpath;
8708 @@ -3696,43 +3097,58 @@ int Novfs_i_rename(struct inode *odir, s
8709 oldname.name = oldpath;
8710 oldname.len = (int)(oldcon - oldpath);
8711 oldname.hash = 0;
8712 - if (!Novfs_d_strcmp(&newname, &oldname)) {
8713 + if (!novfs_d_strcmp(&newname, &oldname)) {
8714
8715 if (od->d_inode
8716 - && od->d_inode->FSPRIVATE) {
8717 + && od->d_inode->i_private) {
8718
8719 - if ((nd->d_inode) &&
8720 - (nd->d_inode->FSPRIVATE)) {
8721 - session = Scope_Get_SessionId(((struct inode_data *)ndir->FSPRIVATE)->Scope);
8722 - if (0 == SC_PRESENT(session)) {
8723 - ((struct inode_data *)ndir->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(nd);
8724 - session = Scope_Get_SessionId(((struct inode_data *)ndir->FSPRIVATE)->Scope);
8725 + if (nd->d_inode
8726 + && nd->d_inode->
8727 + i_private) {
8728 + session =
8729 + novfs_scope_get_sessionId
8730 + (((struct inode_data *) ndir->i_private)->Scope);
8731 + if (0 ==
8732 + SC_PRESENT
8733 + (session)) {
8734 + ((struct inode_data *) ndir->i_private)->Scope = novfs_get_scope(nd);
8735 + session
8736 + =
8737 + novfs_scope_get_sessionId
8738 + (((struct inode_data *) ndir->i_private)->Scope);
8739 }
8740
8741 - retCode = Novfs_Delete(newpath, S_ISDIR(nd->d_inode->i_mode), session);
8742 + retCode =
8743 + novfs_delete
8744 + (newpath,
8745 + S_ISDIR
8746 + (nd->
8747 + d_inode->
8748 + i_mode),
8749 + session);
8750 }
8751
8752 - session = Scope_Get_SessionId(((struct inode_data *) ndir->FSPRIVATE)->Scope);
8753 + session = novfs_scope_get_sessionId(((struct inode_data *) ndir->i_private)->Scope);
8754 if (0 == SC_PRESENT(session)) {
8755 - ((struct inode_data *)ndir->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(nd);
8756 - session = Scope_Get_SessionId(((struct inode_data *) ndir->FSPRIVATE)->Scope);
8757 + ((struct inode_data *)ndir->i_private)->Scope = novfs_get_scope(nd);
8758 + session = novfs_scope_get_sessionId(((struct inode_data *) ndir->i_private)->Scope);
8759 }
8760 - retCode = Novfs_Rename_File(S_ISDIR(od->d_inode->i_mode), oldpath, oldlen - 1, newpath, newlen - 1, session);
8761 + retCode = novfs_rename_file(S_ISDIR(od->d_inode->i_mode), oldpath, oldlen - 1, newpath, newlen - 1, session);
8762
8763 if (!retCode) {
8764 - info = (struct entry_info *) oldbuf;
8765 + info = (struct novfs_entry_info *) oldbuf;
8766 od->d_time = 0;
8767 - Novfs_remove_inode_entry(odir, &od->d_name, 0);
8768 - Novfs_remove_inode_entry(ndir, &nd->d_name, 0);
8769 - Novfs_Get_File_Info(newpath, info, &session);
8770 - nd->d_time = jiffies + (File_update_timeout * HZ);
8771 + novfs_remove_inode_entry(odir, &od->d_name, 0);
8772 + novfs_remove_inode_entry(ndir, &nd->d_name, 0);
8773 + novfs_get_file_info(newpath, info, session);
8774 + nd->d_time = jiffies + (novfs_update_timeout * HZ);
8775
8776 if (od->d_inode && od->d_inode->i_ino) {
8777 ino = od->d_inode-> i_ino;
8778 } else {
8779 - ino = (ino_t)atomic_inc_return(&Novfs_Inode_Number);
8780 + ino = (ino_t)atomic_inc_return(&novfs_Inode_Number);
8781 }
8782 - Novfs_add_inode_entry(ndir, &nd->d_name, ino, info);
8783 + novfs_add_inode_entry(ndir, &nd->d_name, ino, info);
8784 }
8785 }
8786 }
8787 @@ -3744,44 +3160,12 @@ int Novfs_i_rename(struct inode *odir, s
8788 if (oldbuf)
8789 kfree(oldbuf);
8790
8791 - DbgPrint("Novfs_i_rename: return %d\n", retCode);
8792 + DbgPrint("novfs_i_rename: return %d\n", retCode);
8793 return (retCode);
8794 }
8795
8796 -/*++======================================================================*/
8797 -int Novfs_i_permission(struct inode *inode, int mask)
8798 -/*
8799 - * Arguments:
8800 - *
8801 - * Returns:
8802 - *
8803 - * Abstract:
8804 - *
8805 - * Notes:
8806 - *
8807 - * Environment:
8808 - *
8809 - *========================================================================*/
8810 -{
8811 - int retCode = 0;
8812 -
8813 - return (retCode);
8814 -}
8815
8816 -/*++======================================================================*/
8817 -int Novfs_i_setattr(struct dentry *dentry, struct iattr *attr)
8818 -/*
8819 - * Arguments:
8820 - *
8821 - * Returns:
8822 - *
8823 - * Abstract:
8824 - *
8825 - * Notes:
8826 - *
8827 - * Environment:
8828 - *
8829 - *========================================================================*/
8830 +int novfs_i_setattr(struct dentry *dentry, struct iattr *attr)
8831 {
8832 char *path, *buf;
8833 struct inode *inode = dentry->d_inode;
8834 @@ -3789,7 +3173,7 @@ int Novfs_i_setattr(struct dentry *dentr
8835 char mtime_buf[32];
8836 char ctime_buf[32];
8837 unsigned int ia_valid = attr->ia_valid;
8838 - session_t session;
8839 + struct novfs_schandle session;
8840 int retVal = 0;
8841 struct iattr mattr;
8842
8843 @@ -3800,20 +3184,21 @@ int Novfs_i_setattr(struct dentry *dentr
8844 return (-EACCES);
8845 }
8846
8847 - if (inode && inode->FSPRIVATE) {
8848 + if (inode && inode->i_private) {
8849 session =
8850 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
8851 + novfs_scope_get_sessionId(((struct inode_data *) inode->i_private)->
8852 + Scope);
8853 if (0 == SC_PRESENT(session)) {
8854 - ((struct inode_data *)inode->FSPRIVATE)->Scope =
8855 - Scope_Get_ScopefromPath(dentry);
8856 + ((struct inode_data *) inode->i_private)->Scope =
8857 + novfs_get_scope(dentry);
8858 session =
8859 - Scope_Get_SessionId(((struct inode_data *) inode->
8860 - FSPRIVATE)->Scope);
8861 + novfs_scope_get_sessionId(((struct inode_data *) inode->
8862 + i_private)->Scope);
8863 }
8864
8865 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8866 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8867 if (buf) {
8868 - path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
8869 + path = novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
8870 if (path) {
8871 strcpy(atime_buf, "Unspecified");
8872 strcpy(mtime_buf, "Unspecified");
8873 @@ -3831,7 +3216,7 @@ int Novfs_i_setattr(struct dentry *dentr
8874 ctime_buf);
8875 }
8876 /* Removed for Bug 132374. jlt */
8877 - DbgPrint("Novfs_i_setattr: %s\n"
8878 + DbgPrint("novfs_i_setattr: %s\n"
8879 " ia_valid: 0x%x\n"
8880 " ia_mode: 0%o\n"
8881 " ia_uid: %d\n"
8882 @@ -3855,19 +3240,28 @@ int Novfs_i_setattr(struct dentry *dentr
8883 ~(ATTR_FILE | ATTR_SIZE);
8884 attr = &mattr;
8885 ia_valid = attr->ia_valid;
8886 -#if 0 // thanks to vfs changes in our tree...
8887 - retVal = Novfs_Truncate_File_Ex(attr->ia_file->private_data, attr->ia_size, session);
8888 +#if 0 // thanks to vfs changes in our tree...
8889 + retVal =
8890 + novfs_trunc_ex(attr->
8891 + ia_file->
8892 + private_data,
8893 + attr->
8894 + ia_size,
8895 + session);
8896 if (!retVal) {
8897 inode->i_size = attr->ia_size;
8898 - ((struct inode_data *)inode->FSPRIVATE)->Flags |= UPDATE_INODE;
8899 + ((struct inode_data *) inode->
8900 + i_private)->Flags |=
8901 + UPDATE_INODE;
8902 }
8903 #endif
8904 }
8905
8906 if (ia_valid
8907 && !(retVal =
8908 - Novfs_Set_Attr(path, attr, session))) {
8909 - ((struct inode_data *)inode->FSPRIVATE)->Flags |= UPDATE_INODE;
8910 + novfs_set_attr(path, attr, session))) {
8911 + ((struct inode_data *) inode->i_private)->
8912 + Flags |= UPDATE_INODE;
8913
8914 if (ia_valid & ATTR_ATIME)
8915 inode->i_atime = attr->ia_atime;
8916 @@ -3886,26 +3280,13 @@ int Novfs_i_setattr(struct dentry *dentr
8917 }
8918 kfree(buf);
8919 }
8920 - DbgPrint("Novfs_i_setattr: return 0x%x\n", retVal);
8921 + DbgPrint("novfs_i_setattr: return 0x%x\n", retVal);
8922
8923 return (retVal);
8924 }
8925
8926 -/*++======================================================================*/
8927 -int Novfs_i_getattr(struct vfsmount *mnt, struct dentry *dentry,
8928 +int novfs_i_getattr(struct vfsmount *mnt, struct dentry *dentry,
8929 struct kstat *kstat)
8930 -/*
8931 - * Arguments:
8932 - *
8933 - * Returns:
8934 - *
8935 - * Abstract:
8936 - *
8937 - * Notes:
8938 - *
8939 - * Environment:
8940 - *
8941 - *========================================================================*/
8942 {
8943 int retCode = 0;
8944 char atime_buf[32];
8945 @@ -3913,32 +3294,32 @@ int Novfs_i_getattr(struct vfsmount *mnt
8946 char ctime_buf[32];
8947 struct inode *inode = dentry->d_inode;
8948
8949 - struct entry_info info;
8950 + struct novfs_entry_info info;
8951 char *path, *buf;
8952 - session_t session;
8953 + struct novfs_schandle session;
8954 struct inode_data *id;
8955
8956 if (!IS_ROOT(dentry) && !IS_ROOT(dentry->d_parent)) {
8957 SC_INITIALIZE(session);
8958 - id = dentry->d_inode->FSPRIVATE;
8959 + id = dentry->d_inode->i_private;
8960
8961 if (id && (id->Flags & UPDATE_INODE)) {
8962 - session = Scope_Get_SessionId(id->Scope);
8963 + session = novfs_scope_get_sessionId(id->Scope);
8964
8965 if (0 == SC_PRESENT(session)) {
8966 - id->Scope = Scope_Get_ScopefromPath(dentry);
8967 - session = Scope_Get_SessionId(id->Scope);
8968 + id->Scope = novfs_get_scope(dentry);
8969 + session = novfs_scope_get_sessionId(id->Scope);
8970 }
8971
8972 - buf =
8973 - (char *)Novfs_Malloc(PATH_LENGTH_BUFFER,
8974 - GFP_KERNEL);
8975 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
8976 if (buf) {
8977 path =
8978 - Novfs_dget_path(dentry, buf,
8979 + novfs_dget_path(dentry, buf,
8980 PATH_LENGTH_BUFFER);
8981 if (path) {
8982 - retCode = Novfs_Get_File_Info(path, &info, &session);
8983 + retCode =
8984 + novfs_get_file_info(path, &info,
8985 + session);
8986 if (!retCode) {
8987 update_inode(inode, &info);
8988 id->Flags &= ~UPDATE_INODE;
8989 @@ -3969,7 +3350,7 @@ int Novfs_i_getattr(struct vfsmount *mnt
8990 ctime_r(&kstat->mtime.tv_sec, mtime_buf);
8991 ctime_r(&kstat->ctime.tv_sec, ctime_buf);
8992
8993 - DbgPrint("Novfs_i_getattr: 0x%x 0x%p <%.*s>\n"
8994 + DbgPrint("novfs_i_getattr: 0x%x 0x%p <%.*s>\n"
8995 " ino: %d\n"
8996 " dev: 0x%x\n"
8997 " mode: 0%o\n"
8998 @@ -3997,24 +3378,11 @@ int Novfs_i_getattr(struct vfsmount *mnt
8999 return (retCode);
9000 }
9001
9002 -/*++======================================================================*/
9003 -int Novfs_i_getxattr(struct dentry *dentry, const char *name, void *buffer,
9004 +int novfs_i_getxattr(struct dentry *dentry, const char *name, void *buffer,
9005 size_t buffer_size)
9006 -/*
9007 - * Arguments:
9008 - *
9009 - * Returns:
9010 - *
9011 - * Abstract:
9012 - *
9013 - * Notes:
9014 - *
9015 - * Environment:
9016 - *
9017 - *========================================================================*/
9018 {
9019 struct inode *inode = dentry->d_inode;
9020 - session_t sessionId;
9021 + struct novfs_schandle sessionId;
9022 char *path, *buf, *bufRead;
9023 ssize_t dataLen;
9024
9025 @@ -4022,44 +3390,53 @@ int Novfs_i_getxattr(struct dentry *dent
9026
9027 SC_INITIALIZE(sessionId);
9028
9029 - DbgPrint("Novfs_i_getxattr: Ian\n"); /*%.*s\n", dentry->d_name.len, dentry->d_name.name); */
9030 + DbgPrint("novfs_i_getxattr: Ian\n"); /*%.*s\n", dentry->d_name.len, dentry->d_name.name); */
9031 DbgPrint
9032 - ("Novfs_i_getxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
9033 + ("novfs_i_getxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
9034 dentry->d_name.len, dentry->d_name.name);
9035 - DbgPrint("Novfs_i_getxattr: name %s\n", name);
9036 - DbgPrint("Novfs_i_getxattr: size %u\n", buffer_size);
9037 + DbgPrint("novfs_i_getxattr: name %s\n", name);
9038 + DbgPrint("novfs_i_getxattr: size %u\n", buffer_size);
9039
9040 - if (inode && inode->FSPRIVATE) {
9041 + if (inode && inode->i_private) {
9042 sessionId =
9043 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
9044 - DbgPrint("Novfs_i_getxattr: SessionId = %u\n", sessionId);
9045 + novfs_scope_get_sessionId(((struct inode_data *) inode->i_private)->
9046 + Scope);
9047 + DbgPrint("novfs_i_getxattr: SessionId = %u\n", sessionId);
9048 //if (0 == sessionId)
9049 if (0 == SC_PRESENT(sessionId)) {
9050 - ((struct inode_data *) inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(dentry);
9051 - sessionId = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
9052 - DbgPrint("Novfs_i_getxattr: SessionId = %u\n",
9053 + ((struct inode_data *) inode->i_private)->Scope =
9054 + novfs_get_scope(dentry);
9055 + sessionId =
9056 + novfs_scope_get_sessionId(((struct inode_data *) inode->
9057 + i_private)->Scope);
9058 + DbgPrint("novfs_i_getxattr: SessionId = %u\n",
9059 sessionId);
9060 }
9061 }
9062
9063 dataLen = 0;
9064 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9065 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9066 if (buf) {
9067 - path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
9068 + path = novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
9069 if (path) {
9070 - bufRead = (char *)Novfs_Malloc(XA_BUFFER, GFP_KERNEL);
9071 + bufRead = kmalloc(XA_BUFFER, GFP_KERNEL);
9072 if (bufRead) {
9073 - retxcode = Novfs_GetX_File_Info(path, name, bufRead, XA_BUFFER, &dataLen, &sessionId);
9074 - DbgPrint("Novfs_i_getxattr: after Novfs_GetX_File_Info retxcode = %d\n", retxcode);
9075 + retxcode =
9076 + novfs_getx_file_info(path, name, bufRead,
9077 + XA_BUFFER, &dataLen,
9078 + sessionId);
9079 + DbgPrint
9080 + ("novfs_i_getxattr: after novfs_GetX_File_Info retxcode = %d\n",
9081 + retxcode);
9082 if (!retxcode) {
9083 - mydump(64, bufRead);
9084 + novfs_dump(64, bufRead);
9085 if (buffer_size != 0) {
9086 if (buffer_size >= dataLen) {
9087 memcpy(buffer, bufRead,
9088 dataLen);
9089 } else {
9090 DbgPrint
9091 - ("Novfs_i_getxattr: (!!!) not enough buffer_size. buffer_size = %d, dataLen = %d\n",
9092 + ("novfs_i_getxattr: (!!!) not enough buffer_size. buffer_size = %d, dataLen = %d\n",
9093 buffer_size,
9094 dataLen);
9095 retxcode = -ERANGE;
9096 @@ -4086,25 +3463,12 @@ int Novfs_i_getxattr(struct dentry *dent
9097 return (dataLen);
9098 }
9099
9100 -/*++======================================================================*/
9101 -int Novfs_i_setxattr(struct dentry *dentry, const char *name, const void *value,
9102 +int novfs_i_setxattr(struct dentry *dentry, const char *name, const void *value,
9103 size_t value_size, int flags)
9104 -/*
9105 - * Arguments:
9106 - *
9107 - * Returns:
9108 - *
9109 - * Abstract:
9110 - *
9111 - * Notes:
9112 - *
9113 - * Environment:
9114 - *
9115 - *========================================================================*/
9116 {
9117
9118 struct inode *inode = dentry->d_inode;
9119 - session_t sessionId;
9120 + struct novfs_schandle sessionId;
9121 char *path, *buf;
9122 unsigned long bytesWritten = 0;
9123 int retError = 0;
9124 @@ -4112,42 +3476,42 @@ int Novfs_i_setxattr(struct dentry *dent
9125
9126 SC_INITIALIZE(sessionId);
9127
9128 - DbgPrint("Novfs_i_setxattr: Ian\n"); /*%.*s\n", dentry->d_name.len, dentry->d_name.name); */
9129 + DbgPrint("novfs_i_setxattr: Ian\n"); /*%.*s\n", dentry->d_name.len, dentry->d_name.name); */
9130 DbgPrint
9131 - ("Novfs_i_setxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
9132 + ("novfs_i_setxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
9133 dentry->d_name.len, dentry->d_name.name);
9134 - DbgPrint("Novfs_i_setxattr: name %s\n", name);
9135 - DbgPrint("Novfs_i_setxattr: value_size %u\n", value_size);
9136 - DbgPrint("Novfs_i_setxattr: flags %d\n", flags);
9137 + DbgPrint("novfs_i_setxattr: name %s\n", name);
9138 + DbgPrint("novfs_i_setxattr: value_size %u\n", value_size);
9139 + DbgPrint("novfs_i_setxattr: flags %d\n", flags);
9140
9141 - if (inode && inode->FSPRIVATE) {
9142 + if (inode && inode->i_private) {
9143 sessionId =
9144 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->
9145 + novfs_scope_get_sessionId(((struct inode_data *) inode->i_private)->
9146 Scope);
9147 - DbgPrint("Novfs_i_setxattr: SessionId = %u\n", sessionId);
9148 + DbgPrint("novfs_i_setxattr: SessionId = %u\n", sessionId);
9149 //if (0 == sessionId)
9150 if (0 == SC_PRESENT(sessionId)) {
9151 - ((struct inode_data *)inode->FSPRIVATE)->Scope =
9152 - Scope_Get_ScopefromPath(dentry);
9153 + ((struct inode_data *) inode->i_private)->Scope =
9154 + novfs_get_scope(dentry);
9155 sessionId =
9156 - Scope_Get_SessionId(((struct inode_data *)inode->
9157 - FSPRIVATE)->Scope);
9158 - DbgPrint("Novfs_i_setxattr: SessionId = %u\n",
9159 + novfs_scope_get_sessionId(((struct inode_data *) inode->
9160 + i_private)->Scope);
9161 + DbgPrint("novfs_i_setxattr: SessionId = %u\n",
9162 sessionId);
9163 }
9164 }
9165
9166 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9167 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9168 if (buf) {
9169 - path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
9170 + path = novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
9171 if (path) {
9172 retxcode =
9173 - Novfs_SetX_File_Info(path, name, value, value_size,
9174 + novfs_setx_file_info(path, name, value, value_size,
9175 &bytesWritten, flags,
9176 - &sessionId);
9177 + sessionId);
9178 if (!retxcode) {
9179 DbgPrint
9180 - ("Novfs_i_setxattr: bytesWritten = %u\n",
9181 + ("novfs_i_setxattr: bytesWritten = %u\n",
9182 bytesWritten);
9183 }
9184 }
9185 @@ -4164,53 +3528,59 @@ int Novfs_i_setxattr(struct dentry *dent
9186 return (retError);
9187 }
9188
9189 -int Novfs_i_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
9190 +int novfs_i_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
9191 {
9192 struct inode *inode = dentry->d_inode;
9193 - session_t sessionId;
9194 + struct novfs_schandle sessionId;
9195 char *path, *buf, *bufList;
9196 ssize_t dataLen;
9197 -
9198 int retxcode = 0;
9199
9200 SC_INITIALIZE(sessionId);
9201
9202 - DbgPrint("Novfs_i_listxattr: Ian\n"); //%.*s\n", dentry->d_name.len, dentry->d_name.name);
9203 + DbgPrint("novfs_i_listxattr: Ian\n"); //%.*s\n", dentry->d_name.len, dentry->d_name.name);
9204 DbgPrint
9205 - ("Novfs_i_listxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
9206 + ("novfs_i_listxattr: dentry->d_name.len %u, dentry->d_name.name %s\n",
9207 dentry->d_name.len, dentry->d_name.name);
9208 - DbgPrint("Novfs_i_listxattr: size %u\n", buffer_size);
9209 + DbgPrint("novfs_i_listxattr: size %u\n", buffer_size);
9210
9211 - if (inode && inode->FSPRIVATE) {
9212 + if (inode && inode->i_private) {
9213 sessionId =
9214 - Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)-> Scope);
9215 - DbgPrint("Novfs_i_listxattr: SessionId = %u\n", sessionId);
9216 + novfs_scope_get_sessionId(((struct inode_data *) inode->i_private)->
9217 + Scope);
9218 + DbgPrint("novfs_i_listxattr: SessionId = %u\n", sessionId);
9219 //if (0 == sessionId)
9220 if (0 == SC_PRESENT(sessionId)) {
9221 - ((struct inode_data *)inode->FSPRIVATE)->Scope = Scope_Get_ScopefromPath(dentry);
9222 - sessionId = Scope_Get_SessionId(((struct inode_data *)inode->FSPRIVATE)->Scope);
9223 - DbgPrint("Novfs_i_listxattr: SessionId = %u\n",
9224 + ((struct inode_data *) inode->i_private)->Scope =
9225 + novfs_get_scope(dentry);
9226 + sessionId =
9227 + novfs_scope_get_sessionId(((struct inode_data *) inode->
9228 + i_private)->Scope);
9229 + DbgPrint("novfs_i_listxattr: SessionId = %u\n",
9230 sessionId);
9231 }
9232 }
9233
9234 dataLen = 0;
9235 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9236 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9237 if (buf) {
9238 - path = Novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
9239 + path = novfs_dget_path(dentry, buf, PATH_LENGTH_BUFFER);
9240 if (path) {
9241 - bufList = (char *)Novfs_Malloc(XA_BUFFER, GFP_KERNEL);
9242 + bufList = kmalloc(XA_BUFFER, GFP_KERNEL);
9243 if (bufList) {
9244 - retxcode = Novfs_ListX_File_Info(path, bufList, XA_BUFFER, &dataLen, &sessionId);
9245 + retxcode =
9246 + novfs_listx_file_info(path, bufList,
9247 + XA_BUFFER, &dataLen,
9248 + sessionId);
9249
9250 - mydump(64, bufList);
9251 + novfs_dump(64, bufList);
9252 if (buffer_size != 0) {
9253 if (buffer_size >= dataLen) {
9254 memcpy(buffer, bufList,
9255 dataLen);
9256 } else {
9257 DbgPrint
9258 - ("Novfs_i_listxattr: (!!!) not enough buffer_size. buffer_size = %d, dataLen = %d\n",
9259 + ("novfs_i_listxattr: (!!!) not enough buffer_size. buffer_size = %d, dataLen = %d\n",
9260 buffer_size, dataLen);
9261 retxcode = -1;
9262 }
9263 @@ -4236,120 +3606,92 @@ int Novfs_i_listxattr(struct dentry *den
9264 return (dataLen);
9265 }
9266
9267 -int Novfs_i_revalidate(struct dentry *dentry)
9268 +int novfs_i_revalidate(struct dentry *dentry)
9269 {
9270
9271 - DbgPrint("Novfs_i_revalidate: name %.*s\n", dentry->d_name.len,
9272 + DbgPrint("novfs_i_revalidate: name %.*s\n", dentry->d_name.len,
9273 dentry->d_name.name);
9274
9275 return (0);
9276 }
9277
9278 -void Novfs_read_inode(struct inode *inode)
9279 +void novfs_read_inode(struct inode *inode)
9280 {
9281 - DbgPrint("Novfs_read_inode: 0x%p %d\n", inode, inode->i_ino);
9282 + DbgPrint("novfs_read_inode: 0x%p %d\n", inode, inode->i_ino);
9283 }
9284
9285 -void Novfs_write_inode(struct inode *inode)
9286 +void novfs_write_inode(struct inode *inode)
9287 {
9288 - DbgPrint("Novfs_write_inode: Inode=0x%p Ino=%d\n", inode, inode->i_ino);
9289 + DbgPrint("novfs_write_inode: Inode=0x%p Ino=%d\n", inode, inode->i_ino);
9290 }
9291
9292 -int Novfs_notify_change(struct dentry *dentry, struct iattr *attr)
9293 +int novfs_notify_change(struct dentry *dentry, struct iattr *attr)
9294 {
9295 struct inode *inode = dentry->d_inode;
9296
9297 DbgPrint
9298 - ("Novfs_notify_change: Dentry=0x%p Name=%.*s Inode=0x%p Ino=%d ia_valid=0x%x\n",
9299 + ("novfs_notify_change: Dentry=0x%p Name=%.*s Inode=0x%p Ino=%d ia_valid=0x%x\n",
9300 dentry, dentry->d_name.len, dentry->d_name.name, inode,
9301 inode->i_ino, attr->ia_valid);
9302 return (0);
9303 }
9304
9305 -/*++======================================================================*/
9306 -void Novfs_clear_inode(struct inode *inode)
9307 -/*
9308 - * Arguments: sb - pointer to the super_block
9309 - * buf - pointer to the statfs buffer
9310 - *
9311 - * Returns: 0
9312 - *
9313 - * Abstract: Called when statfs(2) system called.
9314 - *
9315 - * Notes:
9316 - *
9317 - * Environment: Superblock operation
9318 - *
9319 - *========================================================================*/
9320 +void novfs_clear_inode(struct inode *inode)
9321 {
9322 InodeCount--;
9323
9324 - if (inode->FSPRIVATE) {
9325 - struct inode_data *id = inode->FSPRIVATE;
9326 + if (inode->i_private) {
9327 + struct inode_data *id = inode->i_private;
9328
9329 DbgPrint
9330 - ("Novfs_clear_inode: inode=0x%p ino=%d Scope=0x%p Name=%s\n",
9331 + ("novfs_clear_inode: inode=0x%p ino=%d Scope=0x%p Name=%s\n",
9332 inode, inode->i_ino, id->Scope, id->Name);
9333
9334 - Novfs_free_inode_cache(inode);
9335 + novfs_free_inode_cache(inode);
9336
9337 down(&InodeList_lock);
9338 list_del(&id->IList);
9339 up(&InodeList_lock);
9340
9341 - kfree(inode->FSPRIVATE);
9342 - inode->FSPRIVATE = NULL;
9343 + kfree(inode->i_private);
9344 + inode->i_private = NULL;
9345
9346 remove_inode_hash(inode);
9347
9348 } else {
9349 - DbgPrint("Novfs_clear_inode: inode=0x%p ino=%d\n", inode,
9350 + DbgPrint("novfs_clear_inode: inode=0x%p ino=%d\n", inode,
9351 inode->i_ino);
9352 }
9353 }
9354
9355 -/*++======================================================================*/
9356 -int Novfs_show_options(struct seq_file *s, struct vfsmount *m)
9357 -/*
9358 - * Arguments:
9359 - *
9360 - * Returns: 0
9361 - *
9362 - * Abstract: Called when /proc/mounts is read
9363 - *
9364 - * Notes:
9365 - *
9366 - * Environment:
9367 - *
9368 - *========================================================================*/
9369 +/* Called when /proc/mounts is read */
9370 +int novfs_show_options(struct seq_file *s, struct vfsmount *m)
9371 {
9372 char *buf, *path, *tmp;
9373
9374 - buf = (char *)Novfs_Malloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9375 + buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
9376 if (buf) {
9377 struct path my_path;
9378 my_path.mnt = m;
9379 my_path.dentry = m->mnt_root;
9380 path = d_path(&my_path, buf, PATH_LENGTH_BUFFER);
9381 if (path) {
9382 - if (!Novfs_CurrentMount
9383 - || (Novfs_CurrentMount
9384 - && strcmp(Novfs_CurrentMount, path))) {
9385 - DbgPrint("Novfs_show_options: %.*s %.*s %s\n",
9386 + if (!novfs_current_mnt
9387 + || (novfs_current_mnt
9388 + && strcmp(novfs_current_mnt, path))) {
9389 + DbgPrint("novfs_show_options: %.*s %.*s %s\n",
9390 m->mnt_root->d_name.len,
9391 m->mnt_root->d_name.name,
9392 m->mnt_mountpoint->d_name.len,
9393 m->mnt_mountpoint->d_name.name, path);
9394 - tmp =
9395 - (char *)Novfs_Malloc(PATH_LENGTH_BUFFER -
9396 + tmp = kmalloc(PATH_LENGTH_BUFFER -
9397 (int)(path - buf),
9398 GFP_KERNEL);
9399 if (tmp) {
9400 strcpy(tmp, path);
9401 - path = Novfs_CurrentMount;
9402 - Novfs_CurrentMount = tmp;
9403 - Daemon_SetMountPoint
9404 - (Novfs_CurrentMount);
9405 + path = novfs_current_mnt;
9406 + novfs_current_mnt = tmp;
9407 + novfs_daemon_set_mnt_point(novfs_current_mnt);
9408
9409 if (path) {
9410 kfree(path);
9411 @@ -4362,37 +3704,17 @@ int Novfs_show_options(struct seq_file *
9412 return (0);
9413 }
9414
9415 -/*++======================================================================*/
9416 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
9417 -int Novfs_statfs(struct dentry *de, struct kstatfs *buf)
9418 -#else
9419 -int Novfs_statfs(struct super_block *sb, struct kstatfs *buf)
9420 -#endif
9421 -/*
9422 - * Arguments: sb - pointer to the super_block
9423 - * buf - pointer to the statfs buffer
9424 - *
9425 - * Returns: 0
9426 - *
9427 - * Abstract: Called when statfs(2) system called.
9428 - *
9429 - * Notes:
9430 - *
9431 - * Environment: Superblock operation
9432 - *
9433 - *========================================================================*/
9434 +/* Called when statfs(2) system called. */
9435 +int novfs_statfs(struct dentry *de, struct kstatfs *buf)
9436 {
9437 uint64_t td, fd, te, fe;
9438 -
9439 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
9440 struct super_block *sb = de->d_sb;
9441 -#endif
9442
9443 - DbgPrint("Novfs_statfs:\n");
9444 + DbgPrint("novfs_statfs:\n");
9445
9446 td = fd = te = fe = 0;
9447
9448 - Scope_Get_UserSpace(&td, &fd, &te, &fe);
9449 + novfs_scope_get_userspace(&td, &fd, &te, &fe);
9450
9451 DbgPrint("td=%llu\n", td);
9452 DbgPrint("fd=%llu\n", fd);
9453 @@ -4430,7 +3752,7 @@ int Novfs_statfs(struct super_block *sb,
9454 return 0;
9455 }
9456
9457 -struct inode *Novfs_get_inode(struct super_block *sb, int mode, int dev,
9458 +struct inode *novfs_get_inode(struct super_block *sb, int mode, int dev,
9459 uid_t Uid, ino_t ino, struct qstr *name)
9460 {
9461 struct inode *inode = new_inode(sb);
9462 @@ -4440,37 +3762,32 @@ struct inode *Novfs_get_inode(struct sup
9463 inode->i_mode = mode;
9464 inode->i_uid = Uid;
9465 inode->i_gid = 0;
9466 - /* bug # 340510 tells us to comment this out... */
9467 -//#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
9468 -// inode->i_blksize = sb->s_blocksize;
9469 -//#else
9470 -// inode->i_sb->s_blocksize = sb->s_blocksize;
9471 -//#endif
9472 + inode->i_sb->s_blocksize = sb->s_blocksize;
9473 inode->i_blkbits = sb->s_blocksize_bits;
9474 inode->i_blocks = 0;
9475 inode->i_rdev = 0;
9476 - inode->i_ino = (ino) ? ino : (ino_t)atomic_inc_return(&Novfs_Inode_Number);
9477 - if (PageCache) {
9478 - inode->i_mapping->a_ops = &Novfs_aops;
9479 + inode->i_ino = (ino) ? ino : (ino_t)atomic_inc_return(&novfs_Inode_Number);
9480 + if (novfs_page_cache) {
9481 + inode->i_mapping->a_ops = &novfs_aops;
9482 } else {
9483 - inode->i_mapping->a_ops = &Novfs_nocache_aops;
9484 + inode->i_mapping->a_ops = &novfs_nocache_aops;
9485 }
9486 - inode->i_mapping->backing_dev_info = &Novfs_backing_dev_info;
9487 + inode->i_mapping->backing_dev_info = &novfs_backing_dev_info;
9488 inode->i_atime.tv_sec = 0;
9489 inode->i_atime.tv_nsec = 0;
9490 inode->i_mtime = inode->i_ctime = inode->i_atime;
9491
9492 - DbgPrint("Novfs_get_inode: Inode=0x%p I_ino=%d len=%d\n", inode,
9493 + DbgPrint("novfs_get_inode: Inode=0x%p I_ino=%d len=%d\n", inode,
9494 inode->i_ino, name->len);
9495
9496 if (NULL !=
9497 - (inode->FSPRIVATE =
9498 - Novfs_Malloc(sizeof(struct inode_data) + name->len,
9499 + (inode->i_private =
9500 + kmalloc(sizeof(struct inode_data) + name->len,
9501 GFP_KERNEL))) {
9502 struct inode_data *id;
9503 - id = inode->FSPRIVATE;
9504 + id = inode->i_private;
9505
9506 - DbgPrint("Novfs_get_inode: FSPRIVATE 0x%p\n", id);
9507 + DbgPrint("novfs_get_inode: i_private 0x%p\n", id);
9508
9509 id->Scope = NULL;
9510 id->Flags = 0;
9511 @@ -4494,7 +3811,7 @@ struct inode *Novfs_get_inode(struct sup
9512 memcpy(id->Name, name->name, name->len);
9513 id->Name[name->len] = '\0';
9514
9515 - DbgPrint("Novfs_get_inode: name %s\n", id->Name);
9516 + DbgPrint("novfs_get_inode: name %s\n", id->Name);
9517 }
9518
9519 insert_inode_hash(inode);
9520 @@ -4502,19 +3819,15 @@ struct inode *Novfs_get_inode(struct sup
9521 switch (mode & S_IFMT) {
9522
9523 case S_IFREG:
9524 - inode->i_op = &Novfs_file_inode_operations;
9525 - inode->i_fop = &Novfs_file_operations;
9526 + inode->i_op = &novfs_file_inode_operations;
9527 + inode->i_fop = &novfs_file_operations;
9528 break;
9529
9530 case S_IFDIR:
9531 - inode->i_op = &Novfs_inode_operations;
9532 - inode->i_fop = &Novfs_dir_operations;
9533 -// Again bug #340510
9534 -//#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
9535 -// inode->i_blksize = 0;
9536 -//#else
9537 -// inode->i_sb->s_blocksize = 0;
9538 -//#endif
9539 + inode->i_op = &novfs_inode_operations;
9540 + inode->i_fop = &novfs_dir_operations;
9541 +
9542 + inode->i_sb->s_blocksize = 0;
9543 inode->i_blkbits = 0;
9544 break;
9545
9546 @@ -4523,63 +3836,63 @@ struct inode *Novfs_get_inode(struct sup
9547 break;
9548 }
9549
9550 - DbgPrint("Novfs_get_inode: size=%lld\n", inode->i_size);
9551 - DbgPrint("Novfs_get_inode: mode=0%o\n", inode->i_mode);
9552 - DbgPrint("Novfs_get_inode: i_sb->s_blocksize=%d\n",
9553 + DbgPrint("novfs_get_inode: size=%lld\n", inode->i_size);
9554 + DbgPrint("novfs_get_inode: mode=0%o\n", inode->i_mode);
9555 + DbgPrint("novfs_get_inode: i_sb->s_blocksize=%d\n",
9556 inode->i_sb->s_blocksize);
9557 - DbgPrint("Novfs_get_inode: i_blkbits=%d\n", inode->i_blkbits);
9558 - DbgPrint("Novfs_get_inode: i_blocks=%d\n", inode->i_blocks);
9559 - DbgPrint("Novfs_get_inode: i_bytes=%d\n", inode->i_bytes);
9560 + DbgPrint("novfs_get_inode: i_blkbits=%d\n", inode->i_blkbits);
9561 + DbgPrint("novfs_get_inode: i_blocks=%d\n", inode->i_blocks);
9562 + DbgPrint("novfs_get_inode: i_bytes=%d\n", inode->i_bytes);
9563 }
9564
9565 - DbgPrint("Novfs_get_inode: 0x%p %d\n", inode, inode->i_ino);
9566 + DbgPrint("novfs_get_inode: 0x%p %d\n", inode, inode->i_ino);
9567 return (inode);
9568 }
9569
9570 -int Novfs_fill_super(struct super_block *SB, void *Data, int Silent)
9571 +int novfs_fill_super(struct super_block *SB, void *Data, int Silent)
9572 {
9573 struct inode *inode;
9574 struct dentry *server, *tree;
9575 struct qstr name;
9576 - struct entry_info info;
9577 + struct novfs_entry_info info;
9578
9579 SB->s_blocksize = PAGE_CACHE_SIZE;
9580 SB->s_blocksize_bits = PAGE_CACHE_SHIFT;
9581 SB->s_maxbytes = 0xFFFFFFFFFFFFFFFFULL; /* Max file size */
9582 - SB->s_op = &Novfs_ops;
9583 + SB->s_op = &novfs_ops;
9584 SB->s_flags |= (MS_NODIRATIME | MS_NODEV | MS_POSIXACL);
9585 SB->s_magic = NOVFS_MAGIC;
9586
9587 name.len = 1;
9588 name.name = "/";
9589
9590 - inode = Novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
9591 + inode = novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
9592 if (!inode) {
9593 return (-ENOMEM);
9594 }
9595
9596 - Novfs_root = d_alloc_root(inode);
9597 + novfs_root = d_alloc_root(inode);
9598
9599 - if (!Novfs_root) {
9600 + if (!novfs_root) {
9601 iput(inode);
9602 return (-ENOMEM);
9603 }
9604 - Novfs_root->d_time = jiffies + (File_update_timeout * HZ);
9605 + novfs_root->d_time = jiffies + (novfs_update_timeout * HZ);
9606
9607 inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME;
9608
9609 - SB->s_root = Novfs_root;
9610 + SB->s_root = novfs_root;
9611
9612 - DbgPrint("Novfs_fill_super: root 0x%p\n", Novfs_root);
9613 + DbgPrint("novfs_fill_super: root 0x%p\n", novfs_root);
9614
9615 - if (Novfs_root) {
9616 - Novfs_root->d_op = &Novfs_dentry_operations;
9617 + if (novfs_root) {
9618 + novfs_root->d_op = &novfs_dentry_operations;
9619
9620 name.name = SERVER_DIRECTORY_NAME;
9621 name.len = strlen(SERVER_DIRECTORY_NAME);
9622 - name.hash = Novfs_internal_hash(&name);
9623 + name.hash = novfs_internal_hash(&name);
9624
9625 - inode = Novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
9626 + inode = novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
9627 if (inode) {
9628 info.mode = inode->i_mode;
9629 info.namelength = 0;
9630 @@ -4590,14 +3903,14 @@ int Novfs_fill_super(struct super_block
9631 inode->i_ctime = info.ctime =
9632 inode->i_mtime = info.mtime = CURRENT_TIME;
9633
9634 - server = d_alloc(Novfs_root, &name);
9635 + server = d_alloc(novfs_root, &name);
9636 if (server) {
9637 - server->d_op = &Novfs_dentry_operations;
9638 + server->d_op = &novfs_dentry_operations;
9639 server->d_time = 0xffffffff;
9640 d_add(server, inode);
9641 - DbgPrint("Novfs_fill_super: d_add %s 0x%p\n",
9642 + DbgPrint("novfs_fill_super: d_add %s 0x%p\n",
9643 SERVER_DIRECTORY_NAME, server);
9644 - Novfs_add_inode_entry(Novfs_root->d_inode,
9645 + novfs_add_inode_entry(novfs_root->d_inode,
9646 &name, inode->i_ino,
9647 &info);
9648 }
9649 @@ -4605,9 +3918,9 @@ int Novfs_fill_super(struct super_block
9650
9651 name.name = TREE_DIRECTORY_NAME;
9652 name.len = strlen(TREE_DIRECTORY_NAME);
9653 - name.hash = Novfs_internal_hash(&name);
9654 + name.hash = novfs_internal_hash(&name);
9655
9656 - inode = Novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
9657 + inode = novfs_get_inode(SB, S_IFDIR | 0777, 0, 0, 0, &name);
9658 if (inode) {
9659 info.mode = inode->i_mode;
9660 info.namelength = 0;
9661 @@ -4617,15 +3930,15 @@ int Novfs_fill_super(struct super_block
9662 inode->i_atime = info.atime =
9663 inode->i_ctime = info.ctime =
9664 inode->i_mtime = info.mtime = CURRENT_TIME;
9665 - tree = d_alloc(Novfs_root, &name);
9666 + tree = d_alloc(novfs_root, &name);
9667 if (tree) {
9668 - tree->d_op = &Novfs_dentry_operations;
9669 + tree->d_op = &novfs_dentry_operations;
9670 tree->d_time = 0xffffffff;
9671
9672 d_add(tree, inode);
9673 - DbgPrint("Novfs_fill_super: d_add %s 0x%p\n",
9674 + DbgPrint("novfs_fill_super: d_add %s 0x%p\n",
9675 TREE_DIRECTORY_NAME, tree);
9676 - Novfs_add_inode_entry(Novfs_root->d_inode,
9677 + novfs_add_inode_entry(novfs_root->d_inode,
9678 &name, inode->i_ino,
9679 &info);
9680 }
9681 @@ -4635,75 +3948,53 @@ int Novfs_fill_super(struct super_block
9682 return (0);
9683 }
9684
9685 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
9686 -int Novfs_get_sb(struct file_system_type *Fstype, int Flags,
9687 +static int novfs_get_sb(struct file_system_type *Fstype, int Flags,
9688 const char *Dev_name, void *Data, struct vfsmount *Mnt)
9689 -#else
9690 -struct super_block *Novfs_get_sb(struct file_system_type *Fstype, int Flags,
9691 - const char *Dev_name, void *Data)
9692 -#endif
9693 {
9694 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
9695 - int sb;
9696 -#else
9697 - struct super_block *sb;
9698 -#endif
9699 -
9700 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
9701 - sb = get_sb_nodev(Fstype, Flags, Data, Novfs_fill_super, Mnt);
9702 -#else
9703 - sb = get_sb_nodev(Fstype, Flags, Data, Novfs_fill_super);
9704 -#endif
9705 -
9706 - DbgPrint("Novfs_get_sb: sb=0x%p Fstype=0x%x Dev_name=%s\n", sb, Fstype,
9707 - Dev_name);
9708 -
9709 - return (sb);
9710 + DbgPrint("novfs_get_sb: Fstype=0x%x Dev_name=%s\n", Fstype, Dev_name);
9711 + return get_sb_nodev(Fstype, Flags, Data, novfs_fill_super, Mnt);
9712 }
9713
9714 static void novfs_kill_sb(struct super_block *super)
9715 {
9716 - /* calling shrink_dcache_sb() fixes novell bugzilla #345179, but I'm
9717 - * not so sure about it... */
9718 - shrink_dcache_sb(super);
9719 kill_litter_super(super);
9720 }
9721
9722 -ssize_t Novfs_Control_read(struct file *file, char *buf, size_t nbytes,
9723 +ssize_t novfs_Control_read(struct file *file, char *buf, size_t nbytes,
9724 loff_t * ppos)
9725 {
9726 ssize_t retval = 0;
9727
9728 - DbgPrint("Novfs_Control_read: kernel_locked 0x%x\n", kernel_locked());
9729 + DbgPrint("novfs_Control_read: kernel_locked 0x%x\n", kernel_locked());
9730
9731 return retval;
9732 }
9733
9734 -ssize_t Novfs_Control_write(struct file * file, const char *buf, size_t nbytes,
9735 +ssize_t novfs_Control_write(struct file * file, const char *buf, size_t nbytes,
9736 loff_t * ppos)
9737 {
9738 ssize_t retval = 0;
9739
9740 - DbgPrint("Novfs_Control_write: kernel_locked 0x%x\n", kernel_locked());
9741 + DbgPrint("novfs_Control_write: kernel_locked 0x%x\n", kernel_locked());
9742 if (buf && nbytes) {
9743 }
9744
9745 return (retval);
9746 }
9747
9748 -int Novfs_Control_ioctl(struct inode *inode, struct file *file,
9749 +int novfs_Control_ioctl(struct inode *inode, struct file *file,
9750 unsigned int cmd, unsigned long arg)
9751 {
9752 int retval = 0;
9753
9754 - DbgPrint("Novfs_Control_ioctl: kernel_locked 0x%x\n", kernel_locked());
9755 + DbgPrint("novfs_Control_ioctl: kernel_locked 0x%x\n", kernel_locked());
9756
9757 return (retval);
9758 }
9759
9760 -static struct file_system_type Novfs_fs_type = {
9761 +static struct file_system_type novfs_fs_type = {
9762 .name = "novfs",
9763 - .get_sb = Novfs_get_sb,
9764 + .get_sb = novfs_get_sb,
9765 .kill_sb = novfs_kill_sb,
9766 .owner = THIS_MODULE,
9767 };
9768 @@ -4718,20 +4009,20 @@ int __init init_novfs(void)
9769 inHAX = 0;
9770 inHAXTime = get_nanosecond_time();
9771
9772 - retCode = Init_Procfs_Interface();
9773 + retCode = novfs_proc_init();
9774
9775 - init_profile();
9776 + novfs_profile_init();
9777
9778 if (!retCode) {
9779 DbgPrint("init_novfs: %s %s %s\n", __DATE__, __TIME__,
9780 NOVFS_VERSION_STRING);
9781 - Init_Daemon_Queue();
9782 - Scope_Init();
9783 - retCode = register_filesystem(&Novfs_fs_type);
9784 + novfs_daemon_queue_init();
9785 + novfs_scope_init();
9786 + retCode = register_filesystem(&novfs_fs_type);
9787 if (retCode) {
9788 - Uninit_Procfs_Interface();
9789 - Uninit_Daemon_Queue();
9790 - Scope_Uninit();
9791 + novfs_proc_exit();
9792 + novfs_daemon_queue_exit();
9793 + novfs_scope_exit();
9794 }
9795 }
9796 return (retCode);
9797 @@ -4741,80 +4032,52 @@ void __exit exit_novfs(void)
9798 {
9799 printk(KERN_INFO "exit_novfs\n");
9800
9801 - Scope_Uninit();
9802 + novfs_scope_exit();
9803 printk(KERN_INFO "exit_novfs after Scope_Uninit\n");
9804
9805 - Uninit_Daemon_Queue();
9806 + novfs_daemon_queue_exit();
9807 printk(KERN_INFO "exit_novfs after Uninit_Daemon_Queue\n");
9808
9809 - uninit_profile();
9810 - printk(KERN_INFO "exit_novfs after uninit_profile\n");
9811 + novfs_profile_exit();
9812 + printk(KERN_INFO "exit_novfs after profile_exit\n");
9813
9814 - Uninit_Procfs_Interface();
9815 + novfs_proc_exit();
9816 printk(KERN_INFO "exit_novfs Uninit_Procfs_Interface\n");
9817
9818 - unregister_filesystem(&Novfs_fs_type);
9819 + unregister_filesystem(&novfs_fs_type);
9820 printk(KERN_INFO "exit_novfs: Exit\n");
9821
9822 - if (Novfs_CurrentMount) {
9823 - kfree(Novfs_CurrentMount);
9824 - Novfs_CurrentMount = NULL;
9825 + if (novfs_current_mnt) {
9826 + kfree(novfs_current_mnt);
9827 + novfs_current_mnt = NULL;
9828 }
9829 }
9830
9831 -int Novfs_lock_inode_cache(struct inode *i)
9832 -/*
9833 - *
9834 - * Arguments: struct inode *i - pointer to directory inode
9835 - *
9836 - * Returns: 0 - locked
9837 - * -1 - not locked
9838 - *
9839 - * Abstract: Locks the inode cache.
9840 - *
9841 - * Notes:
9842 - *
9843 - * Environment:
9844 - *
9845 - *========================================================================*/
9846 +int novfs_lock_inode_cache(struct inode *i)
9847 {
9848 struct inode_data *id;
9849 int retVal = 0;
9850
9851 - DbgPrint("Novfs_lock_inode_cache: 0x%p\n", i);
9852 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
9853 + DbgPrint("novfs_lock_inode_cache: 0x%p\n", i);
9854 + if (i && (id = i->i_private) && id->DirCache.next) {
9855 down(&id->DirCacheLock);
9856 retVal = 1;
9857 }
9858 - DbgPrint("Novfs_lock_inode_cache: return %d\n", retVal);
9859 + DbgPrint("novfs_lock_inode_cache: return %d\n", retVal);
9860 return (retVal);
9861 }
9862
9863 -/*++======================================================================*/
9864 -void Novfs_unlock_inode_cache(struct inode *i)
9865 -/*
9866 - * Arguments: struct inode *i - pointer to directory inode
9867 - *
9868 - * Returns: nothing
9869 - *
9870 - * Abstract: Unlocks inode cache.
9871 - *
9872 - * Notes:
9873 - *
9874 - * Environment:
9875 - *
9876 - *========================================================================*/
9877 +void novfs_unlock_inode_cache(struct inode *i)
9878 {
9879 struct inode_data *id;
9880
9881 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
9882 + if (i && (id = i->i_private) && id->DirCache.next) {
9883 up(&id->DirCacheLock);
9884 }
9885 }
9886
9887 -/*++======================================================================*/
9888 -int Novfs_enumerate_inode_cache(struct inode *i, struct list_head **iteration,
9889 - ino_t * ino, struct entry_info *info)
9890 +int novfs_enumerate_inode_cache(struct inode *i, struct list_head **iteration,
9891 + ino_t * ino, struct novfs_entry_info *info)
9892 /*
9893 * Arguments: struct inode *i - pointer to directory inode
9894 *
9895 @@ -4824,17 +4087,14 @@ int Novfs_enumerate_inode_cache(struct i
9896 * Abstract: Unlocks inode cache.
9897 *
9898 * Notes: DirCacheLock should be held before calling this routine.
9899 - *
9900 - * Environment:
9901 - *
9902 *========================================================================*/
9903 {
9904 struct inode_data *id;
9905 - struct dir_cache *dc;
9906 + struct novfs_dir_cache *dc;
9907 struct list_head *l = NULL;
9908 int retVal = -1;
9909
9910 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
9911 + if (i && (id = i->i_private) && id->DirCache.next) {
9912 if ((NULL == iteration) || (NULL == *iteration)) {
9913 l = id->DirCache.next;
9914 } else {
9915 @@ -4844,7 +4104,7 @@ int Novfs_enumerate_inode_cache(struct i
9916 if (l == &id->DirCache) {
9917 l = NULL;
9918 } else {
9919 - dc = list_entry(l, struct dir_cache, list);
9920 + dc = list_entry(l, struct novfs_dir_cache, list);
9921
9922 *ino = dc->ino;
9923 info->type = 0;
9924 @@ -4865,35 +4125,23 @@ int Novfs_enumerate_inode_cache(struct i
9925 return (retVal);
9926 }
9927
9928 -/*++======================================================================*/
9929 -int Novfs_get_entry(struct inode *i, struct qstr *name, ino_t * ino,
9930 - struct entry_info *info)
9931 -/*
9932 - * Arguments:
9933 - *
9934 - * Returns:
9935 - *
9936 - * Abstract:
9937 - *
9938 - * Notes: DirCacheLock should be held before calling this routine.
9939 - *
9940 - * Environment:
9941 - *
9942 - *========================================================================*/
9943 +/* DirCacheLock should be held before calling this routine. */
9944 +int novfs_get_entry(struct inode *i, struct qstr *name, ino_t * ino,
9945 + struct novfs_entry_info *info)
9946 {
9947 struct inode_data *id;
9948 - struct dir_cache *dc;
9949 + struct novfs_dir_cache *dc;
9950 int retVal = -1;
9951 char *n = "<NULL>";
9952 int nl = 6;
9953
9954 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
9955 + if (i && (id = i->i_private) && id->DirCache.next) {
9956 if (name && name->len) {
9957 n = (char *)name->name;
9958 nl = name->len;
9959 }
9960
9961 - dc = Novfs_lookup_inode_cache(i, name, *ino);
9962 + dc = novfs_lookup_inode_cache(i, name, *ino);
9963 if (dc) {
9964 dc->flags |= ENTRY_VALID;
9965 retVal = 0;
9966 @@ -4910,36 +4158,25 @@ int Novfs_get_entry(struct inode *i, str
9967 retVal = 0;
9968 }
9969
9970 - DbgPrint("Novfs_get_entry:\n"
9971 + DbgPrint("novfs_get_entry:\n"
9972 " inode: 0x%p\n"
9973 " name: %.*s\n" " ino: %d\n", i, nl, n, *ino);
9974 }
9975 - DbgPrint("Novfs_get_entry: return %d\n", retVal);
9976 + DbgPrint("novfs_get_entry: return %d\n", retVal);
9977 return (retVal);
9978 }
9979
9980 -int Novfs_get_entry_by_pos(struct inode *i, loff_t pos, ino_t * ino,
9981 - struct entry_info *info)
9982 -/*
9983 - * Arguments:
9984 - *
9985 - * Returns:
9986 - *
9987 - * Abstract:
9988 - *
9989 - * Notes: DirCacheLock should be held before calling this routine.
9990 - *
9991 - * Environment:
9992 - *
9993 - *========================================================================*/
9994 + /*DirCacheLock should be held before calling this routine. */
9995 +int novfs_get_entry_by_pos(struct inode *i, loff_t pos, ino_t * ino,
9996 + struct novfs_entry_info *info)
9997 {
9998 int retVal = -1;
9999 loff_t count = 0;
10000 loff_t i_pos = pos - 2;
10001 struct list_head *inter = NULL;
10002 - while (!Novfs_enumerate_inode_cache(i, &inter, ino, info)) {
10003 + while (!novfs_enumerate_inode_cache(i, &inter, ino, info)) {
10004 DbgPrint
10005 - ("Novfs_dir_readdir : Novfs_get_entry_by_pos : info->name = %s\n",
10006 + ("novfs_dir_readdir : novfs_get_entry_by_pos : info->name = %s\n",
10007 info->name);
10008 if (count == i_pos) {
10009 retVal = 0;
10010 @@ -4951,38 +4188,26 @@ int Novfs_get_entry_by_pos(struct inode
10011 return retVal;
10012 }
10013
10014 -/*++======================================================================*/
10015 -int Novfs_get_entry_time(struct inode *i, struct qstr *name, ino_t * ino,
10016 - struct entry_info *info, u64 * EntryTime)
10017 -/*
10018 - * Arguments:
10019 - *
10020 - * Returns:
10021 - *
10022 - * Abstract:
10023 - *
10024 - * Notes: DirCacheLock should be held before calling this routine.
10025 - *
10026 - * Environment:
10027 - *
10028 - *========================================================================*/
10029 +/* DirCacheLock should be held before calling this routine. */
10030 +int novfs_get_entry_time(struct inode *i, struct qstr *name, ino_t * ino,
10031 + struct novfs_entry_info *info, u64 * EntryTime)
10032 {
10033 struct inode_data *id;
10034 - struct dir_cache *dc;
10035 + struct novfs_dir_cache *dc;
10036 int retVal = -1;
10037 char *n = "<NULL>";
10038 int nl = 6;
10039
10040 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10041 + if (i && (id = i->i_private) && id->DirCache.next) {
10042 if (name && name->len) {
10043 n = (char *)name->name;
10044 nl = name->len;
10045 }
10046 - DbgPrint("Novfs_get_entry_time:\n"
10047 + DbgPrint("novfs_get_entry_time:\n"
10048 " inode: 0x%p\n"
10049 " name: %.*s\n" " ino: %d\n", i, nl, n, *ino);
10050
10051 - dc = Novfs_lookup_inode_cache(i, name, *ino);
10052 + dc = novfs_lookup_inode_cache(i, name, *ino);
10053 if (dc) {
10054 retVal = 0;
10055 *ino = dc->ino;
10056 @@ -5001,36 +4226,29 @@ int Novfs_get_entry_time(struct inode *i
10057 retVal = 0;
10058 }
10059 }
10060 - DbgPrint("Novfs_get_entry_time: return %d\n", retVal);
10061 + DbgPrint("novfs_get_entry_time: return %d\n", retVal);
10062 return (retVal);
10063 }
10064
10065 -/*++======================================================================*/
10066 -int Novfs_get_remove_entry(struct inode *i, ino_t * ino, struct entry_info *info)
10067 /*
10068 - * Arguments:
10069 - *
10070 - * Returns:
10071 - *
10072 * Abstract: This routine will return the first entry on the list
10073 * and then remove it.
10074 *
10075 * Notes: DirCacheLock should be held before calling this routine.
10076 *
10077 - * Environment:
10078 - *
10079 - *========================================================================*/
10080 + */
10081 +int novfs_get_remove_entry(struct inode *i, ino_t * ino, struct novfs_entry_info *info)
10082 {
10083 struct inode_data *id;
10084 - struct dir_cache *dc;
10085 + struct novfs_dir_cache *dc;
10086 struct list_head *l = NULL;
10087 int retVal = -1;
10088
10089 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10090 + if (i && (id = i->i_private) && id->DirCache.next) {
10091 l = id->DirCache.next;
10092
10093 if (l != &id->DirCache) {
10094 - dc = list_entry(l, struct dir_cache, list);
10095 + dc = list_entry(l, struct novfs_dir_cache, list);
10096
10097 *ino = dc->ino;
10098 info->type = 0;
10099 @@ -5054,41 +4272,31 @@ int Novfs_get_remove_entry(struct inode
10100 return (retVal);
10101 }
10102
10103 -/*++======================================================================*/
10104 -void Novfs_invalidate_inode_cache(struct inode *i)
10105 /*
10106 - * Arguments: struct inode *i - pointer to directory inode
10107 - *
10108 - * Returns: nothing
10109 - *
10110 * Abstract: Marks all entries in the directory cache as invalid.
10111 *
10112 * Notes: DirCacheLock should be held before calling this routine.
10113 *
10114 - * Environment:
10115 - *
10116 *========================================================================*/
10117 +void novfs_invalidate_inode_cache(struct inode *i)
10118 {
10119 struct inode_data *id;
10120 - struct dir_cache *dc;
10121 + struct novfs_dir_cache *dc;
10122 struct list_head *l;
10123
10124 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10125 + if (i && (id = i->i_private) && id->DirCache.next) {
10126 list_for_each(l, &id->DirCache) {
10127 - dc = list_entry(l, struct dir_cache, list);
10128 + dc = list_entry(l, struct novfs_dir_cache, list);
10129 dc->flags &= ~ENTRY_VALID;
10130 }
10131 }
10132 }
10133
10134 /*++======================================================================*/
10135 -static struct dir_cache *Novfs_lookup_inode_cache(struct inode *i, struct qstr *name, ino_t ino)
10136 +struct novfs_dir_cache *novfs_lookup_inode_cache(struct inode *i, struct qstr *name,
10137 + ino_t ino)
10138 /*
10139 - * Arguments: struct inode *i - pointer to directory inode
10140 - * struct qstr *name - pointer to name
10141 - * ino_t - inode number
10142 - *
10143 - * Returns: struct dir_cache entry if match
10144 + * Returns: struct novfs_dir_cache entry if match
10145 * NULL - if there is no match.
10146 *
10147 * Abstract: Checks a inode directory to see if there are any enties
10148 @@ -5097,25 +4305,22 @@ static struct dir_cache *Novfs_lookup_in
10149 *
10150 * Notes: DirCacheLock should be held before calling this routine.
10151 *
10152 - * Environment:
10153 - *
10154 *========================================================================*/
10155 {
10156 struct inode_data *id;
10157 - struct dir_cache *dc;
10158 - struct dir_cache *retVal = NULL;
10159 + struct novfs_dir_cache *dc, *retVal = NULL;
10160 struct list_head *l;
10161 char *n = "<NULL>";
10162 int nl = 6;
10163 int hash = 0;
10164
10165 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10166 + if (i && (id = i->i_private) && id->DirCache.next) {
10167 if (name && name->name) {
10168 nl = name->len;
10169 n = (char *)name->name;
10170 hash = name->hash;
10171 }
10172 - DbgPrint("Novfs_lookup_inode_cache:\n"
10173 + DbgPrint("novfs_lookup_inode_cache:\n"
10174 " inode: 0x%p\n"
10175 " name: %.*s\n"
10176 " hash: 0x%x\n"
10177 @@ -5123,10 +4328,10 @@ static struct dir_cache *Novfs_lookup_in
10178 " ino: %d\n", i, nl, n, hash, nl, ino);
10179
10180 list_for_each(l, &id->DirCache) {
10181 - dc = list_entry(l, struct dir_cache, list);
10182 + dc = list_entry(l, struct novfs_dir_cache, list);
10183 if (name) {
10184
10185 -/* DbgPrint("Novfs_lookup_inode_cache: 0x%p\n" \
10186 +/* DbgPrint("novfs_lookup_inode_cache: 0x%p\n" \
10187 " ino: %d\n" \
10188 " hash: 0x%x\n" \
10189 " len: %d\n" \
10190 @@ -5149,46 +4354,34 @@ static struct dir_cache *Novfs_lookup_in
10191 }
10192 }
10193
10194 - DbgPrint("Novfs_lookup_inode_cache: return 0x%p\n", retVal);
10195 + DbgPrint("novfs_lookup_inode_cache: return 0x%p\n", retVal);
10196 return (retVal);
10197 }
10198
10199 -/*++======================================================================*/
10200 -int Novfs_lookup_validate(struct inode *i, struct qstr *name, ino_t ino)
10201 /*
10202 - * Arguments: struct inode *i - pointer to directory inode
10203 - * struct qstr *name - pointer to name
10204 - * ino_t - inode number
10205 - *
10206 - * Returns: 0 if found
10207 - * !0 if not found
10208 - *
10209 - * Abstract: Checks a inode directory to see if there are any enties
10210 - * matching name or ino. If entry is found the valid bit
10211 - * is set.
10212 + * Checks a inode directory to see if there are any enties matching name
10213 + * or ino. If entry is found the valid bit is set.
10214 *
10215 - * Notes: DirCacheLock should be held before calling this routine.
10216 - *
10217 - * Environment:
10218 - *
10219 - *========================================================================*/
10220 + * DirCacheLock should be held before calling this routine.
10221 + */
10222 +int novfs_lookup_validate(struct inode *i, struct qstr *name, ino_t ino)
10223 {
10224 struct inode_data *id;
10225 - struct dir_cache *dc;
10226 + struct novfs_dir_cache *dc;
10227 int retVal = -1;
10228 char *n = "<NULL>";
10229 int nl = 6;
10230
10231 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10232 + if (i && (id = i->i_private) && id->DirCache.next) {
10233 if (name && name->len) {
10234 n = (char *)name->name;
10235 nl = name->len;
10236 }
10237 - DbgPrint("Novfs_update_entry:\n"
10238 + DbgPrint("novfs_update_entry:\n"
10239 " inode: 0x%p\n"
10240 " name: %.*s\n" " ino: %d\n", i, nl, n, ino);
10241
10242 - dc = Novfs_lookup_inode_cache(i, name, ino);
10243 + dc = novfs_lookup_inode_cache(i, name, ino);
10244 if (dc) {
10245 dc->flags |= ENTRY_VALID;
10246 retVal = 0;
10247 @@ -5197,46 +4390,37 @@ int Novfs_lookup_validate(struct inode *
10248 return (retVal);
10249 }
10250
10251 -/*++======================================================================*/
10252 -int Novfs_add_inode_entry(struct inode *i,
10253 - struct qstr *name, ino_t ino, struct entry_info *info)
10254 /*
10255 - * Arguments:
10256 - *
10257 - * Returns: -ENOMEM - alloc error.
10258 - * 0 - success.
10259 - *
10260 - * Abstract: Added entry to directory cache.
10261 - *
10262 - * Notes: DirCacheLock should be held before calling this routine.
10263 - *
10264 - * Environment:
10265 + * Added entry to directory cache.
10266 *
10267 - *========================================================================*/
10268 + * DirCacheLock should be held before calling this routine.
10269 + */
10270 +int novfs_add_inode_entry(struct inode *i,
10271 + struct qstr *name, ino_t ino, struct novfs_entry_info *info)
10272 {
10273 struct inode_data *id;
10274 - struct dir_cache *new;
10275 + struct novfs_dir_cache *new;
10276 int retVal = -ENOMEM;
10277 - struct dir_cache *todel;
10278 + struct novfs_dir_cache *todel;
10279 struct list_head *todeltmp;
10280
10281 //SClark
10282 - DbgPrint("Novfs_add_inode_entry:\n" " i: %u\n", i);
10283 - if ((id = i->FSPRIVATE)) {
10284 - DbgPrint(" i->FSPRIVATE: %p\n", id);
10285 + DbgPrint("novfs_add_inode_entry:\n" " i: %u\n", i);
10286 + if ((id = i->i_private)) {
10287 + DbgPrint(" i->i_private: %p\n", id);
10288 if (id->DirCache.next)
10289 DbgPrint(" id->DirCache.next: %p\n",
10290 id->DirCache.next);
10291 }
10292 //SClark
10293
10294 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10295 - new = Novfs_Malloc(sizeof(struct dir_cache) + name->len, GFP_KERNEL);
10296 + if (i && (id = i->i_private) && id->DirCache.next) {
10297 + new = kmalloc(sizeof(struct novfs_dir_cache) + name->len, GFP_KERNEL);
10298 if (new) {
10299 id->cntDC++;
10300
10301 DCCount++;
10302 - DbgPrint("Novfs_add_inode_entry:\n"
10303 + DbgPrint("novfs_add_inode_entry:\n"
10304 " inode: 0x%p\n"
10305 " id: 0x%p\n"
10306 " DC: 0x%p\n"
10307 @@ -5265,7 +4449,7 @@ int Novfs_add_inode_entry(struct inode *
10308
10309 if (id->cntDC > 20) {
10310 todeltmp = id->DirCache.prev;
10311 - todel = list_entry(todeltmp, struct dir_cache, list);
10312 + todel = list_entry(todeltmp, struct novfs_dir_cache, list);
10313
10314 list_del(&todel->list);
10315
10316 @@ -5274,29 +4458,20 @@ int Novfs_add_inode_entry(struct inode *
10317 DCCount--;
10318 id->cntDC--;
10319 }
10320 +
10321 }
10322 }
10323 return (retVal);
10324 }
10325
10326 -/*++======================================================================*/
10327 -int Novfs_update_entry(struct inode *i, struct qstr *name, ino_t ino,
10328 - struct entry_info *info)
10329 /*
10330 - * Arguments:
10331 - *
10332 - * Returns:
10333 - *
10334 - * Abstract:
10335 - *
10336 - * Notes: DirCacheLock should be held before calling this routine.
10337 - *
10338 - * Environment:
10339 - *
10340 - *========================================================================*/
10341 + * DirCacheLock should be held before calling this routine.
10342 + */
10343 +int novfs_update_entry(struct inode *i, struct qstr *name, ino_t ino,
10344 + struct novfs_entry_info *info)
10345 {
10346 struct inode_data *id;
10347 - struct dir_cache *dc;
10348 + struct novfs_dir_cache *dc;
10349 int retVal = -1;
10350 char *n = "<NULL>";
10351 int nl = 6;
10352 @@ -5304,7 +4479,7 @@ int Novfs_update_entry(struct inode *i,
10353 char mtime_buf[32];
10354 char ctime_buf[32];
10355
10356 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10357 + if (i && (id = i->i_private) && id->DirCache.next) {
10358
10359 if (name && name->len) {
10360 n = (char *)name->name;
10361 @@ -5313,7 +4488,7 @@ int Novfs_update_entry(struct inode *i,
10362 ctime_r(&info->atime.tv_sec, atime_buf);
10363 ctime_r(&info->mtime.tv_sec, mtime_buf);
10364 ctime_r(&info->ctime.tv_sec, ctime_buf);
10365 - DbgPrint("Novfs_update_entry:\n"
10366 + DbgPrint("novfs_update_entry:\n"
10367 " inode: 0x%p\n"
10368 " name: %.*s\n"
10369 " ino: %d\n"
10370 @@ -5324,7 +4499,7 @@ int Novfs_update_entry(struct inode *i,
10371 i, nl, n, ino, info->size, atime_buf, mtime_buf,
10372 ctime_buf);
10373
10374 - dc = Novfs_lookup_inode_cache(i, name, ino);
10375 + dc = novfs_lookup_inode_cache(i, name, ino);
10376 if (dc) {
10377 retVal = 0;
10378 dc->flags = ENTRY_VALID;
10379 @@ -5338,7 +4513,7 @@ int Novfs_update_entry(struct inode *i,
10380 ctime_r(&dc->atime.tv_sec, atime_buf);
10381 ctime_r(&dc->mtime.tv_sec, mtime_buf);
10382 ctime_r(&dc->ctime.tv_sec, ctime_buf);
10383 - DbgPrint("Novfs_update_entry entry: 0x%p\n"
10384 + DbgPrint("novfs_update_entry entry: 0x%p\n"
10385 " flags: 0x%x\n"
10386 " jiffies: %lld\n"
10387 " ino: %d\n"
10388 @@ -5356,39 +4531,31 @@ int Novfs_update_entry(struct inode *i,
10389 dc->nameLen, dc->name);
10390 }
10391 }
10392 - DbgPrint("Novfs_update_entry: return %d\n", retVal);
10393 + DbgPrint("novfs_update_entry: return %d\n", retVal);
10394 return (retVal);
10395 }
10396
10397 -/*++======================================================================*/
10398 -void Novfs_remove_inode_entry(struct inode *i, struct qstr *name, ino_t ino)
10399 /*
10400 - * Arguments:
10401 - *
10402 - * Returns: nothing
10403 - *
10404 - * Abstract: Removes entry from directory cache. You can specify a name
10405 - * or an inode number.
10406 - *
10407 - * Notes: DirCacheLock should be held before calling this routine.
10408 - *
10409 - * Environment:
10410 + * Removes entry from directory cache. You can specify a name
10411 + * or an inode number.
10412 *
10413 - *========================================================================*/
10414 + * DirCacheLock should be held before calling this routine.
10415 + */
10416 +void novfs_remove_inode_entry(struct inode *i, struct qstr *name, ino_t ino)
10417 {
10418 struct inode_data *id;
10419 - struct dir_cache *dc;
10420 + struct novfs_dir_cache *dc;
10421 char *n = "<NULL>";
10422 int nl = 6;
10423
10424 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10425 - dc = Novfs_lookup_inode_cache(i, name, ino);
10426 + if (i && (id = i->i_private) && id->DirCache.next) {
10427 + dc = novfs_lookup_inode_cache(i, name, ino);
10428 if (dc) {
10429 if (name && name->name) {
10430 nl = name->len;
10431 n = (char *)name->name;
10432 }
10433 - DbgPrint("Novfs_remove_inode_entry:\n"
10434 + DbgPrint("novfs_remove_inode_entry:\n"
10435 " inode: 0x%p\n"
10436 " id: 0x%p\n"
10437 " DC: 0x%p\n"
10438 @@ -5411,30 +4578,22 @@ void Novfs_remove_inode_entry(struct ino
10439 }
10440 }
10441
10442 -/*++======================================================================*/
10443 -void Novfs_free_invalid_entries(struct inode *i)
10444 /*
10445 - * Arguments: struct inode *i - pointer to directory inode.
10446 - *
10447 - * Returns: nothing
10448 - *
10449 - * Abstract: Frees all invalid entries in the directory cache.
10450 - *
10451 - * Notes: DirCacheLock should be held before calling this routine.
10452 - *
10453 - * Environment:
10454 + * Frees all invalid entries in the directory cache.
10455 *
10456 - *========================================================================*/
10457 + * DirCacheLock should be held before calling this routine.
10458 + */
10459 +void novfs_free_invalid_entries(struct inode *i)
10460 {
10461 struct inode_data *id;
10462 - struct dir_cache *dc;
10463 + struct novfs_dir_cache *dc;
10464 struct list_head *l;
10465
10466 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10467 + if (i && (id = i->i_private) && id->DirCache.next) {
10468 list_for_each(l, &id->DirCache) {
10469 - dc = list_entry(l, struct dir_cache, list);
10470 + dc = list_entry(l, struct novfs_dir_cache, list);
10471 if (0 == (dc->flags & ENTRY_VALID)) {
10472 - DbgPrint("Novfs_free_invalid_entries:\n"
10473 + DbgPrint("novfs_free_invalid_entries:\n"
10474 " inode: 0x%p\n"
10475 " id: 0x%p\n"
10476 " entry: 0x%p\n"
10477 @@ -5453,28 +4612,20 @@ void Novfs_free_invalid_entries(struct i
10478 }
10479 }
10480
10481 -/*++======================================================================*/
10482 -void Novfs_free_inode_cache(struct inode *i)
10483 /*
10484 - * Arguments: struct inode *i - pointer to directory inode.
10485 - *
10486 - * Returns: nothing
10487 - *
10488 - * Abstract: Frees all entries in the inode cache.
10489 - *
10490 - * Notes: DirCacheLock should be held before calling this routine.
10491 - *
10492 - * Environment:
10493 + * Frees all entries in the inode cache.
10494 *
10495 - *========================================================================*/
10496 + * DirCacheLock should be held before calling this routine.
10497 + */
10498 +void novfs_free_inode_cache(struct inode *i)
10499 {
10500 struct inode_data *id;
10501 - struct dir_cache *dc;
10502 + struct novfs_dir_cache *dc;
10503 struct list_head *l;
10504
10505 - if (i && (id = i->FSPRIVATE) && id->DirCache.next) {
10506 + if (i && (id = i->i_private) && id->DirCache.next) {
10507 list_for_each(l, &id->DirCache) {
10508 - dc = list_entry(l, struct dir_cache, list);
10509 + dc = list_entry(l, struct novfs_dir_cache, list);
10510 l = l->prev;
10511 list_del(&dc->list);
10512 kfree(dc);
10513 @@ -5485,12 +4636,12 @@ void Novfs_free_inode_cache(struct inode
10514 }
10515 }
10516
10517 -void Novfs_dump_inode(void *pf)
10518 +void novfs_dump_inode(void *pf)
10519 {
10520 struct inode *inode;
10521 void (*pfunc) (char *Fmt, ...) = pf;
10522 struct inode_data *id;
10523 - struct dir_cache *dc;
10524 + struct novfs_dir_cache *dc;
10525 struct list_head *il, *l;
10526 char atime_buf[32];
10527 char mtime_buf[32];
10528 @@ -5517,13 +4668,14 @@ void Novfs_dump_inode(void *pf)
10529 pfunc(" count=0%o\n", atomic_read(&inode->i_count));
10530 }
10531
10532 - pfunc(" inode_data: 0x%p Name=%s Scope=0x%p\n", id, id->Name,
10533 + pfunc(" nofs_inode_data: 0x%p Name=%s Scope=0x%p\n", id, id->Name,
10534 id->Scope);
10535
10536 if (id->DirCache.next) {
10537 list_for_each(l, &id->DirCache) {
10538 dccnt++;
10539 - dc = list_entry(l, struct dir_cache, list);
10540 + dc = list_entry(l, struct novfs_dir_cache,
10541 + list);
10542 ctime_r(&dc->atime.tv_sec, atime_buf);
10543 ctime_r(&dc->mtime.tv_sec, mtime_buf);
10544 ctime_r(&dc->ctime.tv_sec, ctime_buf);
10545 --- a/fs/novfs/nwcapi.c
10546 +++ b/fs/novfs/nwcapi.c
10547 @@ -27,16 +27,20 @@
10548 #include "vfs.h"
10549 #include "commands.h"
10550
10551 -static void GetUserData(NwcScanConnInfo *connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply);
10552 -static void GetConnData(NwcGetConnInfo *connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply);
10553 +#ifndef strlen_user
10554 +#define strlen_user(str) strnlen_user(str, ~0UL >> 1)
10555 +#endif
10556
10557 +static void GetUserData(struct nwc_scan_conn_info * connInfo, struct novfs_xplat_call_request *cmd, struct novfs_xplat_call_reply *reply);
10558 +static void GetConnData(struct nwc_get_conn_info * connInfo, struct novfs_xplat_call_request *cmd, struct novfs_xplat_call_reply *reply);
10559
10560 -int NwOpenConnByName(PXPLAT pdata, HANDLE * Handle, session_t Session)
10561 +/*++======================================================================*/
10562 +int novfs_open_conn_by_name(struct novfs_xplat *pdata, void ** Handle, struct novfs_schandle Session)
10563 {
10564 - PXPLAT_CALL_REQUEST cmd;
10565 - PXPLAT_CALL_REPLY reply;
10566 - PNwdCOpenConnByName openConn, connReply;
10567 - NwcOpenConnByName ocbn;
10568 + struct novfs_xplat_call_request *cmd;
10569 + struct novfs_xplat_call_reply *reply;
10570 + struct nwd_open_conn_by_name *openConn, *connReply;
10571 + struct nwc_open_conn_by_name ocbn;
10572 int retCode = 0;
10573 unsigned long cmdlen, datalen, replylen, cpylen;
10574 char *data;
10575 @@ -45,15 +49,17 @@ int NwOpenConnByName(PXPLAT pdata, HANDL
10576 datalen = sizeof(*openConn) + strlen_user(ocbn.pName->pString) + strlen_user(ocbn.pServiceType);
10577 cmdlen = datalen + sizeof(*cmd);
10578 cmd = kmalloc(cmdlen, GFP_KERNEL);
10579 +
10580 if (!cmd)
10581 return -ENOMEM;
10582 +
10583 cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
10584 cmd->Command.SequenceNumber = 0;
10585 cmd->Command.SessionId = Session;
10586 cmd->NwcCommand = NWC_OPEN_CONN_BY_NAME;
10587
10588 cmd->dataLen = datalen;
10589 - openConn = (PNwdCOpenConnByName) cmd->data;
10590 + openConn = (struct nwd_open_conn_by_name *) cmd->data;
10591
10592 openConn->nameLen = strlen_user(ocbn.pName->pString);
10593 openConn->serviceLen = strlen_user(ocbn.pServiceType);
10594 @@ -64,24 +70,29 @@ int NwOpenConnByName(PXPLAT pdata, HANDL
10595 openConn->oName = sizeof(*openConn);
10596
10597 openConn->oServiceType = openConn->oName + openConn->nameLen;
10598 - cpylen = copy_from_user(data, ocbn.pName->pString, openConn->nameLen);
10599 + cpylen =
10600 + copy_from_user(data, ocbn.pName->pString,
10601 + openConn->nameLen);
10602 data += openConn->nameLen;
10603 - cpylen = copy_from_user(data, ocbn.pServiceType, openConn->serviceLen);
10604 + cpylen =
10605 + copy_from_user(data, ocbn.pServiceType,
10606 + openConn->serviceLen);
10607
10608 - retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10609 - (void **)&reply, &replylen,
10610 - INTERRUPTIBLE);
10611 + retCode =
10612 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10613 + (void **)&reply, &replylen,
10614 + INTERRUPTIBLE);
10615 if (reply) {
10616 /*
10617 * we got reply data from the daemon
10618 */
10619 - connReply = (PNwdCOpenConnByName) reply->data;
10620 + connReply = (struct nwd_open_conn_by_name *) reply->data;
10621 retCode = reply->Reply.ErrorCode;
10622 if (!retCode) {
10623 /*
10624 * we got valid data.
10625 */
10626 - connReply = (PNwdCOpenConnByName) reply->data;
10627 + connReply = (struct nwd_open_conn_by_name *) reply->data;
10628 ocbn.RetConnHandle = HandletoUint32(connReply->newConnHandle);
10629 *Handle = connReply->newConnHandle;
10630
10631 @@ -92,18 +103,17 @@ int NwOpenConnByName(PXPLAT pdata, HANDL
10632 }
10633
10634 kfree(cmd);
10635 -
10636 - return retCode;
10637 + return ((int)retCode);
10638
10639 }
10640
10641 -int NwOpenConnByAddr(PXPLAT pdata, HANDLE * Handle, session_t Session)
10642 +int novfs_open_conn_by_addr(struct novfs_xplat *pdata, void ** Handle, struct novfs_schandle Session)
10643 {
10644 - PXPLAT_CALL_REQUEST cmd;
10645 - PXPLAT_CALL_REPLY reply;
10646 - PNwdCOpenConnByAddr openConn, connReply;
10647 - NwcOpenConnByAddr ocba;
10648 - NwcTranAddr tranAddr;
10649 + struct novfs_xplat_call_request *cmd;
10650 + struct novfs_xplat_call_reply *reply;
10651 + struct nwd_open_conn_by_addr *openConn, *connReply;
10652 + struct nwc_open_conn_by_addr ocba;
10653 + struct nwc_tran_addr tranAddr;
10654 int retCode = 0;
10655 unsigned long cmdlen, datalen, replylen, cpylen;
10656 char addr[MAX_ADDRESS_LENGTH];
10657 @@ -112,6 +122,7 @@ int NwOpenConnByAddr(PXPLAT pdata, HANDL
10658 datalen = sizeof(*openConn);
10659 cmdlen = datalen + sizeof(*cmd);
10660 cmd = kmalloc(cmdlen, GFP_KERNEL);
10661 +
10662 if (!cmd)
10663 return -ENOMEM;
10664
10665 @@ -120,69 +131,66 @@ int NwOpenConnByAddr(PXPLAT pdata, HANDL
10666 cmd->Command.SessionId = Session;
10667 cmd->NwcCommand = NWC_OPEN_CONN_BY_ADDRESS;
10668 cmd->dataLen = datalen;
10669 - openConn = (PNwdCOpenConnByAddr) cmd->data;
10670 + openConn = (struct nwd_open_conn_by_addr *) cmd->data;
10671
10672 - cpylen = copy_from_user(&tranAddr, ocba.pTranAddr, sizeof(tranAddr));
10673 + cpylen =
10674 + copy_from_user(&tranAddr, ocba.pTranAddr, sizeof(tranAddr));
10675
10676 DbgPrint("NwOpenConnByAddr: tranAddr\n");
10677 - mydump(sizeof(tranAddr), &tranAddr);
10678 + novfs_dump(sizeof(tranAddr), &tranAddr);
10679
10680 openConn->TranAddr.uTransportType = tranAddr.uTransportType;
10681 openConn->TranAddr.uAddressLength = tranAddr.uAddressLength;
10682 memset(addr, 0xcc, sizeof(addr) - 1);
10683
10684 - cpylen = copy_from_user(addr, tranAddr.puAddress, tranAddr.uAddressLength);
10685 + cpylen =
10686 + copy_from_user(addr, tranAddr.puAddress,
10687 + tranAddr.uAddressLength);
10688
10689 DbgPrint("NwOpenConnByAddr: addr\n");
10690 - mydump(sizeof(addr), addr);
10691 + novfs_dump(sizeof(addr), addr);
10692
10693 - openConn->TranAddr.oAddress = *(unsigned int*) (&addr[2]);
10694 + openConn->TranAddr.oAddress = *(unsigned int *) (&addr[2]);
10695
10696 - retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10697 - (void **)&reply, &replylen,
10698 - INTERRUPTIBLE);
10699 + retCode =
10700 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10701 + (void **)&reply, &replylen,
10702 + INTERRUPTIBLE);
10703 if (reply) {
10704 /*
10705 * we got reply data from the daemon
10706 */
10707 - connReply = (PNwdCOpenConnByAddr) reply->data;
10708 + connReply = (struct nwd_open_conn_by_addr *) reply->data;
10709 retCode = reply->Reply.ErrorCode;
10710 if (!retCode) {
10711 /*
10712 * we got valid data.
10713 */
10714 - connReply = (PNwdCOpenConnByAddr) reply->data;
10715 - ocba.ConnHandle = HandletoUint32(connReply->ConnHandle);
10716 + connReply = (struct nwd_open_conn_by_addr *) reply->data;
10717 + ocba.ConnHandle =
10718 + HandletoUint32(connReply->ConnHandle);
10719 *Handle = connReply->ConnHandle;
10720 - cpylen = copy_to_user(pdata->reqData, &ocba, sizeof(ocba));
10721 - DbgPrint("New Conn Handle = %X\n", connReply->ConnHandle);
10722 + cpylen =
10723 + copy_to_user(pdata->reqData, &ocba,
10724 + sizeof(ocba));
10725 + DbgPrint("New Conn Handle = %X\n",
10726 + connReply->ConnHandle);
10727 }
10728 kfree(reply);
10729 }
10730
10731 kfree(cmd);
10732 - return retCode;
10733 +
10734 + return (retCode);
10735 +
10736 }
10737
10738 -/*++======================================================================*/
10739 -int NwOpenConnByRef(PXPLAT pdata, HANDLE * Handle, session_t Session)
10740 -/*
10741 - * Arguments:
10742 - *
10743 - * Returns:
10744 - *
10745 - * Abstract:
10746 - *
10747 - * Notes:
10748 - *
10749 - * Environment:
10750 - *
10751 - *========================================================================*/
10752 -{
10753 - PXPLAT_CALL_REQUEST cmd;
10754 - PXPLAT_CALL_REPLY reply;
10755 - PNwdCOpenConnByRef openConn;
10756 - NwcOpenConnByReference ocbr;
10757 +int novfs_open_conn_by_ref(struct novfs_xplat *pdata, void ** Handle, struct novfs_schandle Session)
10758 +{
10759 + struct novfs_xplat_call_request *cmd;
10760 + struct novfs_xplat_call_reply *reply;
10761 + struct nwd_open_conn_by_ref *openConn;
10762 + struct nwc_open_conn_by_ref ocbr;
10763 int retCode = -ENOMEM;
10764 unsigned long cmdlen, datalen, replylen, cpylen;
10765
10766 @@ -198,29 +206,35 @@ int NwOpenConnByRef(PXPLAT pdata, HANDLE
10767 cmd->Command.SessionId = Session;
10768 cmd->NwcCommand = NWC_OPEN_CONN_BY_REFERENCE;
10769 cmd->dataLen = datalen;
10770 - openConn = (PNwdCOpenConnByRef) cmd->data;
10771 + openConn = (struct nwd_open_conn_by_ref *) cmd->data;
10772
10773 - openConn->uConnReference = (HANDLE) (unsigned long) ocbr.uConnReference;
10774 + openConn->uConnReference =
10775 + (void *) (unsigned long) ocbr.uConnReference;
10776 openConn->uConnFlags = ocbr.uConnFlags;
10777
10778 - retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10779 - (void **)&reply, &replylen,
10780 - INTERRUPTIBLE);
10781 + retCode =
10782 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10783 + (void **)&reply, &replylen,
10784 + INTERRUPTIBLE);
10785 if (reply) {
10786 /*
10787 * we got reply data from the daemon
10788 */
10789 - openConn = (PNwdCOpenConnByRef) reply->data;
10790 + openConn = (struct nwd_open_conn_by_ref *) reply->data;
10791 retCode = reply->Reply.ErrorCode;
10792 if (!retCode) {
10793 /*
10794 * we got valid data.
10795 */
10796 - ocbr.ConnHandle = HandletoUint32(openConn->ConnHandle);
10797 + ocbr.ConnHandle =
10798 + HandletoUint32(openConn->ConnHandle);
10799 *Handle = openConn->ConnHandle;
10800
10801 - cpylen = copy_to_user(pdata->reqData, &ocbr, sizeof(ocbr));
10802 - DbgPrint("New Conn Handle = %X\n", openConn->ConnHandle);
10803 + cpylen =
10804 + copy_to_user(pdata->reqData, &ocbr,
10805 + sizeof(ocbr));
10806 + DbgPrint("New Conn Handle = %X\n",
10807 + openConn->ConnHandle);
10808 }
10809 kfree(reply);
10810 }
10811 @@ -230,19 +244,17 @@ int NwOpenConnByRef(PXPLAT pdata, HANDLE
10812
10813 }
10814
10815 -int NwRawSend(PXPLAT pdata, session_t Session)
10816 +int novfs_raw_send(struct novfs_xplat *pdata, struct novfs_schandle Session)
10817 {
10818 - NwcRequest xRequest;
10819 - PNwcFrag frag = NULL;
10820 - PNwcFrag cFrag = NULL;
10821 - PNwcFrag reqFrag = NULL;
10822 - PXPLAT_CALL_REQUEST cmd;
10823 - PXPLAT_CALL_REPLY reply;
10824 + struct nwc_request xRequest;
10825 + struct nwc_frag *frag, *cFrag, *reqFrag;
10826 + struct novfs_xplat_call_request *cmd;
10827 + struct novfs_xplat_call_reply *reply;
10828 int retCode = -ENOMEM;
10829 unsigned long cmdlen, datalen, replylen, cpylen, totalLen;
10830 unsigned int x;
10831 - PNwdCNCPReq ncpData;
10832 - PNwdCNCPRep ncpReply;
10833 + struct nwd_ncp_req *ncpData;
10834 + struct nwd_ncp_rep *ncpReply;
10835 unsigned char *reqData;
10836 unsigned long actualReplyLength = 0;
10837
10838 @@ -252,13 +264,18 @@ int NwRawSend(PXPLAT pdata, session_t Se
10839 /*
10840 * Figure out the length of the request
10841 */
10842 - frag = kmalloc(xRequest.uNumReplyFrags * sizeof(NwcFrag), GFP_KERNEL);
10843 - DbgPrint("[XPLAT RawNCP] - Reply Frag Count 0x%X\n", xRequest.uNumReplyFrags);
10844 + frag =
10845 + kmalloc(xRequest.uNumReplyFrags * sizeof(struct nwc_frag), GFP_KERNEL);
10846 +
10847 + DbgPrint("[XPLAT RawNCP] - Reply Frag Count 0x%X\n",
10848 + xRequest.uNumReplyFrags);
10849
10850 if (!frag)
10851 - goto exit;
10852 + return (retCode);
10853
10854 - cpylen = copy_from_user(frag, xRequest.pReplyFrags, xRequest.uNumReplyFrags * sizeof(NwcFrag));
10855 + cpylen =
10856 + copy_from_user(frag, xRequest.pReplyFrags,
10857 + xRequest.uNumReplyFrags * sizeof(struct nwc_frag));
10858 totalLen = 0;
10859
10860 cFrag = frag;
10861 @@ -270,11 +287,17 @@ int NwRawSend(PXPLAT pdata, session_t Se
10862
10863 DbgPrint("[XPLAT - RawNCP] - totalLen = %d\n", totalLen);
10864 datalen = 0;
10865 - reqFrag = kmalloc(xRequest.uNumRequestFrags * sizeof(NwcFrag), GFP_KERNEL);
10866 - if (!reqFrag)
10867 - goto exit;
10868 + reqFrag =
10869 + kmalloc(xRequest.uNumRequestFrags * sizeof(struct nwc_frag),
10870 + GFP_KERNEL);
10871 + if (!reqFrag) {
10872 + kfree(frag);
10873 + return (retCode);
10874 + }
10875
10876 - cpylen = copy_from_user(reqFrag, xRequest.pRequestFrags, xRequest.uNumRequestFrags * sizeof(NwcFrag));
10877 + cpylen =
10878 + copy_from_user(reqFrag, xRequest.pRequestFrags,
10879 + xRequest.uNumRequestFrags * sizeof(struct nwc_frag));
10880 cFrag = reqFrag;
10881 for (x = 0; x < xRequest.uNumRequestFrags; x++) {
10882 datalen += cFrag->uLength;
10883 @@ -285,12 +308,13 @@ int NwRawSend(PXPLAT pdata, session_t Se
10884 * Allocate the cmd Request
10885 */
10886 cmdlen = datalen + sizeof(*cmd) + sizeof(*ncpData);
10887 - DbgPrint("[XPLAT RawNCP] - Frag Count 0x%X\n", xRequest.uNumRequestFrags);
10888 + DbgPrint("[XPLAT RawNCP] - Frag Count 0x%X\n",
10889 + xRequest.uNumRequestFrags);
10890 DbgPrint("[XPLAT RawNCP] - Total Command Data Len = %x\n", cmdlen);
10891
10892 cmd = kmalloc(cmdlen, GFP_KERNEL);
10893 if (!cmd)
10894 - goto exit;
10895 + return -ENOMEM;
10896
10897 cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
10898 cmd->Command.SequenceNumber = 0;
10899 @@ -301,10 +325,10 @@ int NwRawSend(PXPLAT pdata, session_t Se
10900 * build the NCP Request
10901 */
10902 cmd->dataLen = cmdlen - sizeof(*cmd);
10903 - ncpData = (PNwdCNCPReq) cmd->data;
10904 + ncpData = (struct nwd_ncp_req *) cmd->data;
10905 ncpData->replyLen = totalLen;
10906 ncpData->requestLen = datalen;
10907 - ncpData->ConnHandle = (HANDLE) (unsigned long) xRequest.ConnHandle;
10908 + ncpData->ConnHandle = (void *) (unsigned long) xRequest.ConnHandle;
10909 ncpData->function = xRequest.uFunction;
10910
10911 reqData = ncpData->data;
10912 @@ -312,15 +336,16 @@ int NwRawSend(PXPLAT pdata, session_t Se
10913
10914 for (x = 0; x < xRequest.uNumRequestFrags; x++) {
10915 cpylen =
10916 - copy_from_user(reqData, cFrag->pData,
10917 - cFrag->uLength);
10918 + copy_from_user(reqData, cFrag->pData,
10919 + cFrag->uLength);
10920 reqData += cFrag->uLength;
10921 cFrag++;
10922 }
10923
10924 - retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10925 - (void **)&reply, &replylen,
10926 - INTERRUPTIBLE);
10927 + retCode =
10928 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
10929 + (void **)&reply, &replylen,
10930 + INTERRUPTIBLE);
10931 DbgPrint("RawNCP - reply = %x\n", reply);
10932 DbgPrint("RawNCP - retCode = %x\n", retCode);
10933
10934 @@ -328,11 +353,11 @@ int NwRawSend(PXPLAT pdata, session_t Se
10935 /*
10936 * we got reply data from the daemon
10937 */
10938 - ncpReply = (PNwdCNCPRep) reply->data;
10939 + ncpReply = (struct nwd_ncp_rep *) reply->data;
10940 retCode = reply->Reply.ErrorCode;
10941
10942 DbgPrint("RawNCP - Reply Frag Count 0x%X\n",
10943 - xRequest.uNumReplyFrags);
10944 + xRequest.uNumReplyFrags);
10945
10946 /*
10947 * We need to copy the reply frags to the packet.
10948 @@ -344,11 +369,14 @@ int NwRawSend(PXPLAT pdata, session_t Se
10949 for (x = 0; x < xRequest.uNumReplyFrags; x++) {
10950
10951 DbgPrint("RawNCP - Copy Frag %d: 0x%X\n", x,
10952 - cFrag->uLength);
10953 + cFrag->uLength);
10954
10955 - datalen = min((unsigned long)cFrag->uLength, totalLen);
10956 + datalen =
10957 + min((unsigned long) cFrag->uLength, totalLen);
10958
10959 - cpylen = copy_to_user(cFrag->pData, reqData, datalen);
10960 + cpylen =
10961 + copy_to_user(cFrag->pData, reqData,
10962 + datalen);
10963 totalLen -= datalen;
10964 reqData += datalen;
10965 actualReplyLength += datalen;
10966 @@ -362,22 +390,21 @@ int NwRawSend(PXPLAT pdata, session_t Se
10967 }
10968
10969 kfree(cmd);
10970 -
10971 xRequest.uActualReplyLength = actualReplyLength;
10972 cpylen = copy_to_user(pdata->reqData, &xRequest, sizeof(xRequest));
10973
10974 -exit:
10975 kfree(reqFrag);
10976 kfree(frag);
10977 - return retCode;
10978 +
10979 + return (retCode);
10980 }
10981
10982 -int NwConnClose(PXPLAT pdata, HANDLE * Handle, session_t Session)
10983 +int novfs_conn_close(struct novfs_xplat *pdata, void ** Handle, struct novfs_schandle Session)
10984 {
10985 - PXPLAT_CALL_REQUEST cmd;
10986 - PXPLAT_CALL_REPLY reply;
10987 - NwcCloseConn cc;
10988 - PNwdCCloseConn nwdClose;
10989 + struct novfs_xplat_call_request *cmd;
10990 + struct novfs_xplat_call_reply *reply;
10991 + struct nwc_close_conn cc;
10992 + struct nwd_close_conn *nwdClose;
10993 int retCode = 0;
10994 unsigned long cmdlen, datalen, replylen, cpylen;
10995
10996 @@ -388,35 +415,36 @@ int NwConnClose(PXPLAT pdata, HANDLE * H
10997 cmd = kmalloc(cmdlen, GFP_KERNEL);
10998 if (!cmd)
10999 return -ENOMEM;
11000 -
11001 cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11002 cmd->Command.SequenceNumber = 0;
11003 cmd->Command.SessionId = Session;
11004 cmd->NwcCommand = NWC_CLOSE_CONN;
11005
11006 - nwdClose = (PNwdCCloseConn) cmd->data;
11007 + nwdClose = (struct nwd_close_conn *) cmd->data;
11008 cmd->dataLen = sizeof(*nwdClose);
11009 *Handle = nwdClose->ConnHandle = Uint32toHandle(cc.ConnHandle);
11010
11011 /*
11012 * send the request
11013 */
11014 - retCode = Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11015 - (void **)&reply, &replylen, 0);
11016 + retCode =
11017 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11018 + (void **)&reply, &replylen, 0);
11019 if (reply) {
11020 retCode = reply->Reply.ErrorCode;
11021 kfree(reply);
11022 }
11023 kfree(cmd);
11024 - return retCode;
11025 + return (retCode);
11026 +
11027 }
11028
11029 -int NwSysConnClose(PXPLAT pdata, unsigned long *Handle, session_t Session)
11030 +int novfs_sys_conn_close(struct novfs_xplat *pdata, unsigned long *Handle, struct novfs_schandle Session)
11031 {
11032 - PXPLAT_CALL_REQUEST cmd;
11033 - PXPLAT_CALL_REPLY reply;
11034 - NwcCloseConn cc;
11035 - PNwdCCloseConn nwdClose;
11036 + struct novfs_xplat_call_request *cmd;
11037 + struct novfs_xplat_call_reply *reply;
11038 + struct nwc_close_conn cc;
11039 + struct nwd_close_conn *nwdClose;
11040 unsigned int retCode = 0;
11041 unsigned long cmdlen, datalen, replylen, cpylen;
11042
11043 @@ -424,133 +452,87 @@ int NwSysConnClose(PXPLAT pdata, unsigne
11044
11045 datalen = sizeof(*nwdClose);
11046 cmdlen = datalen + sizeof(*cmd);
11047 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11048 - if (cmd) {
11049 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11050 - cmd->Command.SequenceNumber = 0;
11051 - cmd->Command.SessionId = Session;
11052 - cmd->NwcCommand = NWC_SYS_CLOSE_CONN;
11053 -
11054 - nwdClose = (PNwdCCloseConn) cmd->data;
11055 - cmd->dataLen = sizeof(*nwdClose);
11056 - nwdClose->ConnHandle = (HANDLE) (unsigned long) cc.ConnHandle;
11057 - *Handle = (unsigned long) cc.ConnHandle;
11058 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11059 + if (!cmd)
11060 + return -ENOMEM;
11061 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11062 + cmd->Command.SequenceNumber = 0;
11063 + cmd->Command.SessionId = Session;
11064 + cmd->NwcCommand = NWC_SYS_CLOSE_CONN;
11065
11066 - /*
11067 - * send the request
11068 - */
11069 - retCode =
11070 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11071 - (void **)&reply, &replylen, 0);
11072 - if (reply) {
11073 - retCode = reply->Reply.ErrorCode;
11074 - kfree(reply);
11075 - }
11076 - kfree(cmd);
11077 + nwdClose = (struct nwd_close_conn *) cmd->data;
11078 + cmd->dataLen = sizeof(*nwdClose);
11079 + nwdClose->ConnHandle = (void *) (unsigned long) cc.ConnHandle;
11080 + *Handle = (unsigned long) cc.ConnHandle;
11081
11082 + /*
11083 + * send the request
11084 + */
11085 + retCode =
11086 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0, (void **)&reply, &replylen, 0);
11087 + if (reply) {
11088 + retCode = reply->Reply.ErrorCode;
11089 + kfree(reply);
11090 }
11091 -
11092 + kfree(cmd);
11093 return (retCode);
11094
11095 }
11096
11097 -/*++======================================================================*/
11098 -int NwLoginIdentity(PXPLAT pdata, struct schandle *Session)
11099 -/*
11100 - * Arguments:
11101 - *
11102 - * Returns:
11103 - *
11104 - * Abstract:
11105 - *
11106 - * Notes:
11107 - *
11108 - * Environment:
11109 - *
11110 - *========================================================================*/
11111 +int novfs_login_id(struct novfs_xplat *pdata, struct novfs_schandle Session)
11112 {
11113 - NwcLoginIdentity lgn, *plgn;
11114 + struct nwc_login_id lgn, *plgn;
11115 int retCode = -ENOMEM;
11116 - NclString server;
11117 - NclString username;
11118 - NclString password;
11119 + struct ncl_string server;
11120 + struct ncl_string username;
11121 + struct ncl_string password;
11122 unsigned long cpylen;
11123 - NwcString nwcStr;
11124 + struct nwc_string nwcStr;
11125
11126 cpylen = copy_from_user(&lgn, pdata->reqData, sizeof(lgn));
11127
11128 DbgPrint("NwLoginIdentity:\n");
11129 - mydump(sizeof(lgn), &lgn);
11130 + novfs_dump(sizeof(lgn), &lgn);
11131
11132 cpylen = copy_from_user(&nwcStr, lgn.pDomainName, sizeof(nwcStr));
11133 DbgPrint("NwLoginIdentity: DomainName\n");
11134 - mydump(sizeof(nwcStr), &nwcStr);
11135 + novfs_dump(sizeof(nwcStr), &nwcStr);
11136
11137 - if ((server.buffer = Novfs_Malloc(nwcStr.DataLen, GFP_KERNEL))) {
11138 + if ((server.buffer = kmalloc(nwcStr.DataLen, GFP_KERNEL))) {
11139 server.type = nwcStr.DataType;
11140 server.len = nwcStr.DataLen;
11141 - if (!copy_from_user
11142 - ((void *)server.buffer, nwcStr.pBuffer, server.len)) {
11143 + if (!copy_from_user((void *)server.buffer, nwcStr.pBuffer, server.len)) {
11144 DbgPrint("NwLoginIdentity: Server\n");
11145 - mydump(server.len, server.buffer);
11146 + novfs_dump(server.len, server.buffer);
11147
11148 - cpylen =
11149 - copy_from_user(&nwcStr, lgn.pObjectName,
11150 - sizeof(nwcStr));
11151 + cpylen = copy_from_user(&nwcStr, lgn.pObjectName, sizeof(nwcStr));
11152 DbgPrint("NwLoginIdentity: ObjectName\n");
11153 - mydump(sizeof(nwcStr), &nwcStr);
11154 + novfs_dump(sizeof(nwcStr), &nwcStr);
11155
11156 - if ((username.buffer =
11157 - Novfs_Malloc(nwcStr.DataLen, GFP_KERNEL))) {
11158 + if ((username.buffer = kmalloc(nwcStr.DataLen, GFP_KERNEL))) {
11159 username.type = nwcStr.DataType;
11160 username.len = nwcStr.DataLen;
11161 - if (!copy_from_user
11162 - ((void *)username.buffer, nwcStr.pBuffer,
11163 - username.len)) {
11164 + if (!copy_from_user((void *)username.buffer, nwcStr.pBuffer, username.len)) {
11165 DbgPrint("NwLoginIdentity: User\n");
11166 - mydump(username.len, username.buffer);
11167 + novfs_dump(username.len, username.buffer);
11168
11169 - cpylen =
11170 - copy_from_user(&nwcStr,
11171 - lgn.pPassword,
11172 - sizeof(nwcStr));
11173 + cpylen = copy_from_user(&nwcStr, lgn.pPassword, sizeof(nwcStr));
11174 DbgPrint("NwLoginIdentity: Password\n");
11175 - mydump(sizeof(nwcStr), &nwcStr);
11176 + novfs_dump(sizeof(nwcStr), &nwcStr);
11177
11178 - if ((password.buffer =
11179 - Novfs_Malloc(nwcStr.DataLen,
11180 - GFP_KERNEL))) {
11181 + if ((password.buffer = kmalloc(nwcStr.DataLen, GFP_KERNEL))) {
11182 password.type = nwcStr.DataType;
11183 password.len = nwcStr.DataLen;
11184 - if (!copy_from_user
11185 - ((void *)password.buffer,
11186 - nwcStr.pBuffer,
11187 - password.len)) {
11188 - retCode =
11189 - do_login(&server,
11190 - &username,
11191 - &password,
11192 - (HANDLE *)&lgn.AuthenticationId,
11193 - Session);
11194 + if (!copy_from_user((void *)password.buffer, nwcStr.pBuffer, password.len)) {
11195 + retCode = novfs_do_login(&server, &username, &password, (void **)&lgn.AuthenticationId, &Session);
11196 if (retCode) {
11197 lgn.AuthenticationId = 0;
11198 }
11199
11200 - plgn =
11201 - (NwcLoginIdentity *)
11202 - pdata->reqData;
11203 - cpylen =
11204 - copy_to_user(&plgn->
11205 - AuthenticationId,
11206 - &lgn.
11207 - AuthenticationId,
11208 - sizeof
11209 - (plgn->
11210 - AuthenticationId));
11211 -
11212 + plgn = (struct nwc_login_id *)pdata->reqData;
11213 + cpylen = copy_to_user(&plgn->AuthenticationId, &lgn.AuthenticationId, sizeof(plgn->AuthenticationId));
11214 }
11215 - memset(password.buffer, 0,
11216 - password.len);
11217 + memset(password.buffer, 0, password.len);
11218 kfree(password.buffer);
11219 }
11220 }
11221 @@ -563,633 +545,504 @@ int NwLoginIdentity(PXPLAT pdata, struct
11222 return (retCode);
11223 }
11224
11225 -/*++======================================================================*/
11226 -int NwAuthConnWithId(PXPLAT pdata, session_t Session)
11227 -/*
11228 - * Arguments:
11229 - *
11230 - * Returns:
11231 - *
11232 - * Abstract:
11233 - *
11234 - * Notes:
11235 - *
11236 - * Environment:
11237 - *
11238 - *========================================================================*/
11239 -{
11240 - NwcAuthenticateWithId pauth;
11241 - PNwdCAuthenticateWithId pDauth;
11242 - PXPLAT_CALL_REQUEST cmd;
11243 - PXPLAT_CALL_REPLY reply;
11244 +int novfs_auth_conn(struct novfs_xplat *pdata, struct novfs_schandle Session)
11245 +{
11246 + struct nwc_auth_with_id pauth;
11247 + struct nwc_auth_wid *pDauth;
11248 + struct novfs_xplat_call_request *cmd;
11249 + struct novfs_xplat_call_reply *reply;
11250 int retCode = -ENOMEM;
11251 unsigned long cmdlen, datalen, replylen, cpylen;
11252
11253 datalen = sizeof(*pDauth);
11254 cmdlen = datalen + sizeof(*cmd);
11255 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11256 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11257 + if (!cmd)
11258 + return -ENOMEM;
11259
11260 - if (cmd) {
11261 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11262 - cmd->Command.SequenceNumber = 0;
11263 - cmd->Command.SessionId = Session;
11264 - cmd->NwcCommand = NWC_AUTHENTICATE_CONN_WITH_ID;
11265 -
11266 - cpylen = copy_from_user(&pauth, pdata->reqData, sizeof(pauth));
11267 -
11268 - pDauth = (PNwdCAuthenticateWithId) cmd->data;
11269 - cmd->dataLen = datalen;
11270 - pDauth->AuthenticationId = pauth.AuthenticationId;
11271 - pDauth->ConnHandle = (HANDLE) (unsigned long) pauth.ConnHandle;
11272 -
11273 - retCode =
11274 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11275 - (void **)&reply, &replylen,
11276 - INTERRUPTIBLE);
11277 - if (reply) {
11278 - retCode = reply->Reply.ErrorCode;
11279 - kfree(reply);
11280 - }
11281 - kfree(cmd);
11282 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11283 + cmd->Command.SequenceNumber = 0;
11284 + cmd->Command.SessionId = Session;
11285 + cmd->NwcCommand = NWC_AUTHENTICATE_CONN_WITH_ID;
11286 +
11287 + cpylen = copy_from_user(&pauth, pdata->reqData, sizeof(pauth));
11288 +
11289 + pDauth = (struct nwc_auth_wid *) cmd->data;
11290 + cmd->dataLen = datalen;
11291 + pDauth->AuthenticationId = pauth.AuthenticationId;
11292 + pDauth->ConnHandle = (void *) (unsigned long) pauth.ConnHandle;
11293 +
11294 + retCode =
11295 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11296 + (void **)&reply, &replylen,
11297 + INTERRUPTIBLE);
11298 + if (reply) {
11299 + retCode = reply->Reply.ErrorCode;
11300 + kfree(reply);
11301 }
11302 return (retCode);
11303 }
11304
11305 -/*++======================================================================*/
11306 -int NwLicenseConn(PXPLAT pdata, session_t Session)
11307 -/*
11308 - * Arguments:
11309 - *
11310 - * Returns:
11311 - *
11312 - * Abstract:
11313 - *
11314 - * Notes:
11315 - *
11316 - * Environment:
11317 - *
11318 - *========================================================================*/
11319 -{
11320 - PXPLAT_CALL_REQUEST cmd;
11321 - PXPLAT_CALL_REPLY reply;
11322 - NwcLicenseConn lisc;
11323 - PNwdCLicenseConn pDLisc;
11324 +int novfs_license_conn(struct novfs_xplat *pdata, struct novfs_schandle Session)
11325 +{
11326 + struct novfs_xplat_call_request *cmd;
11327 + struct novfs_xplat_call_reply *reply;
11328 + struct nwc_license_conn lisc;
11329 + struct nwc_lisc_id * pDLisc;
11330 int retCode = -ENOMEM;
11331 unsigned long cmdlen, datalen, replylen, cpylen;
11332
11333 datalen = sizeof(*pDLisc);
11334 cmdlen = datalen + sizeof(*cmd);
11335 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11336 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11337 + if (!cmd)
11338 + return -ENOMEM;
11339
11340 - if (cmd) {
11341 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11342 - cmd->Command.SequenceNumber = 0;
11343 - cmd->Command.SessionId = Session;
11344 - cmd->NwcCommand = NWC_LICENSE_CONN;
11345 -
11346 - cpylen = copy_from_user(&lisc, pdata->reqData, sizeof(lisc));
11347 -
11348 - pDLisc = (PNwdCLicenseConn) cmd->data;
11349 - cmd->dataLen = datalen;
11350 - pDLisc->ConnHandle = (HANDLE) (unsigned long) lisc.ConnHandle;
11351 -
11352 - retCode =
11353 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11354 - (void **)&reply, &replylen,
11355 - INTERRUPTIBLE);
11356 - if (reply) {
11357 - retCode = reply->Reply.ErrorCode;
11358 - kfree(reply);
11359 - }
11360 - kfree(cmd);
11361 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11362 + cmd->Command.SequenceNumber = 0;
11363 + cmd->Command.SessionId = Session;
11364 + cmd->NwcCommand = NWC_LICENSE_CONN;
11365 +
11366 + cpylen = copy_from_user(&lisc, pdata->reqData, sizeof(lisc));
11367 +
11368 + pDLisc = (struct nwc_lisc_id *) cmd->data;
11369 + cmd->dataLen = datalen;
11370 + pDLisc->ConnHandle = (void *) (unsigned long) lisc.ConnHandle;
11371 +
11372 + retCode =
11373 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11374 + (void **)&reply, &replylen,
11375 + INTERRUPTIBLE);
11376 + if (reply) {
11377 + retCode = reply->Reply.ErrorCode;
11378 + kfree(reply);
11379 }
11380 + kfree(cmd);
11381 return (retCode);
11382 }
11383
11384 -/*++======================================================================*/
11385 -int NwLogoutIdentity(PXPLAT pdata, session_t Session)
11386 -/*
11387 - * Arguments:
11388 - *
11389 - * Returns:
11390 - *
11391 - * Abstract:
11392 - *
11393 - * Notes:
11394 - *
11395 - * Environment:
11396 - *
11397 - *========================================================================*/
11398 -{
11399 - PXPLAT_CALL_REQUEST cmd;
11400 - PXPLAT_CALL_REPLY reply;
11401 - NwcLogoutIdentity logout;
11402 - PNwdCLogoutIdentity pDLogout;
11403 +int novfs_logout_id(struct novfs_xplat *pdata, struct novfs_schandle Session)
11404 +{
11405 + struct novfs_xplat_call_request *cmd;
11406 + struct novfs_xplat_call_reply *reply;
11407 + struct nwc_lo_id logout, *pDLogout;
11408 int retCode = -ENOMEM;
11409 unsigned long cmdlen, datalen, replylen, cpylen;
11410
11411 datalen = sizeof(*pDLogout);
11412 cmdlen = datalen + sizeof(*cmd);
11413 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11414 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11415
11416 - if (cmd) {
11417 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11418 - cmd->Command.SequenceNumber = 0;
11419 - cmd->Command.SessionId = Session;
11420 - cmd->NwcCommand = NWC_LOGOUT_IDENTITY;
11421 + if (!cmd)
11422 + return -ENOMEM;
11423 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11424 + cmd->Command.SequenceNumber = 0;
11425 + cmd->Command.SessionId = Session;
11426 + cmd->NwcCommand = NWC_LOGOUT_IDENTITY;
11427
11428 - cpylen =
11429 - copy_from_user(&logout, pdata->reqData, sizeof(logout));
11430 + cpylen =
11431 + copy_from_user(&logout, pdata->reqData, sizeof(logout));
11432
11433 - pDLogout = (PNwdCLogoutIdentity) cmd->data;
11434 - cmd->dataLen = datalen;
11435 - pDLogout->AuthenticationId = logout.AuthenticationId;
11436 -
11437 - retCode =
11438 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11439 - (void **)&reply, &replylen,
11440 - INTERRUPTIBLE);
11441 - if (reply) {
11442 - retCode = reply->Reply.ErrorCode;
11443 - kfree(reply);
11444 - }
11445 - kfree(cmd);
11446 + pDLogout = (struct nwc_lo_id *) cmd->data;
11447 + cmd->dataLen = datalen;
11448 + pDLogout->AuthenticationId = logout.AuthenticationId;
11449 +
11450 + retCode =
11451 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11452 + (void **)&reply, &replylen,
11453 + INTERRUPTIBLE);
11454 + if (reply) {
11455 + retCode = reply->Reply.ErrorCode;
11456 + kfree(reply);
11457 }
11458 + kfree(cmd);
11459 return (retCode);
11460 }
11461
11462 -/*++======================================================================*/
11463 -int NwUnlicenseConn(PXPLAT pdata, session_t Session)
11464 -/*
11465 - * Arguments:
11466 - *
11467 - * Returns:
11468 - *
11469 - * Abstract:
11470 - *
11471 - * Notes:
11472 - *
11473 - * Environment:
11474 - *
11475 - *========================================================================*/
11476 -{
11477 - PXPLAT_CALL_REQUEST cmd;
11478 - PXPLAT_CALL_REPLY reply;
11479 - PNwdCUnlicenseConn pUconn;
11480 - NwcUnlicenseConn ulc;
11481 +int novfs_unlicense_conn(struct novfs_xplat *pdata, struct novfs_schandle Session)
11482 +{
11483 + struct novfs_xplat_call_request *cmd;
11484 + struct novfs_xplat_call_reply *reply;
11485 + struct nwc_unlic_conn *pUconn, ulc;
11486 int retCode = -ENOMEM;
11487 unsigned long cmdlen, datalen, replylen, cpylen;
11488
11489 cpylen = copy_from_user(&ulc, pdata->reqData, sizeof(ulc));
11490 datalen = sizeof(*pUconn);
11491 cmdlen = datalen + sizeof(*cmd);
11492 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11493 - if (cmd) {
11494 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11495 - cmd->Command.SequenceNumber = 0;
11496 - cmd->Command.SessionId = Session;
11497 - cmd->NwcCommand = NWC_UNLICENSE_CONN;
11498 - cmd->dataLen = datalen;
11499 - pUconn = (PNwdCUnlicenseConn) cmd->data;
11500 -
11501 - pUconn->ConnHandle = (HANDLE) (unsigned long) ulc.ConnHandle;
11502 - retCode =
11503 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11504 - (void **)&reply, &replylen,
11505 - INTERRUPTIBLE);
11506 - if (reply) {
11507 - /*
11508 - * we got reply data from the daemon
11509 - */
11510 - retCode = reply->Reply.ErrorCode;
11511 - kfree(reply);
11512 - }
11513 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11514 + if (!cmd)
11515 + return -ENOMEM;
11516 +
11517 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11518 + cmd->Command.SequenceNumber = 0;
11519 + cmd->Command.SessionId = Session;
11520 + cmd->NwcCommand = NWC_UNLICENSE_CONN;
11521 + cmd->dataLen = datalen;
11522 + pUconn = (struct nwc_unlic_conn *) cmd->data;
11523
11524 - kfree(cmd);
11525 + pUconn->ConnHandle = (void *) (unsigned long) ulc.ConnHandle;
11526 + retCode =
11527 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11528 + (void **)&reply, &replylen,
11529 + INTERRUPTIBLE);
11530 + if (reply) {
11531 + /*
11532 + * we got reply data from the daemon
11533 + */
11534 + retCode = reply->Reply.ErrorCode;
11535 + kfree(reply);
11536 }
11537 return (retCode);
11538
11539 }
11540
11541 -/*++======================================================================*/
11542 -int NwUnAuthenticate(PXPLAT pdata, session_t Session)
11543 -/*
11544 - * Arguments:
11545 - *
11546 - * Returns:
11547 - *
11548 - * Abstract:
11549 - *
11550 - * Notes:
11551 - *
11552 - * Environment:
11553 - *
11554 - *========================================================================*/
11555 -{
11556 - PXPLAT_CALL_REQUEST cmd;
11557 - PXPLAT_CALL_REPLY reply;
11558 - NwcUnauthenticate auth;
11559 - PNwdCUnauthenticate pDAuth;
11560 +int novfs_unauthenticate(struct novfs_xplat *pdata, struct novfs_schandle Session)
11561 +{
11562 + struct novfs_xplat_call_request *cmd;
11563 + struct novfs_xplat_call_reply *reply;
11564 + struct nwc_unauthenticate auth, *pDAuth;
11565 int retCode = -ENOMEM;
11566 unsigned long cmdlen, datalen, replylen, cpylen;
11567
11568 datalen = sizeof(*pDAuth);
11569 cmdlen = datalen + sizeof(*cmd);
11570 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11571 + cmd = (struct novfs_xplat_call_request *)kmalloc(cmdlen, GFP_KERNEL);
11572
11573 - if (cmd) {
11574 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11575 - cmd->Command.SequenceNumber = 0;
11576 - cmd->Command.SessionId = Session;
11577 - cmd->NwcCommand = NWC_UNAUTHENTICATE_CONN;
11578 -
11579 - cpylen = copy_from_user(&auth, pdata->reqData, sizeof(auth));
11580 -
11581 - pDAuth = (PNwdCUnauthenticate) cmd->data;
11582 - cmd->dataLen = datalen;
11583 - pDAuth->AuthenticationId = auth.AuthenticationId;
11584 - pDAuth->ConnHandle = (HANDLE) (unsigned long) auth.ConnHandle;
11585 -
11586 - retCode =
11587 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11588 - (void **)&reply, &replylen,
11589 - INTERRUPTIBLE);
11590 - if (reply) {
11591 - retCode = reply->Reply.ErrorCode;
11592 - kfree(reply);
11593 - }
11594 - kfree(cmd);
11595 + if (!cmd)
11596 + return -ENOMEM;
11597 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11598 + cmd->Command.SequenceNumber = 0;
11599 + cmd->Command.SessionId = Session;
11600 + cmd->NwcCommand = NWC_UNAUTHENTICATE_CONN;
11601 +
11602 + cpylen = copy_from_user(&auth, pdata->reqData, sizeof(auth));
11603 +
11604 + pDAuth = (struct nwc_unauthenticate *) cmd->data;
11605 + cmd->dataLen = datalen;
11606 + pDAuth->AuthenticationId = auth.AuthenticationId;
11607 + pDAuth->ConnHandle = (void *) (unsigned long) auth.ConnHandle;
11608 +
11609 + retCode =
11610 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11611 + (void **)&reply, &replylen,
11612 + INTERRUPTIBLE);
11613 + if (reply) {
11614 + retCode = reply->Reply.ErrorCode;
11615 + kfree(reply);
11616 }
11617 + kfree(cmd);
11618 return (retCode);
11619
11620 }
11621
11622 -/*++======================================================================*/
11623 -int NwGetConnInfo(PXPLAT pdata, session_t Session)
11624 -/*
11625 - * Arguments:
11626 - *
11627 - * Returns:
11628 - *
11629 - * Abstract:
11630 - *
11631 - * Notes:
11632 - *
11633 - * Environment:
11634 - *
11635 - *========================================================================*/
11636 -{
11637 - PXPLAT_CALL_REQUEST cmd;
11638 - PXPLAT_CALL_REPLY reply;
11639 - NwcGetConnInfo connInfo;
11640 - PNwdCGetConnInfo pDConnInfo;
11641 +int novfs_get_conn_info(struct novfs_xplat *pdata, struct novfs_schandle Session)
11642 +{
11643 + struct novfs_xplat_call_request *cmd;
11644 + struct novfs_xplat_call_reply *reply;
11645 + struct nwc_get_conn_info connInfo;
11646 + struct nwd_conn_info *pDConnInfo;
11647 int retCode = -ENOMEM;
11648 unsigned long cmdlen, replylen, cpylen;
11649
11650 cmdlen = sizeof(*cmd) + sizeof(*pDConnInfo);
11651 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11652 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11653 cpylen =
11654 - copy_from_user(&connInfo, pdata->reqData, sizeof(NwcGetConnInfo));
11655 + copy_from_user(&connInfo, pdata->reqData, sizeof(struct nwc_get_conn_info));
11656
11657 - if (cmd) {
11658 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11659 - cmd->Command.SequenceNumber = 0;
11660 - cmd->Command.SessionId = Session;
11661 - cmd->NwcCommand = NWC_GET_CONN_INFO;
11662 -
11663 - pDConnInfo = (PNwdCGetConnInfo) cmd->data;
11664 -
11665 - pDConnInfo->ConnHandle = (HANDLE) (unsigned long) connInfo.ConnHandle;
11666 - pDConnInfo->uInfoLevel = connInfo.uInfoLevel;
11667 - pDConnInfo->uInfoLength = connInfo.uInfoLength;
11668 - cmd->dataLen = sizeof(*pDConnInfo);
11669 -
11670 - retCode =
11671 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11672 - (void **)&reply, &replylen,
11673 - INTERRUPTIBLE);
11674 - if (reply) {
11675 - retCode = reply->Reply.ErrorCode;
11676 - if (!retCode) {
11677 - GetConnData(&connInfo, cmd, reply);
11678 - }
11679 + if (!cmd)
11680 + return -ENOMEM;
11681 +
11682 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11683 + cmd->Command.SequenceNumber = 0;
11684 + cmd->Command.SessionId = Session;
11685 + cmd->NwcCommand = NWC_GET_CONN_INFO;
11686
11687 - kfree(reply);
11688 + pDConnInfo = (struct nwd_conn_info *) cmd->data;
11689 +
11690 + pDConnInfo->ConnHandle = (void *) (unsigned long) connInfo.ConnHandle;
11691 + pDConnInfo->uInfoLevel = connInfo.uInfoLevel;
11692 + pDConnInfo->uInfoLength = connInfo.uInfoLength;
11693 + cmd->dataLen = sizeof(*pDConnInfo);
11694 +
11695 + retCode =
11696 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11697 + (void **)&reply, &replylen,
11698 + INTERRUPTIBLE);
11699 + if (reply) {
11700 + retCode = reply->Reply.ErrorCode;
11701 + if (!retCode) {
11702 + GetConnData(&connInfo, cmd, reply);
11703 }
11704 - kfree(cmd);
11705
11706 + kfree(reply);
11707 }
11708 -
11709 + kfree(cmd);
11710 return (retCode);
11711
11712 }
11713
11714 -/*++======================================================================*/
11715 -int NwSetConnInfo(PXPLAT pdata, session_t Session)
11716 -/*
11717 - * Arguments:
11718 - *
11719 - * Returns:
11720 - *
11721 - * Abstract:
11722 - *
11723 - * Notes:
11724 - *
11725 - * Environment:
11726 - *
11727 - *========================================================================*/
11728 -{
11729 - PXPLAT_CALL_REQUEST cmd;
11730 - PXPLAT_CALL_REPLY reply;
11731 - NwcSetConnInfo connInfo;
11732 - PNwdCSetConnInfo pDConnInfo;
11733 +int novfs_set_conn_info(struct novfs_xplat *pdata, struct novfs_schandle Session)
11734 +{
11735 + struct novfs_xplat_call_request *cmd;
11736 + struct novfs_xplat_call_reply *reply;
11737 + struct nwc_set_conn_info connInfo;
11738 + struct nwd_set_conn_info *pDConnInfo;
11739 int retCode = -ENOMEM;
11740 unsigned long cmdlen, replylen, cpylen;
11741
11742 cmdlen = sizeof(*cmd) + sizeof(*pDConnInfo);
11743 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11744 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11745 cpylen =
11746 - copy_from_user(&connInfo, pdata->reqData, sizeof(NwcSetConnInfo));
11747 + copy_from_user(&connInfo, pdata->reqData, sizeof(struct nwc_set_conn_info));
11748
11749 - if (cmd) {
11750 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11751 - cmd->Command.SequenceNumber = 0;
11752 - cmd->Command.SessionId = Session;
11753 - cmd->NwcCommand = NWC_SET_CONN_INFO;
11754 -
11755 - pDConnInfo = (PNwdCSetConnInfo) cmd->data;
11756 -
11757 - pDConnInfo->ConnHandle = (HANDLE) (unsigned long) connInfo.ConnHandle;
11758 - pDConnInfo->uInfoLevel = connInfo.uInfoLevel;
11759 - pDConnInfo->uInfoLength = connInfo.uInfoLength;
11760 - cmd->dataLen = sizeof(*pDConnInfo);
11761 -
11762 - retCode =
11763 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11764 - (void **)&reply, &replylen,
11765 - INTERRUPTIBLE);
11766 - if (reply) {
11767 - retCode = reply->Reply.ErrorCode;
11768 - kfree(reply);
11769 - }
11770 - kfree(cmd);
11771 + if (!cmd)
11772 + return -ENOMEM;
11773
11774 - }
11775 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11776 + cmd->Command.SequenceNumber = 0;
11777 + cmd->Command.SessionId = Session;
11778 + cmd->NwcCommand = NWC_SET_CONN_INFO;
11779
11780 + pDConnInfo = (struct nwd_set_conn_info *) cmd->data;
11781 +
11782 + pDConnInfo->ConnHandle = (void *) (unsigned long) connInfo.ConnHandle;
11783 + pDConnInfo->uInfoLevel = connInfo.uInfoLevel;
11784 + pDConnInfo->uInfoLength = connInfo.uInfoLength;
11785 + cmd->dataLen = sizeof(*pDConnInfo);
11786 +
11787 + retCode =
11788 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11789 + (void **)&reply, &replylen,
11790 + INTERRUPTIBLE);
11791 + if (reply) {
11792 + retCode = reply->Reply.ErrorCode;
11793 + kfree(reply);
11794 + }
11795 + kfree(cmd);
11796 return (retCode);
11797
11798 }
11799
11800 -/*++======================================================================*/
11801 -int NwGetIdentityInfo(PXPLAT pdata, session_t Session)
11802 -/*
11803 - * Arguments:
11804 - *
11805 - * Returns:
11806 - *
11807 - * Abstract:
11808 - *
11809 - * Notes:
11810 - *
11811 - * Environment:
11812 - *
11813 - *========================================================================*/
11814 -{
11815 - PXPLAT_CALL_REQUEST cmd;
11816 - PXPLAT_CALL_REPLY reply;
11817 - NwcGetIdentityInfo qidInfo, *gId;
11818 - PNwdCGetIdentityInfo idInfo;
11819 - NwcString xferStr;
11820 +int novfs_get_id_info(struct novfs_xplat *pdata, struct novfs_schandle Session)
11821 +{
11822 + struct novfs_xplat_call_request *cmd;
11823 + struct novfs_xplat_call_reply *reply;
11824 + struct nwc_get_id_info qidInfo, *gId;
11825 + struct nwd_get_id_info *idInfo;
11826 + struct nwc_string xferStr;
11827 char *str;
11828 int retCode = -ENOMEM;
11829 unsigned long cmdlen, replylen, cpylen;
11830
11831 cmdlen = sizeof(*cmd) + sizeof(*idInfo);
11832 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
11833 + cmd = kmalloc(cmdlen, GFP_KERNEL);
11834 cpylen = copy_from_user(&qidInfo, pdata->reqData, sizeof(qidInfo));
11835
11836 - if (cmd) {
11837 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11838 - cmd->Command.SequenceNumber = 0;
11839 - cmd->Command.SessionId = Session;
11840 - cmd->NwcCommand = NWC_GET_IDENTITY_INFO;
11841 -
11842 - idInfo = (PNwdCGetIdentityInfo) cmd->data;
11843 -
11844 - idInfo->AuthenticationId = qidInfo.AuthenticationId;
11845 - cmd->dataLen = sizeof(*idInfo);
11846 -
11847 - retCode =
11848 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11849 - (void **)&reply, &replylen,
11850 - INTERRUPTIBLE);
11851 - if (reply) {
11852 - retCode = reply->Reply.ErrorCode;
11853 -
11854 - if (!reply->Reply.ErrorCode) {
11855 - /*
11856 - * Save the return info to the user structure.
11857 - */
11858 - gId = pdata->reqData;
11859 - idInfo = (PNwdCGetIdentityInfo) reply->data;
11860 - cpylen =
11861 - copy_to_user(&gId->AuthenticationId,
11862 - &idInfo->AuthenticationId,
11863 - sizeof(idInfo->
11864 + if (!cmd)
11865 + return -ENOMEM;
11866 +
11867 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
11868 + cmd->Command.SequenceNumber = 0;
11869 + cmd->Command.SessionId = Session;
11870 + cmd->NwcCommand = NWC_GET_IDENTITY_INFO;
11871 +
11872 + idInfo = (struct nwd_get_id_info *) cmd->data;
11873 +
11874 + idInfo->AuthenticationId = qidInfo.AuthenticationId;
11875 + cmd->dataLen = sizeof(*idInfo);
11876 +
11877 + retCode =
11878 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
11879 + (void **)&reply, &replylen,
11880 + INTERRUPTIBLE);
11881 + if (reply) {
11882 + retCode = reply->Reply.ErrorCode;
11883 +
11884 + if (!reply->Reply.ErrorCode) {
11885 + /*
11886 + * Save the return info to the user structure.
11887 + */
11888 + gId = pdata->reqData;
11889 + idInfo = (struct nwd_get_id_info *) reply->data;
11890 + cpylen =
11891 + copy_to_user(&gId->AuthenticationId,
11892 + &idInfo->AuthenticationId,
11893 + sizeof(idInfo->
11894 AuthenticationId));
11895 - cpylen =
11896 - copy_to_user(&gId->AuthType,
11897 - &idInfo->AuthType,
11898 - sizeof(idInfo->AuthType));
11899 - cpylen =
11900 - copy_to_user(&gId->IdentityFlags,
11901 - &idInfo->IdentityFlags,
11902 - sizeof(idInfo->IdentityFlags));
11903 - cpylen =
11904 - copy_to_user(&gId->NameType,
11905 - &idInfo->NameType,
11906 - sizeof(idInfo->NameType));
11907 - cpylen =
11908 - copy_to_user(&gId->ObjectType,
11909 - &idInfo->ObjectType,
11910 - sizeof(idInfo->ObjectType));
11911 -
11912 - cpylen =
11913 - copy_from_user(&xferStr, gId->pDomainName,
11914 - sizeof(NwcString));
11915 - str =
11916 - (char *)((char *)reply->data +
11917 - idInfo->pDomainNameOffset);
11918 - cpylen =
11919 - copy_to_user(xferStr.pBuffer, str,
11920 - idInfo->domainLen);
11921 - xferStr.DataType = NWC_STRING_TYPE_ASCII;
11922 - xferStr.DataLen = idInfo->domainLen;
11923 - cpylen =
11924 - copy_to_user(gId->pDomainName, &xferStr,
11925 - sizeof(NwcString));
11926 -
11927 - cpylen =
11928 - copy_from_user(&xferStr, gId->pObjectName,
11929 - sizeof(NwcString));
11930 - str =
11931 - (char *)((char *)reply->data +
11932 - idInfo->pObjectNameOffset);
11933 - cpylen =
11934 - copy_to_user(xferStr.pBuffer, str,
11935 - idInfo->objectLen);
11936 - xferStr.DataLen = idInfo->objectLen - 1;
11937 - xferStr.DataType = NWC_STRING_TYPE_ASCII;
11938 - cpylen =
11939 - copy_to_user(gId->pObjectName, &xferStr,
11940 - sizeof(NwcString));
11941 - }
11942 + cpylen =
11943 + copy_to_user(&gId->AuthType,
11944 + &idInfo->AuthType,
11945 + sizeof(idInfo->AuthType));
11946 + cpylen =
11947 + copy_to_user(&gId->IdentityFlags,
11948 + &idInfo->IdentityFlags,
11949 + sizeof(idInfo->IdentityFlags));
11950 + cpylen =
11951 + copy_to_user(&gId->NameType,
11952 + &idInfo->NameType,
11953 + sizeof(idInfo->NameType));
11954 + cpylen =
11955 + copy_to_user(&gId->ObjectType,
11956 + &idInfo->ObjectType,
11957 + sizeof(idInfo->ObjectType));
11958
11959 - kfree(reply);
11960 + cpylen =
11961 + copy_from_user(&xferStr, gId->pDomainName,
11962 + sizeof(struct nwc_string));
11963 + str =
11964 + (char *)((char *)reply->data +
11965 + idInfo->pDomainNameOffset);
11966 + cpylen =
11967 + copy_to_user(xferStr.pBuffer, str,
11968 + idInfo->domainLen);
11969 + xferStr.DataType = NWC_STRING_TYPE_ASCII;
11970 + xferStr.DataLen = idInfo->domainLen;
11971 + cpylen =
11972 + copy_to_user(gId->pDomainName, &xferStr,
11973 + sizeof(struct nwc_string));
11974 +
11975 + cpylen =
11976 + copy_from_user(&xferStr, gId->pObjectName,
11977 + sizeof(struct nwc_string));
11978 + str =
11979 + (char *)((char *)reply->data +
11980 + idInfo->pObjectNameOffset);
11981 + cpylen =
11982 + copy_to_user(xferStr.pBuffer, str,
11983 + idInfo->objectLen);
11984 + xferStr.DataLen = idInfo->objectLen - 1;
11985 + xferStr.DataType = NWC_STRING_TYPE_ASCII;
11986 + cpylen =
11987 + copy_to_user(gId->pObjectName, &xferStr,
11988 + sizeof(struct nwc_string));
11989 }
11990 - kfree(cmd);
11991
11992 + kfree(reply);
11993 }
11994 -
11995 + kfree(cmd);
11996 return (retCode);
11997 }
11998
11999 -/*++======================================================================*/
12000 -int NwScanConnInfo(PXPLAT pdata, session_t Session)
12001 -/*
12002 - * Arguments:
12003 - *
12004 - * Returns:
12005 - *
12006 - * Abstract:
12007 - *
12008 - * Notes:
12009 - *
12010 - * Environment:
12011 - *
12012 - *========================================================================*/
12013 -{
12014 - PXPLAT_CALL_REQUEST cmd;
12015 - PXPLAT_CALL_REPLY reply;
12016 - NwcScanConnInfo connInfo, *rInfo;
12017 - PNwdCScanConnInfo pDConnInfo;
12018 +int novfs_scan_conn_info(struct novfs_xplat *pdata, struct novfs_schandle Session)
12019 +{
12020 + struct novfs_xplat_call_request *cmd;
12021 + struct novfs_xplat_call_reply *reply;
12022 + struct nwc_scan_conn_info connInfo, *rInfo;
12023 + struct nwd_scan_conn_info *pDConnInfo;
12024 int retCode = -ENOMEM;
12025 unsigned long cmdlen, replylen, cpylen;
12026 unsigned char *localData;
12027
12028 cpylen =
12029 - copy_from_user(&connInfo, pdata->reqData, sizeof(NwcScanConnInfo));
12030 + copy_from_user(&connInfo, pdata->reqData, sizeof(struct nwc_scan_conn_info));
12031
12032 cmdlen = sizeof(*cmd) + sizeof(*pDConnInfo) + connInfo.uScanInfoLen;
12033 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
12034 + cmd = kmalloc(cmdlen, GFP_KERNEL);
12035 + if (!cmd)
12036 + return -ENOMEM;
12037
12038 - if (cmd) {
12039 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12040 - cmd->Command.SequenceNumber = 0;
12041 - cmd->Command.SessionId = Session;
12042 - cmd->NwcCommand = NWC_SCAN_CONN_INFO;
12043 -
12044 - pDConnInfo = (PNwdCScanConnInfo) cmd->data;
12045 -
12046 - DbgPrint("NwScanConnInfo: Input Data\n");
12047 - DbgPrint("connInfo.uScanIndex = 0x%X\n", connInfo.uScanIndex);
12048 - DbgPrint("connInfo.uConnectionReference = 0x%X\n",
12049 - connInfo.uConnectionReference);
12050 - DbgPrint("connInfo.uScanInfoLevel = 0x%X\n",
12051 - connInfo.uScanInfoLevel);
12052 - DbgPrint("connInfo.uScanInfoLen = 0x%X\n",
12053 - connInfo.uScanInfoLen);
12054 - DbgPrint("connInfo.uReturnInfoLength = 0x%X\n",
12055 - connInfo.uReturnInfoLength);
12056 - DbgPrint("connInfo.uReturnInfoLevel = 0x%X\n",
12057 - connInfo.uReturnInfoLevel);
12058 - DbgPrint("connInfo.uScanFlags = 0x%X\n", connInfo.uScanFlags);
12059 -
12060 - pDConnInfo->uScanIndex = connInfo.uScanIndex;
12061 - pDConnInfo->uConnectionReference =
12062 - connInfo.uConnectionReference;
12063 - pDConnInfo->uScanInfoLevel = connInfo.uScanInfoLevel;
12064 - pDConnInfo->uScanInfoLen = connInfo.uScanInfoLen;
12065 - pDConnInfo->uReturnInfoLength = connInfo.uReturnInfoLength;
12066 - pDConnInfo->uReturnInfoLevel = connInfo.uReturnInfoLevel;
12067 - pDConnInfo->uScanFlags = connInfo.uScanFlags;
12068 -
12069 - if (pDConnInfo->uScanInfoLen) {
12070 - localData = (unsigned char *) pDConnInfo;
12071 - pDConnInfo->uScanConnInfoOffset = sizeof(*pDConnInfo);
12072 - localData += pDConnInfo->uScanConnInfoOffset;
12073 - cpylen =
12074 - copy_from_user(localData, connInfo.pScanConnInfo,
12075 - connInfo.uScanInfoLen);
12076 - } else {
12077 - pDConnInfo->uScanConnInfoOffset = 0;
12078 - }
12079 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12080 + cmd->Command.SequenceNumber = 0;
12081 + cmd->Command.SessionId = Session;
12082 + cmd->NwcCommand = NWC_SCAN_CONN_INFO;
12083 +
12084 + pDConnInfo = (struct nwd_scan_conn_info *) cmd->data;
12085 +
12086 + DbgPrint("NwScanConnInfo: Input Data\n");
12087 + DbgPrint("connInfo.uScanIndex = 0x%X\n", connInfo.uScanIndex);
12088 + DbgPrint("connInfo.uConnectionReference = 0x%X\n",
12089 + connInfo.uConnectionReference);
12090 + DbgPrint("connInfo.uScanInfoLevel = 0x%X\n",
12091 + connInfo.uScanInfoLevel);
12092 + DbgPrint("connInfo.uScanInfoLen = 0x%X\n",
12093 + connInfo.uScanInfoLen);
12094 + DbgPrint("connInfo.uReturnInfoLength = 0x%X\n",
12095 + connInfo.uReturnInfoLength);
12096 + DbgPrint("connInfo.uReturnInfoLevel = 0x%X\n",
12097 + connInfo.uReturnInfoLevel);
12098 + DbgPrint("connInfo.uScanFlags = 0x%X\n", connInfo.uScanFlags);
12099 +
12100 + pDConnInfo->uScanIndex = connInfo.uScanIndex;
12101 + pDConnInfo->uConnectionReference =
12102 + connInfo.uConnectionReference;
12103 + pDConnInfo->uScanInfoLevel = connInfo.uScanInfoLevel;
12104 + pDConnInfo->uScanInfoLen = connInfo.uScanInfoLen;
12105 + pDConnInfo->uReturnInfoLength = connInfo.uReturnInfoLength;
12106 + pDConnInfo->uReturnInfoLevel = connInfo.uReturnInfoLevel;
12107 + pDConnInfo->uScanFlags = connInfo.uScanFlags;
12108 +
12109 + if (pDConnInfo->uScanInfoLen) {
12110 + localData = (unsigned char *) pDConnInfo;
12111 + pDConnInfo->uScanConnInfoOffset = sizeof(*pDConnInfo);
12112 + localData += pDConnInfo->uScanConnInfoOffset;
12113 + cpylen =
12114 + copy_from_user(localData, connInfo.pScanConnInfo,
12115 + connInfo.uScanInfoLen);
12116 + } else {
12117 + pDConnInfo->uScanConnInfoOffset = 0;
12118 + }
12119 +
12120 + cmd->dataLen = sizeof(*pDConnInfo);
12121
12122 - cmd->dataLen = sizeof(*pDConnInfo);
12123 + retCode =
12124 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12125 + (void **)&reply, &replylen,
12126 + INTERRUPTIBLE);
12127 + if (reply) {
12128 + DbgPrint("NwScanConnInfo: Reply recieved\n");
12129 + DbgPrint(" NextIndex = %x\n", connInfo.uScanIndex);
12130 + DbgPrint(" ErrorCode = %x\n", reply->Reply.ErrorCode);
12131 + DbgPrint(" data = %x\n", reply->data);
12132
12133 - retCode =
12134 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12135 - (void **)&reply, &replylen,
12136 - INTERRUPTIBLE);
12137 - if (reply) {
12138 - DbgPrint("NwScanConnInfo: Reply recieved\n");
12139 - DbgPrint(" NextIndex = %x\n", connInfo.uScanIndex);
12140 - DbgPrint(" ErrorCode = %x\n", reply->Reply.ErrorCode);
12141 - DbgPrint(" data = %x\n", reply->data);
12142 -
12143 - pDConnInfo = (PNwdCScanConnInfo) reply->data;
12144 - retCode = (unsigned long) reply->Reply.ErrorCode;
12145 - if (!retCode) {
12146 - GetUserData(&connInfo, cmd, reply);
12147 - rInfo = (NwcScanConnInfo *) pdata->repData;
12148 - cpylen =
12149 - copy_to_user(pdata->repData,
12150 - &pDConnInfo->uScanIndex,
12151 - sizeof(pDConnInfo->
12152 + pDConnInfo = (struct nwd_scan_conn_info *) reply->data;
12153 + retCode = (unsigned long) reply->Reply.ErrorCode;
12154 + if (!retCode) {
12155 + GetUserData(&connInfo, cmd, reply);
12156 + rInfo = (struct nwc_scan_conn_info *) pdata->repData;
12157 + cpylen =
12158 + copy_to_user(pdata->repData,
12159 + &pDConnInfo->uScanIndex,
12160 + sizeof(pDConnInfo->
12161 uScanIndex));
12162 - cpylen =
12163 - copy_to_user(&rInfo->uConnectionReference,
12164 - &pDConnInfo->
12165 - uConnectionReference,
12166 - sizeof(pDConnInfo->
12167 + cpylen =
12168 + copy_to_user(&rInfo->uConnectionReference,
12169 + &pDConnInfo->
12170 + uConnectionReference,
12171 + sizeof(pDConnInfo->
12172 uConnectionReference));
12173 - } else {
12174 - unsigned long x;
12175 + } else {
12176 + unsigned long x;
12177
12178 - x = 0;
12179 - rInfo = (NwcScanConnInfo *) pdata->reqData;
12180 - cpylen =
12181 - copy_to_user(&rInfo->uConnectionReference,
12182 - &x,
12183 - sizeof(rInfo->
12184 + x = 0;
12185 + rInfo = (struct nwc_scan_conn_info *) pdata->reqData;
12186 + cpylen =
12187 + copy_to_user(&rInfo->uConnectionReference,
12188 + &x,
12189 + sizeof(rInfo->
12190 uConnectionReference));
12191 - }
12192 -
12193 - kfree(reply);
12194 - } else {
12195 - retCode = -EIO;
12196 }
12197 - kfree(cmd);
12198
12199 + kfree(reply);
12200 + } else {
12201 + retCode = -EIO;
12202 }
12203 -
12204 + kfree(cmd);
12205 return (retCode);
12206 }
12207
12208 -/*++======================================================================*/
12209 -static void GetUserData(NwcScanConnInfo * connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply)
12210 /*
12211 - * Abstract: Copies the user data out of the scan conn info call.
12212 - *
12213 - *========================================================================*/
12214 + * Copies the user data out of the scan conn info call.
12215 + */
12216 +static void GetUserData(struct nwc_scan_conn_info * connInfo, struct novfs_xplat_call_request *cmd, struct novfs_xplat_call_reply *reply)
12217 {
12218 unsigned long uLevel;
12219 - PNwdCScanConnInfo pDConnInfo;
12220 + struct nwd_scan_conn_info *pDConnInfo;
12221
12222 unsigned char *srcData = NULL;
12223 unsigned long dataLen = 0, cpylen;
12224
12225 - pDConnInfo = (PNwdCScanConnInfo) reply->data;
12226 + pDConnInfo = (struct nwd_scan_conn_info *) reply->data;
12227 uLevel = pDConnInfo->uReturnInfoLevel;
12228 DbgPrint
12229 ("[GetUserData] uLevel = %d, reply = 0x%p, reply->data = 0x%X\n",
12230 @@ -1224,7 +1077,7 @@ static void GetUserData(NwcScanConnInfo
12231 case NWC_CONN_INFO_TRAN_ADDR:
12232 {
12233 unsigned char *dstData = connInfo->pReturnConnInfo;
12234 - NwcTranAddr tranAddr;
12235 + struct nwc_tran_addr tranAddr;
12236
12237 srcData = (unsigned char *) reply->data;
12238 dataLen = reply->dataLen;
12239 @@ -1238,20 +1091,20 @@ static void GetUserData(NwcScanConnInfo
12240 sizeof(tranAddr));
12241
12242 srcData +=
12243 - ((PNwdCScanConnInfo) srcData)->
12244 + ((struct nwd_scan_conn_info *) srcData)->
12245 uReturnConnInfoOffset;
12246
12247 tranAddr.uTransportType =
12248 - ((PNwdTranAddr) srcData)->uTransportType;
12249 + ((struct nwd_tran_addr *) srcData)->uTransportType;
12250 tranAddr.uAddressLength =
12251 - ((PNwdTranAddr) srcData)->uAddressLength;
12252 + ((struct tagNwdTranAddrEx *) srcData)->uAddressLength;
12253
12254 cpylen =
12255 copy_to_user(dstData, &tranAddr, sizeof(tranAddr));
12256 cpylen =
12257 copy_to_user(tranAddr.puAddress,
12258 - ((PNwdTranAddr) srcData)->Buffer,
12259 - ((PNwdTranAddr) srcData)->
12260 + ((struct tagNwdTranAddrEx *) srcData)->Buffer,
12261 + ((struct tagNwdTranAddrEx *) srcData)->
12262 uAddressLength);
12263 dataLen = 0;
12264 break;
12265 @@ -1276,20 +1129,18 @@ static void GetUserData(NwcScanConnInfo
12266 return;
12267 }
12268
12269 -/*++======================================================================*/
12270 -static void GetConnData(NwcGetConnInfo * connInfo, PXPLAT_CALL_REQUEST cmd, PXPLAT_CALL_REPLY reply)
12271 /*
12272 - * Abstract: Copies the user data out of the scan conn info call.
12273 - *
12274 - *========================================================================*/
12275 + * Copies the user data out of the scan conn info call.
12276 + */
12277 +static void GetConnData(struct nwc_get_conn_info * connInfo, struct novfs_xplat_call_request *cmd, struct novfs_xplat_call_reply *reply)
12278 {
12279 unsigned long uLevel;
12280 - PNwdCGetConnInfo pDConnInfo;
12281 + struct nwd_conn_info * pDConnInfo;
12282
12283 unsigned char *srcData = NULL;
12284 unsigned long dataLen = 0, cpylen;
12285
12286 - pDConnInfo = (PNwdCGetConnInfo) cmd->data;
12287 + pDConnInfo = (struct nwd_conn_info *) cmd->data;
12288 uLevel = pDConnInfo->uInfoLevel;
12289
12290 switch (uLevel) {
12291 @@ -1305,7 +1156,7 @@ static void GetConnData(NwcGetConnInfo *
12292 case NWC_CONN_INFO_TRAN_ADDR:
12293 {
12294 unsigned char *dstData = connInfo->pConnInfo;
12295 - NwcTranAddr tranAddr;
12296 + struct nwc_tran_addr tranAddr;
12297
12298 srcData = (unsigned char *) reply->data;
12299
12300 @@ -1313,16 +1164,16 @@ static void GetConnData(NwcGetConnInfo *
12301 copy_from_user(&tranAddr, dstData,
12302 sizeof(tranAddr));
12303 tranAddr.uTransportType =
12304 - ((PNwdTranAddr) srcData)->uTransportType;
12305 + ((struct tagNwdTranAddrEx *) srcData)->uTransportType;
12306 tranAddr.uAddressLength =
12307 - ((PNwdTranAddr) srcData)->uAddressLength;
12308 + ((struct tagNwdTranAddrEx *) srcData)->uAddressLength;
12309
12310 cpylen =
12311 copy_to_user(dstData, &tranAddr, sizeof(tranAddr));
12312 cpylen =
12313 copy_to_user(tranAddr.puAddress,
12314 - ((PNwdTranAddr) srcData)->Buffer,
12315 - ((PNwdTranAddr) srcData)->
12316 + ((struct tagNwdTranAddrEx *) srcData)->Buffer,
12317 + ((struct tagNwdTranAddrEx *) srcData)->
12318 uAddressLength);
12319 dataLen = 0;
12320 break;
12321 @@ -1376,343 +1227,282 @@ static void GetConnData(NwcGetConnInfo *
12322 return;
12323 }
12324
12325 -/*++======================================================================*/
12326 -int NwGetDaemonVersion(PXPLAT pdata, session_t Session)
12327 -/*
12328 - * Arguments:
12329 - *
12330 - * Returns:
12331 - *
12332 - * Abstract:
12333 - *
12334 - * Notes:
12335 - *
12336 - * Environment:
12337 - *
12338 - *========================================================================*/
12339 -{
12340 - PXPLAT_CALL_REQUEST cmd;
12341 - PXPLAT_CALL_REPLY reply;
12342 - PNwdCGetRequesterVersion pDVersion;
12343 +int novfs_get_daemon_ver(struct novfs_xplat *pdata, struct novfs_schandle Session)
12344 +{
12345 + struct novfs_xplat_call_request *cmd;
12346 + struct novfs_xplat_call_reply *reply;
12347 + struct nwd_get_reqversion *pDVersion;
12348 int retCode = -ENOMEM;
12349 unsigned long cmdlen, datalen, replylen, cpylen;
12350
12351 datalen = sizeof(*pDVersion);
12352 cmdlen = datalen + sizeof(*cmd);
12353 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
12354 -
12355 - if (cmd) {
12356 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12357 - cmd->Command.SequenceNumber = 0;
12358 - cmd->Command.SessionId = Session;
12359 - cmd->NwcCommand = NWC_GET_REQUESTER_VERSION;
12360 - cmdlen = sizeof(*cmd);
12361 - retCode =
12362 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12363 - (void **)&reply, &replylen,
12364 - INTERRUPTIBLE);
12365 - if (reply) {
12366 - retCode = reply->Reply.ErrorCode;
12367 - pDVersion = (PNwdCGetRequesterVersion) reply->data;
12368 - cpylen =
12369 - copy_to_user(pDVersion, pdata->reqData,
12370 - sizeof(*pDVersion));
12371 - kfree(reply);
12372 - }
12373 - kfree(cmd);
12374 - }
12375 - return (retCode);
12376 -
12377 -}
12378 + cmd = kmalloc(cmdlen, GFP_KERNEL);
12379 + if (!cmd)
12380 + return -ENOMEM;
12381
12382 -/*++======================================================================*/
12383 -int NwcGetPreferredDSTree(PXPLAT pdata, session_t Session)
12384 -/*
12385 - * Arguments:
12386 - *
12387 - * Returns:
12388 - *
12389 - * Abstract:
12390 - *
12391 - * Notes:
12392 - *
12393 - * Environment:
12394 - *
12395 - *========================================================================*/
12396 -{
12397 - PXPLAT_CALL_REQUEST cmd;
12398 - PXPLAT_CALL_REPLY reply;
12399 - PNwdCGetPreferredDsTree pDGetTree;
12400 - NwcGetPreferredDsTree xplatCall, *p;
12401 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12402 + cmd->Command.SequenceNumber = 0;
12403 + cmd->Command.SessionId = Session;
12404 + cmd->NwcCommand = NWC_GET_REQUESTER_VERSION;
12405 + cmdlen = sizeof(*cmd);
12406 + retCode =
12407 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12408 + (void **)&reply, &replylen,
12409 + INTERRUPTIBLE);
12410 + if (reply) {
12411 + retCode = reply->Reply.ErrorCode;
12412 + pDVersion = (struct nwd_get_reqversion *) reply->data;
12413 + cpylen =
12414 + copy_to_user(pDVersion, pdata->reqData,
12415 + sizeof(*pDVersion));
12416 + kfree(reply);
12417 + }
12418 + kfree(cmd);
12419 + return (retCode);
12420 +
12421 +}
12422 +
12423 +int novfs_get_preferred_DS_tree(struct novfs_xplat *pdata, struct novfs_schandle Session)
12424 +{
12425 + struct novfs_xplat_call_request *cmd;
12426 + struct novfs_xplat_call_reply *reply;
12427 + struct nwd_get_pref_ds_tree *pDGetTree;
12428 + struct nwc_get_pref_ds_tree xplatCall, *p;
12429 int retCode = -ENOMEM;
12430 unsigned long cmdlen, datalen, replylen, cpylen;
12431 unsigned char *dPtr;
12432
12433 cpylen =
12434 copy_from_user(&xplatCall, pdata->reqData,
12435 - sizeof(NwcGetPreferredDsTree));
12436 + sizeof(struct nwc_get_pref_ds_tree));
12437 datalen = sizeof(*pDGetTree) + xplatCall.uTreeLength;
12438 cmdlen = datalen + sizeof(*cmd);
12439 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
12440 + cmd = kmalloc(cmdlen, GFP_KERNEL);
12441
12442 - if (cmd) {
12443 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12444 - cmd->Command.SequenceNumber = 0;
12445 - cmd->Command.SessionId = Session;
12446 - cmd->NwcCommand = NWC_GET_PREFERRED_DS_TREE;
12447 - cmdlen = sizeof(*cmd);
12448 -
12449 - retCode =
12450 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12451 - (void **)&reply, &replylen,
12452 - INTERRUPTIBLE);
12453 - if (reply) {
12454 - retCode = reply->Reply.ErrorCode;
12455 - if (!retCode) {
12456 - pDGetTree =
12457 - (PNwdCGetPreferredDsTree) reply->data;
12458 - dPtr =
12459 - reply->data + pDGetTree->DsTreeNameOffset;
12460 - p = (NwcGetPreferredDsTree *) pdata->reqData;
12461 -
12462 - DbgPrint
12463 - ("NwcGetPreferredDSTree: Reply recieved\n");
12464 - DbgPrint(" TreeLen = %x\n",
12465 - pDGetTree->uTreeLength);
12466 - DbgPrint(" TreeName = %s\n", dPtr);
12467 -
12468 - cpylen =
12469 - copy_to_user(p, &pDGetTree->uTreeLength, 4);
12470 - cpylen =
12471 - copy_to_user(xplatCall.pDsTreeName, dPtr,
12472 - pDGetTree->uTreeLength);
12473 - }
12474 - kfree(reply);
12475 + if (!cmd)
12476 + return -ENOMEM;
12477 +
12478 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12479 + cmd->Command.SequenceNumber = 0;
12480 + cmd->Command.SessionId = Session;
12481 + cmd->NwcCommand = NWC_GET_PREFERRED_DS_TREE;
12482 + cmdlen = sizeof(*cmd);
12483 +
12484 + retCode =
12485 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12486 + (void **)&reply, &replylen,
12487 + INTERRUPTIBLE);
12488 + if (reply) {
12489 + retCode = reply->Reply.ErrorCode;
12490 + if (!retCode) {
12491 + pDGetTree =
12492 + (struct nwd_get_pref_ds_tree *) reply->data;
12493 + dPtr =
12494 + reply->data + pDGetTree->DsTreeNameOffset;
12495 + p = (struct nwc_get_pref_ds_tree *) pdata->reqData;
12496 +
12497 + DbgPrint
12498 + ("NwcGetPreferredDSTree: Reply recieved\n");
12499 + DbgPrint(" TreeLen = %x\n",
12500 + pDGetTree->uTreeLength);
12501 + DbgPrint(" TreeName = %s\n", dPtr);
12502 +
12503 + cpylen =
12504 + copy_to_user(p, &pDGetTree->uTreeLength, 4);
12505 + cpylen =
12506 + copy_to_user(xplatCall.pDsTreeName, dPtr,
12507 + pDGetTree->uTreeLength);
12508 }
12509 - kfree(cmd);
12510 + kfree(reply);
12511 }
12512 + kfree(cmd);
12513 return (retCode);
12514
12515 }
12516
12517 -/*++======================================================================*/
12518 -int NwcSetPreferredDSTree(PXPLAT pdata, session_t Session)
12519 -/*
12520 - * Arguments:
12521 - *
12522 - * Returns:
12523 - *
12524 - * Abstract:
12525 - *
12526 - * Notes:
12527 - *
12528 - * Environment:
12529 - *
12530 - *========================================================================*/
12531 -{
12532 - PXPLAT_CALL_REQUEST cmd;
12533 - PXPLAT_CALL_REPLY reply;
12534 - PNwdCSetPreferredDsTree pDSetTree;
12535 - NwcSetPreferredDsTree xplatCall;
12536 +int novfs_set_preferred_DS_tree(struct novfs_xplat *pdata, struct novfs_schandle Session)
12537 +{
12538 + struct novfs_xplat_call_request *cmd;
12539 + struct novfs_xplat_call_reply *reply;
12540 + struct nwd_set_pref_ds_tree *pDSetTree;
12541 + struct nwc_set_pref_ds_tree xplatCall;
12542 int retCode = -ENOMEM;
12543 unsigned long cmdlen, datalen, replylen, cpylen;
12544 unsigned char *dPtr;
12545
12546 cpylen =
12547 copy_from_user(&xplatCall, pdata->reqData,
12548 - sizeof(NwcSetPreferredDsTree));
12549 + sizeof(struct nwc_set_pref_ds_tree));
12550 datalen = sizeof(*pDSetTree) + xplatCall.uTreeLength;
12551 cmdlen = datalen + sizeof(*cmd);
12552 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
12553 + cmd = kmalloc(cmdlen, GFP_KERNEL);
12554
12555 - if (cmd) {
12556 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12557 - cmd->Command.SequenceNumber = 0;
12558 - cmd->Command.SessionId = Session;
12559 - cmd->NwcCommand = NWC_SET_PREFERRED_DS_TREE;
12560 -
12561 - pDSetTree = (PNwdCSetPreferredDsTree) cmd->data;
12562 - pDSetTree->DsTreeNameOffset = sizeof(*pDSetTree);
12563 - pDSetTree->uTreeLength = xplatCall.uTreeLength;
12564 + if (!cmd)
12565 + return -ENOMEM;
12566
12567 - dPtr = cmd->data + sizeof(*pDSetTree);
12568 - cpylen =
12569 - copy_from_user(dPtr, xplatCall.pDsTreeName,
12570 - xplatCall.uTreeLength);
12571 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12572 + cmd->Command.SequenceNumber = 0;
12573 + cmd->Command.SessionId = Session;
12574 + cmd->NwcCommand = NWC_SET_PREFERRED_DS_TREE;
12575
12576 - retCode =
12577 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12578 - (void **)&reply, &replylen,
12579 - INTERRUPTIBLE);
12580 - if (reply) {
12581 - retCode = reply->Reply.ErrorCode;
12582 - kfree(reply);
12583 - }
12584 - kfree(cmd);
12585 + pDSetTree = (struct nwd_set_pref_ds_tree *) cmd->data;
12586 + pDSetTree->DsTreeNameOffset = sizeof(*pDSetTree);
12587 + pDSetTree->uTreeLength = xplatCall.uTreeLength;
12588 +
12589 + dPtr = cmd->data + sizeof(*pDSetTree);
12590 + cpylen =
12591 + copy_from_user(dPtr, xplatCall.pDsTreeName,
12592 + xplatCall.uTreeLength);
12593 +
12594 + retCode =
12595 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12596 + (void **)&reply, &replylen,
12597 + INTERRUPTIBLE);
12598 + if (reply) {
12599 + retCode = reply->Reply.ErrorCode;
12600 + kfree(reply);
12601 }
12602 + kfree(cmd);
12603 return (retCode);
12604
12605 }
12606
12607 -/*++======================================================================*/
12608 -int NwcSetDefaultNameCtx(PXPLAT pdata, session_t Session)
12609 -/*
12610 - * Arguments:
12611 - *
12612 - * Returns:
12613 - *
12614 - * Abstract:
12615 - *
12616 - * Notes:
12617 - *
12618 - * Environment:
12619 - *
12620 - *========================================================================*/
12621 -{
12622 - PXPLAT_CALL_REQUEST cmd;
12623 - PXPLAT_CALL_REPLY reply;
12624 - NwcSetDefaultNameContext xplatCall;
12625 - PNwdCSetDefaultNameContext pDSet;
12626 +int novfs_set_default_ctx(struct novfs_xplat *pdata,
12627 + struct novfs_schandle Session)
12628 +{
12629 + struct novfs_xplat_call_request *cmd;
12630 + struct novfs_xplat_call_reply *reply;
12631 + struct nwc_set_def_name_ctx xplatCall;
12632 + struct nwd_set_def_name_ctx * pDSet;
12633 int retCode = -ENOMEM;
12634 unsigned long cmdlen, datalen, replylen, cpylen;
12635 unsigned char *dPtr;
12636
12637 cpylen =
12638 copy_from_user(&xplatCall, pdata->reqData,
12639 - sizeof(NwcSetDefaultNameContext));
12640 + sizeof(struct nwc_set_def_name_ctx));
12641 datalen =
12642 sizeof(*pDSet) + xplatCall.uTreeLength + xplatCall.uNameLength;
12643 cmdlen = datalen + sizeof(*cmd);
12644 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
12645 + cmd = kmalloc(cmdlen, GFP_KERNEL);
12646
12647 - if (cmd) {
12648 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12649 - cmd->Command.SequenceNumber = 0;
12650 - cmd->Command.SessionId = Session;
12651 - cmd->NwcCommand = NWC_SET_DEFAULT_NAME_CONTEXT;
12652 - cmd->dataLen =
12653 - sizeof(NwdCSetDefaultNameContext) + xplatCall.uTreeLength +
12654 - xplatCall.uNameLength;
12655 -
12656 - pDSet = (PNwdCSetDefaultNameContext) cmd->data;
12657 - dPtr = cmd->data;
12658 -
12659 - pDSet->TreeOffset = sizeof(NwdCSetDefaultNameContext);
12660 - pDSet->uTreeLength = xplatCall.uTreeLength;
12661 - pDSet->NameContextOffset =
12662 - pDSet->TreeOffset + xplatCall.uTreeLength;
12663 - pDSet->uNameLength = xplatCall.uNameLength;
12664 + if (!cmd)
12665 + return -ENOMEM;
12666 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12667 + cmd->Command.SequenceNumber = 0;
12668 + cmd->Command.SessionId = Session;
12669 + cmd->NwcCommand = NWC_SET_DEFAULT_NAME_CONTEXT;
12670 + cmd->dataLen =
12671 + sizeof(struct nwd_set_def_name_ctx) +
12672 + xplatCall.uTreeLength + xplatCall.uNameLength;
12673 +
12674 + pDSet = (struct nwd_set_def_name_ctx *) cmd->data;
12675 + dPtr = cmd->data;
12676 +
12677 + pDSet->TreeOffset = sizeof(struct nwd_set_def_name_ctx);
12678 + pDSet->uTreeLength = xplatCall.uTreeLength;
12679 + pDSet->NameContextOffset =
12680 + pDSet->TreeOffset + xplatCall.uTreeLength;
12681 + pDSet->uNameLength = xplatCall.uNameLength;
12682
12683 -//sgled cpylen = copy_from_user(dPtr+pDSet->TreeOffset, xplatCall.pTreeName, xplatCall.uTreeLength);
12684 - cpylen = copy_from_user(dPtr + pDSet->TreeOffset, xplatCall.pDsTreeName, xplatCall.uTreeLength); //sgled
12685 - cpylen =
12686 - copy_from_user(dPtr + pDSet->NameContextOffset,
12687 - xplatCall.pNameContext,
12688 - xplatCall.uNameLength);
12689 -
12690 - retCode =
12691 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12692 - (void **)&reply, &replylen,
12693 - INTERRUPTIBLE);
12694 - if (reply) {
12695 - retCode = reply->Reply.ErrorCode;
12696 - kfree(reply);
12697 - }
12698 - kfree(cmd);
12699 + //sgled cpylen = copy_from_user(dPtr+pDSet->TreeOffset, xplatCall.pTreeName, xplatCall.uTreeLength);
12700 + cpylen = copy_from_user(dPtr + pDSet->TreeOffset, xplatCall.pDsTreeName, xplatCall.uTreeLength); //sgled
12701 + cpylen =
12702 + copy_from_user(dPtr + pDSet->NameContextOffset,
12703 + xplatCall.pNameContext,
12704 + xplatCall.uNameLength);
12705 +
12706 + retCode =
12707 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12708 + (void **)&reply, &replylen,
12709 + INTERRUPTIBLE);
12710 + if (reply) {
12711 + retCode = reply->Reply.ErrorCode;
12712 + kfree(reply);
12713 }
12714 + kfree(cmd);
12715 return (retCode);
12716
12717 }
12718
12719 -/*++======================================================================*/
12720 -int NwcGetDefaultNameCtx(PXPLAT pdata, session_t Session)
12721 -/*
12722 - * Arguments:
12723 - *
12724 - * Returns:
12725 - *
12726 - * Abstract:
12727 - *
12728 - * Notes:
12729 - *
12730 - * Environment:
12731 - *
12732 - *========================================================================*/
12733 -{
12734 - PXPLAT_CALL_REQUEST cmd;
12735 - PXPLAT_CALL_REPLY reply;
12736 - NwcGetDefaultNameContext xplatCall;
12737 - PNwdCGetDefaultNameContext pGet;
12738 +int novfs_get_default_ctx(struct novfs_xplat *pdata,
12739 + struct novfs_schandle Session)
12740 +{
12741 + struct novfs_xplat_call_request *cmd;
12742 + struct novfs_xplat_call_reply *reply;
12743 + struct nwc_get_def_name_ctx xplatCall;
12744 + struct nwd_get_def_name_ctx * pGet;
12745 char *dPtr;
12746 int retCode = -ENOMEM;
12747 unsigned long cmdlen, replylen, cpylen;
12748
12749 cpylen =
12750 copy_from_user(&xplatCall, pdata->reqData,
12751 - sizeof(NwcGetDefaultNameContext));
12752 + sizeof(struct nwc_get_def_name_ctx));
12753 cmdlen =
12754 - sizeof(*cmd) + sizeof(NwdCGetDefaultNameContext) +
12755 + sizeof(*cmd) + sizeof(struct nwd_get_def_name_ctx ) +
12756 xplatCall.uTreeLength;
12757 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
12758 + cmd = kmalloc(cmdlen, GFP_KERNEL);
12759
12760 - if (cmd) {
12761 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12762 - cmd->Command.SequenceNumber = 0;
12763 - cmd->Command.SessionId = Session;
12764 - cmd->NwcCommand = NWC_GET_DEFAULT_NAME_CONTEXT;
12765 - cmd->dataLen =
12766 - sizeof(NwdCGetDefaultNameContext) + xplatCall.uTreeLength;
12767 -
12768 - pGet = (PNwdCGetDefaultNameContext) cmd->data;
12769 - dPtr = cmd->data;
12770 -
12771 - pGet->TreeOffset = sizeof(NwdCGetDefaultNameContext);
12772 - pGet->uTreeLength = xplatCall.uTreeLength;
12773 -
12774 -//sgled cpylen = copy_from_user( dPtr + pGet->TreeOffset, xplatCall.pTreeName, xplatCall.uTreeLength);
12775 - cpylen = copy_from_user(dPtr + pGet->TreeOffset, xplatCall.pDsTreeName, xplatCall.uTreeLength); //sgled
12776 - dPtr[pGet->TreeOffset + pGet->uTreeLength] = 0;
12777 -
12778 - retCode =
12779 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12780 - (void **)&reply, &replylen,
12781 - INTERRUPTIBLE);
12782 - if (reply) {
12783 - retCode = reply->Reply.ErrorCode;
12784 - if (!retCode) {
12785 - pGet = (PNwdCGetDefaultNameContext) reply->data;
12786 -
12787 - DbgPrint
12788 - ("NwcGetDefaultNameCtx: retCode=0x%x uNameLength1=%d uNameLength2=%d\n",
12789 - retCode, pGet->uNameLength,
12790 - xplatCall.uNameLength);
12791 - if (xplatCall.uNameLength < pGet->uNameLength) {
12792 - pGet->uNameLength =
12793 - xplatCall.uNameLength;
12794 - retCode = NWE_BUFFER_OVERFLOW;
12795 - }
12796 - dPtr = (char *)pGet + pGet->NameContextOffset;
12797 - cpylen =
12798 - copy_to_user(xplatCall.pNameContext, dPtr,
12799 - pGet->uNameLength);
12800 - }
12801 + if (!cmd)
12802 + return -ENOMEM;
12803 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12804 + cmd->Command.SequenceNumber = 0;
12805 + cmd->Command.SessionId = Session;
12806 + cmd->NwcCommand = NWC_GET_DEFAULT_NAME_CONTEXT;
12807 + cmd->dataLen =
12808 + sizeof(struct nwd_get_def_name_ctx) + xplatCall.uTreeLength;
12809 +
12810 + pGet = (struct nwd_get_def_name_ctx *) cmd->data;
12811 + dPtr = cmd->data;
12812 +
12813 + pGet->TreeOffset = sizeof(struct nwd_get_def_name_ctx );
12814 + pGet->uTreeLength = xplatCall.uTreeLength;
12815 +
12816 + //sgled cpylen = copy_from_user( dPtr + pGet->TreeOffset, xplatCall.pTreeName, xplatCall.uTreeLength);
12817 + cpylen = copy_from_user(dPtr + pGet->TreeOffset, xplatCall.pDsTreeName, xplatCall.uTreeLength); //sgled
12818 + dPtr[pGet->TreeOffset + pGet->uTreeLength] = 0;
12819 +
12820 + retCode =
12821 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12822 + (void **)&reply, &replylen,
12823 + INTERRUPTIBLE);
12824 + if (reply) {
12825 + retCode = reply->Reply.ErrorCode;
12826 + if (!retCode) {
12827 + pGet = (struct nwd_get_def_name_ctx *) reply->data;
12828
12829 - kfree(reply);
12830 + DbgPrint
12831 + ("NwcGetDefaultNameCtx: retCode=0x%x uNameLength1=%d uNameLength2=%d\n",
12832 + retCode, pGet->uNameLength,
12833 + xplatCall.uNameLength);
12834 + if (xplatCall.uNameLength < pGet->uNameLength) {
12835 + pGet->uNameLength =
12836 + xplatCall.uNameLength;
12837 + retCode = NWE_BUFFER_OVERFLOW;
12838 + }
12839 + dPtr = (char *)pGet + pGet->NameContextOffset;
12840 + cpylen =
12841 + copy_to_user(xplatCall.pNameContext, dPtr,
12842 + pGet->uNameLength);
12843 }
12844 - kfree(cmd);
12845 +
12846 + kfree(reply);
12847 }
12848 + kfree(cmd);
12849 return (retCode);
12850
12851 }
12852
12853 -int NwQueryFeature(PXPLAT pdata, session_t Session)
12854 +int novfs_query_feature(struct novfs_xplat *pdata, struct novfs_schandle Session)
12855 {
12856 - NwcQueryFeature xpCall;
12857 + struct nwc_query_feature xpCall;
12858 int status = 0;
12859 unsigned long cpylen;
12860
12861 cpylen =
12862 - copy_from_user(&xpCall, pdata->reqData, sizeof(NwcQueryFeature));
12863 + copy_from_user(&xpCall, pdata->reqData, sizeof(struct nwc_query_feature));
12864 switch (xpCall.Feature) {
12865 case NWC_FEAT_NDS:
12866 case NWC_FEAT_NDS_MTREE:
12867 @@ -1725,372 +1515,306 @@ int NwQueryFeature(PXPLAT pdata, session
12868 return (status);
12869 }
12870
12871 -/*++======================================================================*/
12872 -int NwcGetTreeMonitoredConn(PXPLAT pdata, session_t Session)
12873 -/*
12874 - * Arguments:
12875 - *
12876 - * Returns:
12877 - *
12878 - * Abstract:
12879 - *
12880 - * Notes:
12881 - *
12882 - * Environment:
12883 - *
12884 - *========================================================================*/
12885 -{
12886 - PXPLAT_CALL_REQUEST cmd;
12887 - PXPLAT_CALL_REPLY reply;
12888 - NwcGetTreeMonitoredConnRef xplatCall, *p;
12889 - PNwdCGetTreeMonitoredConnRef pDConnRef;
12890 +int novfs_get_tree_monitored_conn(struct novfs_xplat *pdata,
12891 + struct novfs_schandle Session)
12892 +{
12893 + struct novfs_xplat_call_request *cmd;
12894 + struct novfs_xplat_call_reply *reply;
12895 + struct nwc_get_tree_monitored_conn_ref xplatCall, *p;
12896 + struct nwd_get_tree_monitored_conn_ref *pDConnRef;
12897 char *dPtr;
12898 unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
12899
12900 cpylen =
12901 copy_from_user(&xplatCall, pdata->reqData,
12902 - sizeof(NwcGetTreeMonitoredConnRef));
12903 + sizeof(struct nwc_get_tree_monitored_conn_ref));
12904 datalen = sizeof(*pDConnRef) + xplatCall.pTreeName->DataLen;
12905 cmdlen = datalen + sizeof(*cmd);
12906 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
12907 + cmd = kmalloc(cmdlen, GFP_KERNEL);
12908
12909 - if (cmd) {
12910 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12911 - cmd->Command.SequenceNumber = 0;
12912 - cmd->Command.SessionId = Session;
12913 - cmd->NwcCommand = NWC_GET_TREE_MONITORED_CONN_REF;
12914 -
12915 - pDConnRef = (PNwdCGetTreeMonitoredConnRef) cmd->data;
12916 - pDConnRef->TreeName.boffset = sizeof(*pDConnRef);
12917 - pDConnRef->TreeName.len = xplatCall.pTreeName->DataLen;
12918 - pDConnRef->TreeName.type = xplatCall.pTreeName->DataType;
12919 + if (!cmd)
12920 + return -ENOMEM;
12921
12922 - dPtr = cmd->data + sizeof(*pDConnRef);
12923 - cpylen =
12924 - copy_from_user(dPtr, xplatCall.pTreeName->pBuffer,
12925 - pDConnRef->TreeName.len);
12926 - status =
12927 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12928 - (void **)&reply, &replylen,
12929 - INTERRUPTIBLE);
12930 - if (reply) {
12931 - pDConnRef = (PNwdCGetTreeMonitoredConnRef) reply->data;
12932 - dPtr = reply->data + pDConnRef->TreeName.boffset;
12933 - p = (NwcGetTreeMonitoredConnRef *) pdata->reqData;
12934 - cpylen =
12935 - copy_to_user(&p->uConnReference,
12936 - &pDConnRef->uConnReference, 4);
12937 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
12938 + cmd->Command.SequenceNumber = 0;
12939 + cmd->Command.SessionId = Session;
12940 + cmd->NwcCommand = NWC_GET_TREE_MONITORED_CONN_REF;
12941
12942 - status = reply->Reply.ErrorCode;
12943 - kfree(reply);
12944 - }
12945 - kfree(cmd);
12946 + pDConnRef = (struct nwd_get_tree_monitored_conn_ref *) cmd->data;
12947 + pDConnRef->TreeName.boffset = sizeof(*pDConnRef);
12948 + pDConnRef->TreeName.len = xplatCall.pTreeName->DataLen;
12949 + pDConnRef->TreeName.type = xplatCall.pTreeName->DataType;
12950
12951 - }
12952 + dPtr = cmd->data + sizeof(*pDConnRef);
12953 + cpylen =
12954 + copy_from_user(dPtr, xplatCall.pTreeName->pBuffer,
12955 + pDConnRef->TreeName.len);
12956 + status =
12957 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
12958 + (void **)&reply, &replylen,
12959 + INTERRUPTIBLE);
12960 + if (reply) {
12961 + pDConnRef = (struct nwd_get_tree_monitored_conn_ref *) reply->data;
12962 + dPtr = reply->data + pDConnRef->TreeName.boffset;
12963 + p = (struct nwc_get_tree_monitored_conn_ref *) pdata->reqData;
12964 + cpylen =
12965 + copy_to_user(&p->uConnReference,
12966 + &pDConnRef->uConnReference, 4);
12967
12968 + status = reply->Reply.ErrorCode;
12969 + kfree(reply);
12970 + }
12971 + kfree(cmd);
12972 return (status);
12973 }
12974
12975 -/*++======================================================================*/
12976 -int NwcEnumIdentities(PXPLAT pdata, session_t Session)
12977 -/*
12978 - * Arguments:
12979 - *
12980 - * Returns:
12981 - *
12982 - * Abstract:
12983 - *
12984 - * Notes:
12985 - *
12986 - * Environment:
12987 - *
12988 - *========================================================================*/
12989 -{
12990 - PXPLAT_CALL_REQUEST cmd;
12991 - PXPLAT_CALL_REPLY reply;
12992 - NwcEnumerateIdentities xplatCall, *eId;
12993 - PNwdCEnumerateIdentities pEnum;
12994 - NwcString xferStr;
12995 +int novfs_enum_ids(struct novfs_xplat *pdata, struct novfs_schandle Session)
12996 +{
12997 + struct novfs_xplat_call_request *cmd;
12998 + struct novfs_xplat_call_reply *reply;
12999 + struct nwc_enum_ids xplatCall, *eId;
13000 + struct nwd_enum_ids *pEnum;
13001 + struct nwc_string xferStr;
13002 char *str;
13003 unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
13004
13005 cpylen =
13006 copy_from_user(&xplatCall, pdata->reqData,
13007 - sizeof(NwcEnumerateIdentities));
13008 + sizeof(struct nwc_enum_ids));
13009 datalen = sizeof(*pEnum);
13010 cmdlen = datalen + sizeof(*cmd);
13011 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13012 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13013
13014 - if (cmd) {
13015 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13016 - cmd->Command.SequenceNumber = 0;
13017 - cmd->Command.SessionId = Session;
13018 - cmd->NwcCommand = NWC_ENUMERATE_IDENTITIES;
13019 -
13020 - DbgPrint("NwcEnumIdentities: Send Request\n");
13021 - DbgPrint(" iterator = %x\n", xplatCall.Iterator);
13022 - DbgPrint(" cmdlen = %d\n", cmdlen);
13023 -
13024 - pEnum = (PNwdCEnumerateIdentities) cmd->data;
13025 - pEnum->Iterator = xplatCall.Iterator;
13026 - status =
13027 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13028 - (void **)&reply, &replylen,
13029 - INTERRUPTIBLE);
13030 - if (reply) {
13031 - status = reply->Reply.ErrorCode;
13032 -
13033 - eId = pdata->repData;
13034 - pEnum = (PNwdCEnumerateIdentities) reply->data;
13035 - cpylen =
13036 - copy_to_user(&eId->Iterator, &pEnum->Iterator,
13037 - sizeof(pEnum->Iterator));
13038 - DbgPrint("[XPLAT NWCAPI] Found AuthId 0x%X\n",
13039 - pEnum->AuthenticationId);
13040 - cpylen =
13041 - copy_to_user(&eId->AuthenticationId,
13042 - &pEnum->AuthenticationId,
13043 - sizeof(pEnum->AuthenticationId));
13044 - cpylen =
13045 - copy_to_user(&eId->AuthType, &pEnum->AuthType,
13046 - sizeof(pEnum->AuthType));
13047 - cpylen =
13048 - copy_to_user(&eId->IdentityFlags,
13049 - &pEnum->IdentityFlags,
13050 - sizeof(pEnum->IdentityFlags));
13051 - cpylen =
13052 - copy_to_user(&eId->NameType, &pEnum->NameType,
13053 - sizeof(pEnum->NameType));
13054 - cpylen =
13055 - copy_to_user(&eId->ObjectType, &pEnum->ObjectType,
13056 - sizeof(pEnum->ObjectType));
13057 -
13058 - if (!status) {
13059 - cpylen =
13060 - copy_from_user(&xferStr, eId->pDomainName,
13061 - sizeof(NwcString));
13062 - str =
13063 - (char *)((char *)reply->data +
13064 - pEnum->domainNameOffset);
13065 - DbgPrint("[XPLAT NWCAPI] Found Domain %s\n",
13066 - str);
13067 - cpylen =
13068 - copy_to_user(xferStr.pBuffer, str,
13069 - pEnum->domainNameLen);
13070 - xferStr.DataType = NWC_STRING_TYPE_ASCII;
13071 - xferStr.DataLen = pEnum->domainNameLen - 1;
13072 - cpylen =
13073 - copy_to_user(eId->pDomainName, &xferStr,
13074 - sizeof(NwcString));
13075 -
13076 - cpylen =
13077 - copy_from_user(&xferStr, eId->pObjectName,
13078 - sizeof(NwcString));
13079 - str =
13080 - (char *)((char *)reply->data +
13081 - pEnum->objectNameOffset);
13082 - DbgPrint("[XPLAT NWCAPI] Found User %s\n", str);
13083 - cpylen =
13084 - copy_to_user(xferStr.pBuffer, str,
13085 - pEnum->objectNameLen);
13086 - xferStr.DataType = NWC_STRING_TYPE_ASCII;
13087 - xferStr.DataLen = pEnum->objectNameLen - 1;
13088 - cpylen =
13089 - copy_to_user(eId->pObjectName, &xferStr,
13090 - sizeof(NwcString));
13091 - }
13092 + if (!cmd)
13093 + return -ENOMEM;
13094 +
13095 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13096 + cmd->Command.SequenceNumber = 0;
13097 + cmd->Command.SessionId = Session;
13098 + cmd->NwcCommand = NWC_ENUMERATE_IDENTITIES;
13099 +
13100 + DbgPrint("NwcEnumIdentities: Send Request\n");
13101 + DbgPrint(" iterator = %x\n", xplatCall.Iterator);
13102 + DbgPrint(" cmdlen = %d\n", cmdlen);
13103
13104 - kfree(reply);
13105 + pEnum = (struct nwd_enum_ids *) cmd->data;
13106 + pEnum->Iterator = xplatCall.Iterator;
13107 + status =
13108 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13109 + (void **)&reply, &replylen,
13110 + INTERRUPTIBLE);
13111 + if (reply) {
13112 + status = reply->Reply.ErrorCode;
13113
13114 + eId = pdata->repData;
13115 + pEnum = (struct nwd_enum_ids *) reply->data;
13116 + cpylen =
13117 + copy_to_user(&eId->Iterator, &pEnum->Iterator,
13118 + sizeof(pEnum->Iterator));
13119 + DbgPrint("[XPLAT NWCAPI] Found AuthId 0x%X\n",
13120 + pEnum->AuthenticationId);
13121 + cpylen =
13122 + copy_to_user(&eId->AuthenticationId,
13123 + &pEnum->AuthenticationId,
13124 + sizeof(pEnum->AuthenticationId));
13125 + cpylen =
13126 + copy_to_user(&eId->AuthType, &pEnum->AuthType,
13127 + sizeof(pEnum->AuthType));
13128 + cpylen =
13129 + copy_to_user(&eId->IdentityFlags,
13130 + &pEnum->IdentityFlags,
13131 + sizeof(pEnum->IdentityFlags));
13132 + cpylen =
13133 + copy_to_user(&eId->NameType, &pEnum->NameType,
13134 + sizeof(pEnum->NameType));
13135 + cpylen =
13136 + copy_to_user(&eId->ObjectType, &pEnum->ObjectType,
13137 + sizeof(pEnum->ObjectType));
13138 +
13139 + if (!status) {
13140 + cpylen =
13141 + copy_from_user(&xferStr, eId->pDomainName,
13142 + sizeof(struct nwc_string));
13143 + str =
13144 + (char *)((char *)reply->data +
13145 + pEnum->domainNameOffset);
13146 + DbgPrint("[XPLAT NWCAPI] Found Domain %s\n",
13147 + str);
13148 + cpylen =
13149 + copy_to_user(xferStr.pBuffer, str,
13150 + pEnum->domainNameLen);
13151 + xferStr.DataType = NWC_STRING_TYPE_ASCII;
13152 + xferStr.DataLen = pEnum->domainNameLen - 1;
13153 + cpylen =
13154 + copy_to_user(eId->pDomainName, &xferStr,
13155 + sizeof(struct nwc_string));
13156 +
13157 + cpylen =
13158 + copy_from_user(&xferStr, eId->pObjectName,
13159 + sizeof(struct nwc_string));
13160 + str =
13161 + (char *)((char *)reply->data +
13162 + pEnum->objectNameOffset);
13163 + DbgPrint("[XPLAT NWCAPI] Found User %s\n", str);
13164 + cpylen =
13165 + copy_to_user(xferStr.pBuffer, str,
13166 + pEnum->objectNameLen);
13167 + xferStr.DataType = NWC_STRING_TYPE_ASCII;
13168 + xferStr.DataLen = pEnum->objectNameLen - 1;
13169 + cpylen =
13170 + copy_to_user(eId->pObjectName, &xferStr,
13171 + sizeof(struct nwc_string));
13172 }
13173 - kfree(cmd);
13174 +
13175 + kfree(reply);
13176
13177 }
13178 + kfree(cmd);
13179 return (status);
13180 }
13181
13182 -/*++======================================================================*/
13183 -int NwcChangeAuthKey(PXPLAT pdata, session_t Session)
13184 -/*
13185 - * Arguments:
13186 - *
13187 - * Returns:
13188 - *
13189 - * Abstract: Change the password on the server
13190 - *
13191 - * Notes:
13192 - *
13193 - * Environment:
13194 - *
13195 - *========================================================================*/
13196 -{
13197 - PXPLAT_CALL_REQUEST cmd;
13198 - PXPLAT_CALL_REPLY reply;
13199 - NwcChangeKey xplatCall;
13200 - PNwdCChangeKey pNewKey;
13201 - NwcString xferStr;
13202 +int novfs_change_auth_key(struct novfs_xplat *pdata, struct novfs_schandle Session)
13203 +{
13204 + struct novfs_xplat_call_request *cmd;
13205 + struct novfs_xplat_call_reply *reply;
13206 + struct nwc_change_key xplatCall;
13207 + struct nwd_change_key *pNewKey;
13208 + struct nwc_string xferStr;
13209 char *str;
13210 unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
13211
13212 cpylen =
13213 - copy_from_user(&xplatCall, pdata->reqData, sizeof(NwcChangeKey));
13214 + copy_from_user(&xplatCall, pdata->reqData, sizeof(struct nwc_change_key));
13215
13216 datalen =
13217 - sizeof(NwdCChangeKey) + xplatCall.pDomainName->DataLen +
13218 + sizeof(struct nwd_change_key) + xplatCall.pDomainName->DataLen +
13219 xplatCall.pObjectName->DataLen + xplatCall.pNewPassword->DataLen +
13220 xplatCall.pVerifyPassword->DataLen;
13221
13222 cmdlen = sizeof(*cmd) + datalen;
13223 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13224 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13225
13226 - if (cmd) {
13227 - pNewKey = (PNwdCChangeKey) cmd->data;
13228 - cmd->dataLen = datalen;
13229 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13230 - cmd->Command.SequenceNumber = 0;
13231 - cmd->Command.SessionId = Session;
13232 - cmd->NwcCommand = NWC_CHANGE_KEY;
13233 -
13234 - pNewKey->NameType = xplatCall.NameType;
13235 - pNewKey->ObjectType = xplatCall.ObjectType;
13236 - pNewKey->AuthType = xplatCall.AuthType;
13237 - str = (char *)pNewKey;
13238 + if (!cmd)
13239 + return -ENOMEM;
13240
13241 - /*
13242 - * Get the tree name
13243 - */
13244 - str += sizeof(*pNewKey);
13245 - cpylen =
13246 - copy_from_user(&xferStr, xplatCall.pDomainName,
13247 - sizeof(NwcString));
13248 - pNewKey->domainNameOffset = sizeof(*pNewKey);
13249 - cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13250 - pNewKey->domainNameLen = xferStr.DataLen;
13251 + pNewKey = (struct nwd_change_key *) cmd->data;
13252 + cmd->dataLen = datalen;
13253 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13254 + cmd->Command.SequenceNumber = 0;
13255 + cmd->Command.SessionId = Session;
13256 + cmd->NwcCommand = NWC_CHANGE_KEY;
13257
13258 - /*
13259 - * Get the User Name
13260 - */
13261 - str += pNewKey->domainNameLen;
13262 - cpylen =
13263 - copy_from_user(&xferStr, xplatCall.pObjectName,
13264 - sizeof(NwcString));
13265 - pNewKey->objectNameOffset =
13266 - pNewKey->domainNameOffset + pNewKey->domainNameLen;
13267 - cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13268 - pNewKey->objectNameLen = xferStr.DataLen;
13269 + pNewKey->NameType = xplatCall.NameType;
13270 + pNewKey->ObjectType = xplatCall.ObjectType;
13271 + pNewKey->AuthType = xplatCall.AuthType;
13272 + str = (char *)pNewKey;
13273
13274 - /*
13275 - * Get the New Password
13276 - */
13277 - str += pNewKey->objectNameLen;
13278 - cpylen =
13279 - copy_from_user(&xferStr, xplatCall.pNewPassword,
13280 - sizeof(NwcString));
13281 - pNewKey->newPasswordOffset =
13282 - pNewKey->objectNameOffset + pNewKey->objectNameLen;
13283 - cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13284 - pNewKey->newPasswordLen = xferStr.DataLen;
13285 + /*
13286 + * Get the tree name
13287 + */
13288 + str += sizeof(*pNewKey);
13289 + cpylen =
13290 + copy_from_user(&xferStr, xplatCall.pDomainName,
13291 + sizeof(struct nwc_string));
13292 + pNewKey->domainNameOffset = sizeof(*pNewKey);
13293 + cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13294 + pNewKey->domainNameLen = xferStr.DataLen;
13295
13296 - /*
13297 - * Get the Verify Password
13298 - */
13299 - str += pNewKey->newPasswordLen;
13300 - cpylen =
13301 - copy_from_user(&xferStr, xplatCall.pVerifyPassword,
13302 - sizeof(NwcString));
13303 - pNewKey->verifyPasswordOffset =
13304 - pNewKey->newPasswordOffset + pNewKey->newPasswordLen;
13305 - cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13306 - pNewKey->verifyPasswordLen = xferStr.DataLen;
13307 -
13308 - status =
13309 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13310 - (void **)&reply, &replylen,
13311 - INTERRUPTIBLE);
13312 - if (reply) {
13313 - status = reply->Reply.ErrorCode;
13314 - kfree(reply);
13315 - }
13316 - memset(cmd, 0, cmdlen);
13317 + /*
13318 + * Get the User Name
13319 + */
13320 + str += pNewKey->domainNameLen;
13321 + cpylen =
13322 + copy_from_user(&xferStr, xplatCall.pObjectName,
13323 + sizeof(struct nwc_string));
13324 + pNewKey->objectNameOffset =
13325 + pNewKey->domainNameOffset + pNewKey->domainNameLen;
13326 + cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13327 + pNewKey->objectNameLen = xferStr.DataLen;
13328
13329 - kfree(cmd);
13330 + /*
13331 + * Get the New Password
13332 + */
13333 + str += pNewKey->objectNameLen;
13334 + cpylen =
13335 + copy_from_user(&xferStr, xplatCall.pNewPassword,
13336 + sizeof(struct nwc_string));
13337 + pNewKey->newPasswordOffset =
13338 + pNewKey->objectNameOffset + pNewKey->objectNameLen;
13339 + cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13340 + pNewKey->newPasswordLen = xferStr.DataLen;
13341 +
13342 + /*
13343 + * Get the Verify Password
13344 + */
13345 + str += pNewKey->newPasswordLen;
13346 + cpylen =
13347 + copy_from_user(&xferStr, xplatCall.pVerifyPassword,
13348 + sizeof(struct nwc_string));
13349 + pNewKey->verifyPasswordOffset =
13350 + pNewKey->newPasswordOffset + pNewKey->newPasswordLen;
13351 + cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
13352 + pNewKey->verifyPasswordLen = xferStr.DataLen;
13353 +
13354 + status =
13355 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13356 + (void **)&reply, &replylen,
13357 + INTERRUPTIBLE);
13358 + if (reply) {
13359 + status = reply->Reply.ErrorCode;
13360 + kfree(reply);
13361 }
13362 + memset(cmd, 0, cmdlen);
13363
13364 + kfree(cmd);
13365 return (status);
13366 }
13367
13368 -/*++======================================================================*/
13369 -int NwcSetPrimaryConn(PXPLAT pdata, session_t Session)
13370 -/*
13371 - * Arguments:
13372 - *
13373 - * Returns:
13374 - *
13375 - * Abstract: Set the primary connection Id
13376 - *
13377 - * Notes:
13378 - *
13379 - * Environment:
13380 - *
13381 - *========================================================================*/
13382 -{
13383 - PXPLAT_CALL_REQUEST cmd;
13384 - PXPLAT_CALL_REPLY reply;
13385 - NwcSetPrimaryConnection xplatCall;
13386 - PNwdCSetPrimaryConnection pConn;
13387 +int novfs_set_pri_conn(struct novfs_xplat *pdata, struct novfs_schandle Session)
13388 +{
13389 + struct novfs_xplat_call_request *cmd;
13390 + struct novfs_xplat_call_reply *reply;
13391 + struct nwc_set_primary_conn xplatCall;
13392 + struct nwd_set_primary_conn *pConn;
13393 unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
13394
13395 cpylen =
13396 copy_from_user(&xplatCall, pdata->reqData,
13397 - sizeof(NwcSetPrimaryConnection));
13398 + sizeof(struct nwc_set_primary_conn));
13399
13400 - datalen = sizeof(NwdCSetPrimaryConnection);
13401 + datalen = sizeof(struct nwd_set_primary_conn);
13402 cmdlen = sizeof(*cmd) + datalen;
13403 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13404 - if (cmd) {
13405 - pConn = (PNwdCSetPrimaryConnection) cmd->data;
13406 - cmd->dataLen = datalen;
13407 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13408 - cmd->Command.SequenceNumber = 0;
13409 - cmd->Command.SessionId = Session;
13410 - cmd->NwcCommand = NWC_SET_PRIMARY_CONN;
13411 - pConn->ConnHandle = (HANDLE) (unsigned long) xplatCall.ConnHandle;
13412 - status =
13413 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13414 - (void **)&reply, &replylen,
13415 - INTERRUPTIBLE);
13416 -
13417 - if (reply) {
13418 - status = reply->Reply.ErrorCode;
13419 - kfree(reply);
13420 - }
13421 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13422 + if (!cmd)
13423 + return -ENOMEM;
13424
13425 - kfree(cmd);
13426 - }
13427 + pConn = (struct nwd_set_primary_conn *) cmd->data;
13428 + cmd->dataLen = datalen;
13429 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13430 + cmd->Command.SequenceNumber = 0;
13431 + cmd->Command.SessionId = Session;
13432 + cmd->NwcCommand = NWC_SET_PRIMARY_CONN;
13433 + pConn->ConnHandle = (void *) (unsigned long) xplatCall.ConnHandle;
13434 + status =
13435 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13436 + (void **)&reply, &replylen,
13437 + INTERRUPTIBLE);
13438
13439 + if (reply) {
13440 + status = reply->Reply.ErrorCode;
13441 + kfree(reply);
13442 + }
13443 + kfree(cmd);
13444 return (status);
13445 }
13446
13447 -/*++======================================================================*/
13448 -int NwcGetPrimaryConn(PXPLAT pdata, session_t Session)
13449 -/*
13450 - * Arguments:
13451 - *
13452 - * Returns:
13453 - *
13454 - * Abstract: Get the Primary connection
13455 - *
13456 - * Notes:
13457 - *
13458 - * Environment:
13459 - *
13460 - *========================================================================*/
13461 +int novfs_get_pri_conn(struct novfs_xplat *pdata, struct novfs_schandle Session)
13462 {
13463 - XPLAT_CALL_REQUEST cmd;
13464 - PXPLAT_CALL_REPLY reply;
13465 + struct novfs_xplat_call_request cmd;
13466 + struct novfs_xplat_call_reply *reply;
13467 unsigned long status = -ENOMEM, cmdlen, replylen, cpylen;
13468
13469 - cmdlen = (unsigned long) (&((PXPLAT_CALL_REQUEST) 0)->data);
13470 + cmdlen = (unsigned long) (&((struct novfs_xplat_call_request *) 0)->data);
13471
13472 cmd.dataLen = 0;
13473 cmd.Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13474 @@ -2099,15 +1823,15 @@ int NwcGetPrimaryConn(PXPLAT pdata, sess
13475 cmd.NwcCommand = NWC_GET_PRIMARY_CONN;
13476
13477 status =
13478 - Queue_Daemon_Command((void *)&cmd, cmdlen, NULL, 0, (void **)&reply,
13479 - &replylen, INTERRUPTIBLE);
13480 + Queue_Daemon_Command((void *)&cmd, cmdlen, NULL, 0, (void **)&reply,
13481 + &replylen, INTERRUPTIBLE);
13482
13483 if (reply) {
13484 status = reply->Reply.ErrorCode;
13485 if (!status) {
13486 cpylen =
13487 - copy_to_user(pdata->repData, reply->data,
13488 - sizeof(unsigned long));
13489 + copy_to_user(pdata->repData, reply->data,
13490 + sizeof(unsigned long));
13491 }
13492
13493 kfree(reply);
13494 @@ -2116,26 +1840,13 @@ int NwcGetPrimaryConn(PXPLAT pdata, sess
13495 return (status);
13496 }
13497
13498 -/*++======================================================================*/
13499 -int NwcSetMapDrive(PXPLAT pdata, session_t Session)
13500 -/*
13501 - * Arguments:
13502 - *
13503 - * Returns:
13504 - *
13505 - * Abstract: Get the Primary connection
13506 - *
13507 - * Notes:
13508 - *
13509 - * Environment:
13510 - *
13511 - *========================================================================*/
13512 +int novfs_set_map_drive(struct novfs_xplat *pdata, struct novfs_schandle Session)
13513 {
13514
13515 - PXPLAT_CALL_REQUEST cmd;
13516 - PXPLAT_CALL_REPLY reply;
13517 + struct novfs_xplat_call_request *cmd;
13518 + struct novfs_xplat_call_reply *reply;
13519 unsigned long status = 0, datalen, cmdlen, replylen, cpylen;
13520 - NwcMapDriveEx symInfo;
13521 + struct nwc_map_drive_ex symInfo;
13522
13523 DbgPrint("Call to NwcSetMapDrive\n");
13524 cpylen = copy_from_user(&symInfo, pdata->reqData, sizeof(symInfo));
13525 @@ -2151,53 +1862,41 @@ int NwcSetMapDrive(PXPLAT pdata, session
13526 DbgPrint(" symInfo.linkOffsetLength = %d\n", symInfo.linkOffsetLength);
13527 DbgPrint(" pdata->datalen = %d\n", pdata->reqLen);
13528
13529 - mydump(sizeof(symInfo), &symInfo);
13530 + novfs_dump(sizeof(symInfo), &symInfo);
13531
13532 cmdlen += datalen;
13533
13534 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13535 - if (cmd) {
13536 - cmd->dataLen = datalen;
13537 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13538 - cmd->Command.SequenceNumber = 0;
13539 - cmd->Command.SessionId = Session;
13540 - cmd->NwcCommand = NWC_MAP_DRIVE;
13541 -
13542 - cpylen = copy_from_user(cmd->data, pdata->reqData, datalen);
13543 - status =
13544 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13545 - (void **)&reply, &replylen,
13546 - INTERRUPTIBLE);
13547 -
13548 - if (reply) {
13549 - status = reply->Reply.ErrorCode;
13550 - kfree(reply);
13551 - }
13552 - kfree(cmd);
13553 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13554 + if (!cmd)
13555 + return -ENOMEM;
13556 +
13557 + cmd->dataLen = datalen;
13558 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13559 + cmd->Command.SequenceNumber = 0;
13560 + cmd->Command.SessionId = Session;
13561 + cmd->NwcCommand = NWC_MAP_DRIVE;
13562 +
13563 + cpylen = copy_from_user(cmd->data, pdata->reqData, datalen);
13564 + status =
13565 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13566 + (void **)&reply, &replylen,
13567 + INTERRUPTIBLE);
13568 +
13569 + if (reply) {
13570 + status = reply->Reply.ErrorCode;
13571 + kfree(reply);
13572 }
13573 + kfree(cmd);
13574 return (status);
13575
13576 }
13577
13578 -/*++======================================================================*/
13579 -int NwcUnMapDrive(PXPLAT pdata, session_t Session)
13580 -/*
13581 - * Arguments:
13582 - *
13583 - * Returns:
13584 - *
13585 - * Abstract: Get the Primary connection
13586 - *
13587 - * Notes:
13588 - *
13589 - * Environment:
13590 - *
13591 - *========================================================================*/
13592 +int novfs_unmap_drive(struct novfs_xplat *pdata, struct novfs_schandle Session)
13593 {
13594 - PXPLAT_CALL_REQUEST cmd;
13595 - PXPLAT_CALL_REPLY reply;
13596 + struct novfs_xplat_call_request *cmd;
13597 + struct novfs_xplat_call_reply *reply;
13598 unsigned long status = 0, datalen, cmdlen, replylen, cpylen;
13599 - NwcUnmapDriveEx symInfo;
13600 + struct nwc_unmap_drive_ex symInfo;
13601
13602 DbgPrint("Call to NwcUnMapDrive\n");
13603
13604 @@ -2206,47 +1905,34 @@ int NwcUnMapDrive(PXPLAT pdata, session_
13605 datalen = sizeof(symInfo) + symInfo.linkLen;
13606
13607 cmdlen += datalen;
13608 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13609 - if (cmd) {
13610 - cmd->dataLen = datalen;
13611 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13612 - cmd->Command.SequenceNumber = 0;
13613 - cmd->Command.SessionId = Session;
13614 - cmd->NwcCommand = NWC_UNMAP_DRIVE;
13615 -
13616 - cpylen = copy_from_user(cmd->data, pdata->reqData, datalen);
13617 - status =
13618 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13619 - (void **)&reply, &replylen,
13620 - INTERRUPTIBLE);
13621 -
13622 - if (reply) {
13623 - status = reply->Reply.ErrorCode;
13624 - kfree(reply);
13625 - }
13626 - kfree(cmd);
13627 - }
13628 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13629 + if (!cmd)
13630 + return -ENOMEM;
13631 +
13632 + cmd->dataLen = datalen;
13633 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13634 + cmd->Command.SequenceNumber = 0;
13635 + cmd->Command.SessionId = Session;
13636 + cmd->NwcCommand = NWC_UNMAP_DRIVE;
13637 +
13638 + cpylen = copy_from_user(cmd->data, pdata->reqData, datalen);
13639 + status =
13640 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13641 + (void **)&reply, &replylen,
13642 + INTERRUPTIBLE);
13643
13644 + if (reply) {
13645 + status = reply->Reply.ErrorCode;
13646 + kfree(reply);
13647 + }
13648 + kfree(cmd);
13649 return (status);
13650 }
13651
13652 -/*++======================================================================*/
13653 -int NwcEnumerateDrives(PXPLAT pdata, session_t Session)
13654 -/*
13655 - * Arguments:
13656 - *
13657 - * Returns:
13658 - *
13659 - * Abstract: Get the Primary connection
13660 - *
13661 - * Notes:
13662 - *
13663 - * Environment:
13664 - *
13665 - *========================================================================*/
13666 +int novfs_enum_drives(struct novfs_xplat *pdata, struct novfs_schandle Session)
13667 {
13668 - PXPLAT_CALL_REQUEST cmd;
13669 - PXPLAT_CALL_REPLY reply;
13670 + struct novfs_xplat_call_request *cmd;
13671 + struct novfs_xplat_call_reply *reply;
13672 unsigned long status = 0, cmdlen, replylen, cpylen;
13673 unsigned long offset;
13674 char *cp;
13675 @@ -2254,284 +1940,266 @@ int NwcEnumerateDrives(PXPLAT pdata, ses
13676 DbgPrint("Call to NwcEnumerateDrives\n");
13677
13678 cmdlen = sizeof(*cmd);
13679 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13680 - if (cmd) {
13681 - cmd->dataLen = 0;
13682 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13683 - cmd->Command.SequenceNumber = 0;
13684 - cmd->Command.SessionId = Session;
13685 - cmd->NwcCommand = NWC_ENUMERATE_DRIVES;
13686 - status =
13687 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13688 - (void **)&reply, &replylen,
13689 - INTERRUPTIBLE);
13690 -
13691 - if (reply) {
13692 - status = reply->Reply.ErrorCode;
13693 - DbgPrint("Status Code = 0x%X\n", status);
13694 - if (!status) {
13695 - offset =
13696 - sizeof(((PNwcGetMappedDrives) pdata->
13697 - repData)->MapBuffLen);
13698 - cp = reply->data;
13699 - replylen =
13700 - ((PNwcGetMappedDrives) pdata->repData)->
13701 - MapBuffLen;
13702 - cpylen =
13703 - copy_to_user(pdata->repData, cp, offset);
13704 - cp += offset;
13705 - cpylen =
13706 - copy_to_user(((PNwcGetMappedDrives) pdata->
13707 - repData)->MapBuffer, cp,
13708 - min(replylen - offset,
13709 - reply->dataLen - offset));
13710 - }
13711 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13712 + if (!cmd)
13713 + return -ENOMEM;
13714
13715 - kfree(reply);
13716 + cmd->dataLen = 0;
13717 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13718 + cmd->Command.SequenceNumber = 0;
13719 + cmd->Command.SessionId = Session;
13720 + cmd->NwcCommand = NWC_ENUMERATE_DRIVES;
13721 + status =
13722 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13723 + (void **)&reply, &replylen,
13724 + INTERRUPTIBLE);
13725 +
13726 + if (reply) {
13727 + status = reply->Reply.ErrorCode;
13728 + DbgPrint("Status Code = 0x%X\n", status);
13729 + if (!status) {
13730 + offset =
13731 + sizeof(((struct nwc_get_mapped_drives *) pdata->
13732 + repData)->MapBuffLen);
13733 + cp = reply->data;
13734 + replylen =
13735 + ((struct nwc_get_mapped_drives *) pdata->repData)->
13736 + MapBuffLen;
13737 + cpylen =
13738 + copy_to_user(pdata->repData, cp, offset);
13739 + cp += offset;
13740 + cpylen =
13741 + copy_to_user(((struct nwc_get_mapped_drives *) pdata->
13742 + repData)->MapBuffer, cp,
13743 + min(replylen - offset,
13744 + reply->dataLen - offset));
13745 }
13746 - kfree(cmd);
13747 - }
13748
13749 + kfree(reply);
13750 + }
13751 + kfree(cmd);
13752 return (status);
13753 }
13754
13755 -/*++======================================================================*/
13756 -int NwcGetBroadcastMessage(PXPLAT pdata, session_t Session)
13757 -/*
13758 - * Arguments:
13759 - *
13760 - * Returns:
13761 - *
13762 - * Abstract: Get the Primary connection
13763 - *
13764 - * Notes:
13765 - *
13766 - * Environment:
13767 - *
13768 - *========================================================================*/
13769 +int novfs_get_bcast_msg(struct novfs_xplat *pdata, struct novfs_schandle Session)
13770 {
13771 - PXPLAT_CALL_REQUEST cmd;
13772 - PXPLAT_CALL_REPLY reply;
13773 + struct novfs_xplat_call_request *cmd;
13774 + struct novfs_xplat_call_reply *reply;
13775 unsigned long cmdlen, replylen;
13776 int status = 0x8866, cpylen;
13777 - NwcGetBroadcastNotification msg;
13778 - PNwdCGetBroadcastNotification dmsg;
13779 + struct nwc_get_bcast_notification msg;
13780 + struct nwd_get_bcast_notification *dmsg;
13781
13782 cmdlen = sizeof(*cmd) + sizeof(*dmsg);
13783 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13784 - if (cmd) {
13785 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13786 + if (!cmd)
13787 + return -ENOMEM;
13788
13789 - cpylen = copy_from_user(&msg, pdata->reqData, sizeof(msg));
13790 - cmd->dataLen = sizeof(*dmsg);
13791 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13792 - cmd->Command.SequenceNumber = 0;
13793 - cmd->Command.SessionId = Session;
13794 -
13795 - cmd->NwcCommand = NWC_GET_BROADCAST_MESSAGE;
13796 - dmsg = (PNwdCGetBroadcastNotification) cmd->data;
13797 - dmsg->uConnReference = (HANDLE) (unsigned long) msg.uConnReference;
13798 -
13799 - status =
13800 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13801 - (void **)&reply, &replylen,
13802 - INTERRUPTIBLE);
13803 -
13804 - if (reply) {
13805 - status = reply->Reply.ErrorCode;
13806 -
13807 - if (!status) {
13808 - char *cp = pdata->repData;
13809 -
13810 - dmsg =
13811 - (PNwdCGetBroadcastNotification) reply->data;
13812 - if (pdata->repLen < dmsg->messageLen) {
13813 - dmsg->messageLen = pdata->repLen;
13814 - }
13815 - msg.messageLen = dmsg->messageLen;
13816 - cpylen = offsetof(NwcGetBroadcastNotification, message);
13817 - cp += cpylen;
13818 - cpylen = copy_to_user(pdata->repData, &msg, cpylen);
13819 - cpylen = copy_to_user(cp, dmsg->message, msg.messageLen);
13820 - } else {
13821 - msg.messageLen = 0;
13822 - msg.message[0] = 0;
13823 - cpylen = offsetof(NwcGetBroadcastNotification, message);
13824 - cpylen = copy_to_user(pdata->repData, &msg, sizeof(msg));
13825 - }
13826 + cpylen = copy_from_user(&msg, pdata->reqData, sizeof(msg));
13827 + cmd->dataLen = sizeof(*dmsg);
13828 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13829 + cmd->Command.SequenceNumber = 0;
13830 + cmd->Command.SessionId = Session;
13831 +
13832 + cmd->NwcCommand = NWC_GET_BROADCAST_MESSAGE;
13833 + dmsg = (struct nwd_get_bcast_notification *) cmd->data;
13834 + dmsg->uConnReference = (void *) (unsigned long) msg.uConnReference;
13835 +
13836 + status =
13837 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13838 + (void **)&reply, &replylen,
13839 + INTERRUPTIBLE);
13840 +
13841 + if (reply) {
13842 + status = reply->Reply.ErrorCode;
13843
13844 - kfree(reply);
13845 + if (!status) {
13846 + char *cp = pdata->repData;
13847 +
13848 + dmsg =
13849 + (struct nwd_get_bcast_notification *) reply->data;
13850 + if (pdata->repLen < dmsg->messageLen) {
13851 + dmsg->messageLen = pdata->repLen;
13852 + }
13853 + msg.messageLen = dmsg->messageLen;
13854 + cpylen =
13855 + offsetof(struct
13856 + nwc_get_bcast_notification,
13857 + message);
13858 + cp += cpylen;
13859 + cpylen =
13860 + copy_to_user(pdata->repData, &msg, cpylen);
13861 + cpylen =
13862 + copy_to_user(cp, dmsg->message,
13863 + msg.messageLen);
13864 + } else {
13865 + msg.messageLen = 0;
13866 + msg.message[0] = 0;
13867 + cpylen = offsetof(struct
13868 + nwc_get_bcast_notification,
13869 + message);
13870 + cpylen =
13871 + copy_to_user(pdata->repData, &msg,
13872 + sizeof(msg));
13873 }
13874 - kfree(cmd);
13875 +
13876 + kfree(reply);
13877 }
13878 + kfree(cmd);
13879 return (status);
13880 }
13881
13882 -int NwdSetKeyValue(PXPLAT pdata, session_t Session)
13883 +int novfs_set_key_value(struct novfs_xplat *pdata, struct novfs_schandle Session)
13884 {
13885 - PXPLAT_CALL_REQUEST cmd;
13886 - PXPLAT_CALL_REPLY reply;
13887 - NwcSetKey xplatCall;
13888 - PNwdCSetKey pNewKey;
13889 - NwcString cstrObjectName, cstrPassword;
13890 + struct novfs_xplat_call_request *cmd;
13891 + struct novfs_xplat_call_reply *reply;
13892 + struct nwc_set_key xplatCall;
13893 + struct nwd_set_key *pNewKey;
13894 + struct nwc_string cstrObjectName, cstrPassword;
13895 char *str;
13896 unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
13897
13898 - cpylen = copy_from_user(&xplatCall, pdata->reqData, sizeof(NwcSetKey));
13899 + cpylen = copy_from_user(&xplatCall, pdata->reqData, sizeof(struct nwc_set_key));
13900 cpylen =
13901 copy_from_user(&cstrObjectName, xplatCall.pObjectName,
13902 - sizeof(NwcString));
13903 + sizeof(struct nwc_string));
13904 cpylen =
13905 copy_from_user(&cstrPassword, xplatCall.pNewPassword,
13906 - sizeof(NwcString));
13907 + sizeof(struct nwc_string));
13908
13909 datalen =
13910 - sizeof(NwdCSetKey) + cstrObjectName.DataLen + cstrPassword.DataLen;
13911 + sizeof(struct nwd_set_key ) + cstrObjectName.DataLen + cstrPassword.DataLen;
13912
13913 cmdlen = sizeof(*cmd) + datalen;
13914 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
13915 + cmd = kmalloc(cmdlen, GFP_KERNEL);
13916
13917 - if (cmd) {
13918 - pNewKey = (PNwdCSetKey) cmd->data;
13919 - cmd->dataLen = datalen;
13920 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13921 - cmd->Command.SequenceNumber = 0;
13922 - cmd->Command.SessionId = Session;
13923 - cmd->NwcCommand = NWC_SET_KEY;
13924 -
13925 - pNewKey->ObjectType = xplatCall.ObjectType;
13926 - pNewKey->AuthenticationId = xplatCall.AuthenticationId;
13927 - pNewKey->ConnHandle = (HANDLE) (unsigned long) xplatCall.ConnHandle;
13928 - str = (char *)pNewKey;
13929 + if (!cmd)
13930 + return -ENOMEM;
13931
13932 - /*
13933 - * Get the User Name
13934 - */
13935 - str += sizeof(NwdCSetKey);
13936 - cpylen =
13937 - copy_from_user(str, cstrObjectName.pBuffer,
13938 - cstrObjectName.DataLen);
13939 + pNewKey = (struct nwd_set_key *) cmd->data;
13940 + cmd->dataLen = datalen;
13941 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
13942 + cmd->Command.SequenceNumber = 0;
13943 + cmd->Command.SessionId = Session;
13944 + cmd->NwcCommand = NWC_SET_KEY;
13945
13946 - str += pNewKey->objectNameLen = cstrObjectName.DataLen;
13947 - pNewKey->objectNameOffset = sizeof(NwdCSetKey);
13948 + pNewKey->ObjectType = xplatCall.ObjectType;
13949 + pNewKey->AuthenticationId = xplatCall.AuthenticationId;
13950 + pNewKey->ConnHandle = (void *) (unsigned long) xplatCall.ConnHandle;
13951 + str = (char *)pNewKey;
13952
13953 - /*
13954 - * Get the Verify Password
13955 - */
13956 - cpylen =
13957 - copy_from_user(str, cstrPassword.pBuffer,
13958 - cstrPassword.DataLen);
13959 + /*
13960 + * Get the User Name
13961 + */
13962 + str += sizeof(struct nwd_set_key );
13963 + cpylen =
13964 + copy_from_user(str, cstrObjectName.pBuffer,
13965 + cstrObjectName.DataLen);
13966
13967 - pNewKey->newPasswordLen = cstrPassword.DataLen;
13968 - pNewKey->newPasswordOffset =
13969 - pNewKey->objectNameOffset + pNewKey->objectNameLen;
13970 -
13971 - status =
13972 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13973 - (void **)&reply, &replylen,
13974 - INTERRUPTIBLE);
13975 - if (reply) {
13976 - status = reply->Reply.ErrorCode;
13977 - kfree(reply);
13978 - }
13979 - memset(cmd, 0, cmdlen);
13980 - kfree(cmd);
13981 - }
13982 + str += pNewKey->objectNameLen = cstrObjectName.DataLen;
13983 + pNewKey->objectNameOffset = sizeof(struct nwd_set_key );
13984 +
13985 + /*
13986 + * Get the Verify Password
13987 + */
13988 + cpylen =
13989 + copy_from_user(str, cstrPassword.pBuffer,
13990 + cstrPassword.DataLen);
13991
13992 + pNewKey->newPasswordLen = cstrPassword.DataLen;
13993 + pNewKey->newPasswordOffset =
13994 + pNewKey->objectNameOffset + pNewKey->objectNameLen;
13995 +
13996 + status =
13997 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
13998 + (void **)&reply, &replylen,
13999 + INTERRUPTIBLE);
14000 + if (reply) {
14001 + status = reply->Reply.ErrorCode;
14002 + kfree(reply);
14003 + }
14004 + kfree(cmd);
14005 return (status);
14006 }
14007
14008 -/*++======================================================================*/
14009 -int NwdVerifyKeyValue(PXPLAT pdata, session_t Session)
14010 -/*
14011 - * Arguments:
14012 - *
14013 - * Returns:
14014 - *
14015 - * Abstract: Change the password on the server
14016 - *
14017 - * Notes:
14018 - *
14019 - * Environment:
14020 - *
14021 - *========================================================================*/
14022 -{
14023 - PXPLAT_CALL_REQUEST cmd;
14024 - PXPLAT_CALL_REPLY reply;
14025 - NwcVerifyKey xplatCall;
14026 - PNwdCVerifyKey pNewKey;
14027 - NwcString xferStr;
14028 +int novfs_verify_key_value(struct novfs_xplat *pdata, struct novfs_schandle Session)
14029 +{
14030 + struct novfs_xplat_call_request *cmd;
14031 + struct novfs_xplat_call_reply *reply;
14032 + struct nwc_verify_key xplatCall;
14033 + struct nwd_verify_key *pNewKey;
14034 + struct nwc_string xferStr;
14035 char *str;
14036 unsigned long status = -ENOMEM, cmdlen, datalen, replylen, cpylen;
14037
14038 cpylen =
14039 - copy_from_user(&xplatCall, pdata->reqData, sizeof(NwcVerifyKey));
14040 + copy_from_user(&xplatCall, pdata->reqData, sizeof(struct nwc_verify_key));
14041
14042 datalen =
14043 - sizeof(NwdCVerifyKey) + xplatCall.pDomainName->DataLen +
14044 + sizeof(struct nwd_verify_key) + xplatCall.pDomainName->DataLen +
14045 xplatCall.pObjectName->DataLen + xplatCall.pVerifyPassword->DataLen;
14046
14047 cmdlen = sizeof(*cmd) + datalen;
14048 - cmd = Novfs_Malloc(cmdlen, GFP_KERNEL);
14049 + cmd = (struct novfs_xplat_call_request *)kmalloc(cmdlen, GFP_KERNEL);
14050
14051 - if (cmd) {
14052 - pNewKey = (PNwdCVerifyKey) cmd->data;
14053 - cmd->dataLen = datalen;
14054 - cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
14055 - cmd->Command.SequenceNumber = 0;
14056 - cmd->Command.SessionId = Session;
14057 - cmd->NwcCommand = NWC_VERIFY_KEY;
14058 -
14059 - pNewKey->NameType = xplatCall.NameType;
14060 - pNewKey->ObjectType = xplatCall.ObjectType;
14061 - pNewKey->AuthType = xplatCall.AuthType;
14062 - str = (char *)pNewKey;
14063 + if (!cmd)
14064 + return -ENOMEM;
14065
14066 - /*
14067 - * Get the tree name
14068 - */
14069 - str += sizeof(*pNewKey);
14070 - cpylen =
14071 - copy_from_user(&xferStr, xplatCall.pDomainName,
14072 - sizeof(NwcString));
14073 - pNewKey->domainNameOffset = sizeof(*pNewKey);
14074 - cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
14075 - pNewKey->domainNameLen = xferStr.DataLen;
14076 + pNewKey = (struct nwd_verify_key *) cmd->data;
14077 + cmd->dataLen = datalen;
14078 + cmd->Command.CommandType = VFS_COMMAND_XPLAT_CALL;
14079 + cmd->Command.SequenceNumber = 0;
14080 + cmd->Command.SessionId = Session;
14081 + cmd->NwcCommand = NWC_VERIFY_KEY;
14082
14083 - /*
14084 - * Get the User Name
14085 - */
14086 - str += pNewKey->domainNameLen;
14087 - cpylen =
14088 - copy_from_user(&xferStr, xplatCall.pObjectName,
14089 - sizeof(NwcString));
14090 - pNewKey->objectNameOffset =
14091 - pNewKey->domainNameOffset + pNewKey->domainNameLen;
14092 - cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
14093 - pNewKey->objectNameLen = xferStr.DataLen;
14094 + pNewKey->NameType = xplatCall.NameType;
14095 + pNewKey->ObjectType = xplatCall.ObjectType;
14096 + pNewKey->AuthType = xplatCall.AuthType;
14097 + str = (char *)pNewKey;
14098
14099 - /*
14100 - * Get the Verify Password
14101 - */
14102 - str += pNewKey->objectNameLen;
14103 - cpylen =
14104 - copy_from_user(&xferStr, xplatCall.pVerifyPassword,
14105 - sizeof(NwcString));
14106 - pNewKey->verifyPasswordOffset =
14107 - pNewKey->objectNameOffset + pNewKey->objectNameLen;
14108 - cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
14109 - pNewKey->verifyPasswordLen = xferStr.DataLen;
14110 -
14111 - status =
14112 - Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
14113 - (void **)&reply, &replylen,
14114 - INTERRUPTIBLE);
14115 - if (reply) {
14116 - status = reply->Reply.ErrorCode;
14117 - kfree(reply);
14118 - }
14119 - memset(cmd, 0, cmdlen);
14120 - kfree(cmd);
14121 - }
14122 + /*
14123 + * Get the tree name
14124 + */
14125 + str += sizeof(*pNewKey);
14126 + cpylen =
14127 + copy_from_user(&xferStr, xplatCall.pDomainName,
14128 + sizeof(struct nwc_string));
14129 + pNewKey->domainNameOffset = sizeof(*pNewKey);
14130 + cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
14131 + pNewKey->domainNameLen = xferStr.DataLen;
14132 +
14133 + /*
14134 + * Get the User Name
14135 + */
14136 + str += pNewKey->domainNameLen;
14137 + cpylen =
14138 + copy_from_user(&xferStr, xplatCall.pObjectName,
14139 + sizeof(struct nwc_string));
14140 + pNewKey->objectNameOffset =
14141 + pNewKey->domainNameOffset + pNewKey->domainNameLen;
14142 + cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
14143 + pNewKey->objectNameLen = xferStr.DataLen;
14144 +
14145 + /*
14146 + * Get the Verify Password
14147 + */
14148 + str += pNewKey->objectNameLen;
14149 + cpylen =
14150 + copy_from_user(&xferStr, xplatCall.pVerifyPassword,
14151 + sizeof(struct nwc_string));
14152 + pNewKey->verifyPasswordOffset =
14153 + pNewKey->objectNameOffset + pNewKey->objectNameLen;
14154 + cpylen = copy_from_user(str, xferStr.pBuffer, xferStr.DataLen);
14155 + pNewKey->verifyPasswordLen = xferStr.DataLen;
14156
14157 + status =
14158 + Queue_Daemon_Command((void *)cmd, cmdlen, NULL, 0,
14159 + (void **)&reply, &replylen,
14160 + INTERRUPTIBLE);
14161 + if (reply) {
14162 + status = reply->Reply.ErrorCode;
14163 + kfree(reply);
14164 + }
14165 + kfree(cmd);
14166 return (status);
14167 }
14168 --- a/fs/novfs/nwcapi.h
14169 +++ b/fs/novfs/nwcapi.h
14170 @@ -109,14 +109,14 @@
14171
14172 #define IOC_XPLAT 0x4a540002
14173
14174 -typedef struct _XPLAT_ {
14175 +struct novfs_xplat {
14176 int xfunction;
14177 unsigned long reqLen;
14178 void *reqData;
14179 unsigned long repLen;
14180 void *repData;
14181
14182 -} XPLAT, *PXPLAT;
14183 +};
14184
14185 #if 0
14186 N_EXTERN_LIBRARY(NWRCODE)
14187 @@ -326,66 +326,30 @@ N_EXTERN_LIBRARY(NWRCODE)
14188
14189 //===[ Type definitions ]==================================================
14190
14191 -//
14192 -// Connection Handle returned from all OpenConnByXXXX calls
14193 -//
14194 -
14195 -typedef u32 NW_CONN_HANDLE, *PNW_CONN_HANDLE;
14196 -
14197 -//
14198 -// Authentication Id returned from the NwcCreateAuthenticationId call
14199 -//
14200 -
14201 -typedef u32 AUTHEN_ID, *PAUTHEN_ID;
14202
14203 //
14204 // Structure for defining what a transport
14205 // address looks like
14206 //
14207
14208 -typedef struct tagNwcTranAddr {
14209 +struct nwc_tran_addr {
14210 u32 uTransportType;
14211 u32 uAddressLength;
14212 unsigned char *puAddress;
14213 +};
14214
14215 -} NwcTranAddr, *PNwcTranAddr;
14216 -
14217 -//
14218 -// Structure for defining what a new transport
14219 -// address looks like
14220 -//
14221 -
14222 -typedef struct tagNwcTranAddrEx {
14223 - u32 uTransportType;
14224 - u32 uAddressLength;
14225 - unsigned char buBuffer[MAX_ADDRESS_LENGTH];
14226 -
14227 -} NwcTranAddrEx, *PNwcTranAddrEx;
14228
14229 -typedef struct tagNwcReferral {
14230 - u32 uAddrCnt;
14231 - PNwcTranAddrEx pAddrs;
14232 -
14233 -} NwcReferral, *PNwcReferral;
14234 -
14235 -typedef struct tagNwcServerVersion {
14236 - u32 uMajorVersion;
14237 - u16 uMinorVersion;
14238 - u16 uRevision;
14239 -
14240 -} NwcServerVersion, *PNwcServerVersion;
14241 -
14242 -typedef struct tagNwcConnString {
14243 +struct nwc_conn_string {
14244 char *pString;
14245 u32 uStringType;
14246 u32 uNameFormatType;
14247
14248 -} NwcConnString, *PNwcConnString;
14249 +};
14250
14251 //#if defined(NTYPES_H)
14252 //typedef NWCString NwcString, *PNwcString;
14253 //#else
14254 -typedef struct tagNwcString {
14255 +struct nwc_string {
14256 u32 DataType;
14257 u32 BuffSize;
14258 u32 DataLen;
14259 @@ -393,36 +357,18 @@ typedef struct tagNwcString {
14260 u32 CodePage;
14261 u32 CountryCode;
14262
14263 -} NwcString, *PNwcString;
14264 +};
14265 //#endif
14266
14267 //
14268 -// Structure used in NDS Resolve name
14269 -//
14270 -
14271 -#define RESOLVE_INFO_SVC_V1_00 0x00FE0001
14272 -
14273 -typedef struct tagNwcResolveInfo {
14274 - u32 uResolveInfoVersion;
14275 - u32 luFlags;
14276 - u32 luReqFlags;
14277 - u32 luReqScope;
14278 - u32 luResolveType;
14279 - u32 luRepFlags;
14280 - u32 luResolvedOffset;
14281 - u32 luDerefNameLen;
14282 - u16 *pDerefName;
14283 -} NwcResolveInfo, *PNwcResolveInfo;
14284 -
14285 -//
14286 // Definition of a fragment for the Raw NCP requests
14287 //
14288
14289 -typedef struct tagNwcFrag {
14290 +struct nwc_frag {
14291 void *pData;
14292 u32 uLength;
14293
14294 -} NwcFrag, *PNwcFrag;
14295 +};
14296
14297 //
14298 // Current connection information available for
14299 @@ -432,62 +378,6 @@ typedef struct tagNwcFrag {
14300 #define NW_INFO_BUFFER_SIZE NW_MAX_TREE_NAME_LEN + \
14301 NW_MAX_TREE_NAME_LEN + \
14302 NW_MAX_SERVICE_TYPE_LEN
14303 -
14304 -typedef struct tagNwcConnInfo {
14305 - u32 uInfoVersion;
14306 - u32 uAuthenticationState;
14307 - u32 uBroadcastState;
14308 - u32 uConnectionReference;
14309 - u32 TreeNameOffset;
14310 - u32 uSecurityState;
14311 - u32 uConnectionNumber;
14312 - u32 uUserId;
14313 - u32 ServerNameOffset;
14314 - u32 uNdsState;
14315 - u32 uMaxPacketSize;
14316 - u32 uLicenseState;
14317 - u32 uPublicState;
14318 - u32 bcastState;
14319 - u32 ServiceTypeOffset;
14320 - u32 uDistance;
14321 - u32 uAuthId;
14322 - u32 uDisconnected;
14323 - NwcServerVersion serverVersion;
14324 - NwcTranAddrEx tranAddress;
14325 - unsigned char buBuffer[NW_INFO_BUFFER_SIZE];
14326 -
14327 -} NwcConnInfo, *PNwcConnInfo;
14328 -
14329 -//
14330 -// Get Browse Connection References
14331 -//
14332 -
14333 -typedef struct _GetBrowseConnectionsRec {
14334 -
14335 - u32 recordSize;
14336 - u32 numConnectionsReturned;
14337 - u32 numConnectionsAvailable;
14338 - u32 connReferences[1];
14339 -
14340 -} GetBrowseConnectionRec, *PGetBrowseConnectionRec;
14341 -
14342 -//++=======================================================================
14343 -// API Name: NwcClearBroadcastMessage
14344 -//
14345 -// Arguments In: NONE
14346 -//
14347 -// Arguments Out: NONE
14348 -//
14349 -// Returns: STATUS_SUCCESS
14350 -//
14351 -// Abstract: This API is clears the broadcast message buffer.
14352 -//
14353 -// Notes:
14354 -//
14355 -// Environment: PASSIVE_LEVEL, LINUX
14356 -//
14357 -//=======================================================================--
14358 -
14359 //++=======================================================================
14360 // API Name: NwcCloseConn
14361 //
14362 @@ -514,10 +404,10 @@ typedef struct _GetBrowseConnectionsRec
14363 //
14364 //=======================================================================--
14365
14366 -typedef struct tagNwcCloseConn {
14367 - NW_CONN_HANDLE ConnHandle;
14368 +struct nwc_close_conn {
14369 + u32 ConnHandle;
14370
14371 -} NwcCloseConn, *PNwcCloseConn;
14372 +};
14373
14374 //++=======================================================================
14375 // API Name: NwcConvertLocalFileHandle
14376 @@ -548,11 +438,11 @@ typedef struct tagNwcCloseConn {
14377 //
14378 //=======================================================================--
14379
14380 -typedef struct tagNwcConvertLocalHandle {
14381 +struct nwc_convert_local_handle {
14382 u32 uConnReference;
14383 unsigned char NetWareHandle[6];
14384
14385 -} NwcConvertLocalHandle, *PNwcConvertLocalHandle;
14386 +};
14387
14388 //++=======================================================================
14389 // API Name: NwcConvertNetWareHandle
14390 @@ -592,121 +482,13 @@ typedef struct tagNwcConvertLocalHandle
14391 // Environment: PASSIVE_LEVEL, LINUX
14392 //
14393 //=======================================================================--
14394 -typedef struct tagNwcConvertNetWareHandle {
14395 - NW_CONN_HANDLE ConnHandle;
14396 +struct nwc_convert_netware_handle {
14397 + u32 ConnHandle;
14398 u32 uAccessMode;
14399 unsigned char NetWareHandle[6];
14400 u32 uFileSize;
14401 -} NwcConvertNetWareHandle, *PNwcConvertNetWareHandle;
14402 +};
14403
14404 -//++=======================================================================
14405 -// API Name: NwcFragmentRequest
14406 -//
14407 -// Arguments In: ConnHandle
14408 -// The connection handle the request is being
14409 -// directed to.
14410 -//
14411 -// uFunction
14412 -// The NCP function to be called, should be 104
14413 -// for NDS fragger/defragger requests.
14414 -//
14415 -// uSubFunction
14416 -// The NCP subfunction to be called, should be
14417 -// 2 for NDS fragger/defragger requests.
14418 -//
14419 -// uVerb
14420 -// The actual operation to be completed on the
14421 -// server backend.
14422 -//
14423 -// flags
14424 -// Currently not implemented. Reserved for
14425 -// future use.
14426 -//
14427 -// uNumRequestFrags
14428 -// The number of fragments that the request packet
14429 -// has been broken into.
14430 -//
14431 -// pRequestFrags
14432 -// List of fragments that make up the request packet.
14433 -// Each fragment includes the length of the fragment
14434 -// data and a pointer to the data.
14435 -//
14436 -// uNumReplyFrags
14437 -// The number of fragments the reply packet has been
14438 -// broken into.
14439 -//
14440 -// Arguments Out: pReplyFrags
14441 -// List of fragments that make up the reply packet.
14442 -// Each fragment includes the length of the fragment
14443 -// data and a pointer to the data.
14444 -//
14445 -// uActualReplyLength
14446 -// Total size of the reply packet after any header
14447 -// and tail information is removed.
14448 -//
14449 -// Returns: STATUS_SUCCESS
14450 -// NWE_ACCESS_VIOLATION
14451 -// NWE_CONN_INVALID
14452 -//
14453 -// Abstract: API for sending large NCP/NDS packets that are
14454 -// larger than the max MTU size for the underlying
14455 -// network.
14456 -//
14457 -// Notes:
14458 -//
14459 -// Environment: PASSIVE_LEVEL, LINUX
14460 -//
14461 -//=======================================================================--
14462 -typedef struct tagNwcFragmentRequest {
14463 - NW_CONN_HANDLE ConnHandle;
14464 - u32 uFunction;
14465 - u32 uSubFunction;
14466 - u32 uVerb;
14467 - u32 flags;
14468 - u32 uNumRequestFrags;
14469 - PNwcFrag pRequestFrags;
14470 - u32 uNumReplyFrags;
14471 - PNwcFrag pReplyFrags;
14472 - u32 uActualReplyLength;
14473 -} NwcFragmentRequest, *PNwcFragmentRequest;
14474 -
14475 -//++=======================================================================
14476 -// API Name: NwcGetBroadcastMessage
14477 -//
14478 -// Arguments In: uMessageFlags - Not currently used.
14479 -//
14480 -// uConnReference - connection reference for
14481 -// pending message.
14482 -//
14483 -// messageLen - length of message buffer.
14484 -//
14485 -// message - message buffer
14486 -//
14487 -// Arguments Out: messageLen - length of the message
14488 -//
14489 -// Returns: STATUS_SUCCESS
14490 -// NWE_ACCESS_VIOLATION
14491 -// NWE_NO_MORE_ENTRIES
14492 -//
14493 -// Abstract: This API is used for notifying a caller of pending
14494 -// broadcast messages on the server.
14495 -//
14496 -// Notes:
14497 -//
14498 -// Environment: PASSIVE_LEVEL, LINUX
14499 -//
14500 -//=======================================================================--
14501 -
14502 -/* jlt
14503 -typedef struct tagNwcGetBroadcastMessage
14504 -{
14505 - u32 uMessageFlags;
14506 - u32 uConnReference;
14507 - u32 messageLen;
14508 - unsigned char message[255];
14509 -
14510 -} NwcGetBroadcastMessage, *PNwcGetBroadcastMessage;
14511 -*/
14512
14513 //++=======================================================================
14514 // API Name: NwcGetConnInfo
14515 @@ -746,13 +528,13 @@ typedef struct tagNwcGetBroadcastMess
14516 //
14517 //=======================================================================--
14518
14519 -typedef struct tagNwcGetConnInfo {
14520 - NW_CONN_HANDLE ConnHandle;
14521 +struct nwc_get_conn_info {
14522 + u32 ConnHandle;
14523 u32 uInfoLevel;
14524 u32 uInfoLength;
14525 void *pConnInfo;
14526
14527 -} NwcGetConnInfo, *PNwcGetConnInfo;
14528 +};
14529
14530 //++=======================================================================
14531 // API Name: NwcGetDefaultNameContext
14532 @@ -785,14 +567,14 @@ typedef struct tagNwcGetConnInfo {
14533 //
14534 //=======================================================================--
14535
14536 -typedef struct tagNwcGetDefaultNameContext {
14537 +struct nwc_get_def_name_ctx {
14538 u32 uTreeLength;
14539 unsigned char *pDsTreeName;
14540 u32 uNameLength;
14541 // unsigned short *pNameContext;
14542 unsigned char *pNameContext;
14543
14544 -} NwcGetDefaultNameContext, *PNwcGetDefaultNameContext;
14545 +};
14546
14547 //++=======================================================================
14548 // API Name: NwcGetTreeMonitoredConnReference
14549 @@ -817,86 +599,12 @@ typedef struct tagNwcGetDefaultNameConte
14550 //
14551 //=======================================================================--
14552
14553 -typedef struct tagNwcGetTreeMonitoredConnRef {
14554 - PNwcString pTreeName;
14555 +struct nwc_get_tree_monitored_conn_ref {
14556 + struct nwc_string *pTreeName;
14557 u32 uConnReference;
14558
14559 -} NwcGetTreeMonitoredConnRef, *PNwcGetTreeMonitoredConnRef;
14560 +};
14561
14562 -//++=======================================================================
14563 -// API Name: NwcGetNumberConns
14564 -//
14565 -// Arguments In: NONE
14566 -//
14567 -// Arguments Out: uMaxConns - The maximum number of connections
14568 -// supported by the redirector. -1 for dynamic.
14569 -//
14570 -// uPublicConns - The current number of public
14571 -// connections.
14572 -//
14573 -// uTasksPrivateConns - The current number of private
14574 -// connections that are owned by the calling process.
14575 -//
14576 -// uOtherPrivateConns - The current number of private
14577 -// connections that are not owned by the calling
14578 -// process.
14579 -//
14580 -// Returns: STATUS_SUCCESS
14581 -// NWE_ACCESS_VIOLATION
14582 -// NWE_RESOURCE_LOCK
14583 -//
14584 -// Abstract: This API returns the current number of connections
14585 -// as well as the maximum number of supported
14586 -// connections. If the requester/redirector supports
14587 -// a dynamic connection table, -1 will be returned
14588 -// in the uMaxConns field.
14589 -//
14590 -// Notes:
14591 -//
14592 -// Environment: PASSIVE_LEVEL, LINUX
14593 -//
14594 -//=======================================================================--
14595 -
14596 -typedef struct tagNwcGetNumberConns {
14597 - u32 uMaxConns;
14598 - u32 uPublicConns;
14599 - u32 uTasksPrivateConns;
14600 - u32 uOtherPrivateConns;
14601 -
14602 -} NwcGetNumberConns, *PNwcGetNumberConns;
14603 -
14604 -//++=======================================================================
14605 -// API Name: NwcGetPreferredServer
14606 -//
14607 -// Arguments In: uServerNameLength - On input, this is the length
14608 -// in bytes of the server buffer. On output, this is
14609 -// the actual length of the server name string in bytes.
14610 -//
14611 -// Arguments Out: pServerName - The buffer to copy the preferred server
14612 -// name into.
14613 -//
14614 -// Returns: STATUS_SUCCESS
14615 -// NWE_ACCESS_VIOLATION
14616 -// NWE_BUFFER_OVERFLOW
14617 -// NWE_OBJECT_NOT_FOUND
14618 -// NWE_PARAM_INVALID
14619 -// NWE_RESOURCE_LOCK
14620 -//
14621 -// Abstract: This API returns the configured preferred bindery
14622 -// server previously set either by configuration or
14623 -// by calling NwcSetPreferredServer.
14624 -//
14625 -// Notes:
14626 -//
14627 -// Environment: PASSIVE_LEVEL, LINUX
14628 -//
14629 -//=======================================================================--
14630 -
14631 -typedef struct tagNwcGetPreferredServer {
14632 - u32 uServerNameLength;
14633 - char *pServerName;
14634 -
14635 -} NwcGetPreferredServer, *PNwcGetPreferredServer;
14636
14637 //++=======================================================================
14638 // API Name: NwcGetPreferredDsTree
14639 @@ -923,63 +631,10 @@ typedef struct tagNwcGetPreferredServer
14640 // Environment: PASSIVE_LEVEL, LINUX
14641 //
14642 //=======================================================================--
14643 -typedef struct tagNwcGetPreferredDsTree {
14644 +struct nwc_get_pref_ds_tree {
14645 u32 uTreeLength;
14646 unsigned char *pDsTreeName;
14647 -} NwcGetPreferredDsTree, *PNwcGetPreferredDsTree;
14648 -
14649 -//++=======================================================================
14650 -// API Name: NwcGetPrimaryConnection
14651 -//
14652 -// Arguments In: NONE
14653 -//
14654 -// Arguments Out: uConnReference - Reference to the primary connection.
14655 -//
14656 -// Returns: STATUS_SUCCESS
14657 -// NWE_ACCESS_VIOLATION
14658 -// NWE_CONN_PRIMARY_NOT_SET
14659 -//
14660 -// Abstract: This API returns the reference to the current primary
14661 -// connection in the redirector.
14662 -//
14663 -// Notes:
14664 -//
14665 -// Environment: PASSIVE_LEVEL, LINUX
14666 -//
14667 -//=======================================================================--
14668 -
14669 -typedef struct tagNwcGetPrimaryConnection {
14670 - u32 uConnReference;
14671 -
14672 -} NwcGetPrimaryConnection, *PNwcGetPrimaryConnection;
14673 -
14674 -//++=======================================================================
14675 -// API Name: NwcGetRequesterVersion
14676 -//
14677 -// Arguments In: NONE
14678 -//
14679 -// Arguments Out: uMajorVersion
14680 -// uMinorVersion
14681 -// uRevision
14682 -//
14683 -// Returns: STATUS_SUCCESS
14684 -// NWE_ACCESS_VIOLATION
14685 -//
14686 -// Abstract: This API returns the major version, minor version and
14687 -// revision of the requester/redirector.
14688 -//
14689 -// Notes:
14690 -//
14691 -// Environment: PASSIVE_LEVEL, LINUX
14692 -//
14693 -//=======================================================================--
14694 -
14695 -typedef struct tagNwcGetRequesterVersion {
14696 - u32 uMajorVersion;
14697 - u32 uMinorVersion;
14698 - u32 uRevision;
14699 -
14700 -} NwcGetRequesterVersion, *PNwcGetRequesterVersion;
14701 +};
14702
14703 //++=======================================================================
14704 // API Name: NwcLicenseConn
14705 @@ -1007,115 +662,10 @@ typedef struct tagNwcGetRequesterVersion
14706 //
14707 //=======================================================================--
14708
14709 -typedef struct tagNwcLicenseConn {
14710 - NW_CONN_HANDLE ConnHandle;
14711 -
14712 -} NwcLicenseConn, *PNwcLicenseConn;
14713 -
14714 -//++=======================================================================
14715 -// API Name: NwcMakeConnPermanent
14716 -//
14717 -// Arguments In: ConnHandle - An open connection handle associated
14718 -// with the connection to be made permanent.
14719 -//
14720 -// Arguments Out: NONE
14721 -//
14722 -// Returns: NWE_ACCESS_VIOLATION
14723 -// NWE_CONN_INVALID
14724 -// NWE_INVALID_OWNER
14725 -//
14726 -// Abstract: This API is used to keep the connection from being
14727 -// destroyed until a NwcSysCloseConn request is made
14728 -// on the connection. This allows the connection to
14729 -// remain after all processes that have the
14730 -// connection open terminate.
14731 -//
14732 -// Notes:
14733 -//
14734 -// Environment: PASSIVE_LEVEL, LINUX
14735 -//
14736 -//=======================================================================--
14737 -
14738 -typedef struct tagNwcMakeConnPermanent {
14739 - NW_CONN_HANDLE ConnHandle;
14740 -
14741 -} NwcMakeConnPermanent, *PNwcMakeConnPermanent;
14742 -
14743 -//++=======================================================================
14744 -// API Name: NwcMapDrive
14745 -//
14746 -// Arguments In: ConnHandle - The connection handle of the server
14747 -// to where the drive is to be mapped.
14748 -//
14749 -// LocalUID - Local user ID
14750 -//
14751 -// LocalPathLen - Length of local/link directory path string,
14752 -// including nul terminator.
14753 -//
14754 -// LocalPathOffset - Offset of local directory path that will
14755 -// be mapped to NetWare directory path.
14756 -//
14757 -// NetWarePathLen - Offset of NetWare directory path,
14758 -// including nul terminator.
14759 -//
14760 -// NetWarePathOffset - Offset of NetWare directory path in
14761 -// structure.
14762 -//
14763 -// Arguments Out: NONE
14764 -//
14765 -// Returns: STATUS_SUCCESS
14766 -// NWE_ACCESS_VIOLATION
14767 -// NWE_CONN_INVALID
14768 -// NWE_INSUFFICIENT_RESOURCES
14769 -// NWE_STRING_TRANSLATION
14770 -//
14771 -// Abstract: This API maps the target drive to the specified
14772 -// directory.
14773 -//
14774 -// Notes:
14775 -//
14776 -// Environment: PASSIVE_LEVEL, LINUX
14777 -//
14778 -//=======================================================================--
14779 -
14780 -typedef struct tagNwcMapDrive {
14781 - NW_CONN_HANDLE ConnHandle;
14782 - u32 LocalUID;
14783 - u32 LinkPathLen;
14784 - u32 LinkPathOffset;
14785 - u32 DestPathLen;
14786 - u32 DestPathOffset;
14787 +struct nwc_license_conn {
14788 + u32 ConnHandle;
14789 +};
14790
14791 -} NwcMapDrive, *PNwcMapDrive;
14792 -
14793 -//++=======================================================================
14794 -// API Name: NwcUnmapDrive
14795 -//
14796 -// Arguments In: LinkPathLen - Length of local/link path string,
14797 -// including nul terminator.
14798 -//
14799 -// LinkPath - Local/link path in structure
14800 -// to be unmapped
14801 -//
14802 -// Arguments Out: NONE
14803 -//
14804 -// Returns: STATUS_SUCCESS
14805 -// NWE_ACCESS_VIOLATION
14806 -// NWE_PARAM_INVALID
14807 -//
14808 -// Abstract: This API deletes a network drive mapping.
14809 -//
14810 -// Notes:
14811 -//
14812 -// Environment: PASSIVE_LEVEL, LINUX
14813 -//
14814 -//=======================================================================--
14815 -
14816 -typedef struct tagNwcUnmapDrive {
14817 - u32 LinkPathLen;
14818 - unsigned char LinkPath[1];
14819 -
14820 -} NwcUnmapDrive, *PNwcUnmapDrive;
14821
14822 //++=======================================================================
14823 // API Name: NWCGetMappedDrives
14824 @@ -1136,26 +686,11 @@ typedef struct tagNwcUnmapDrive {
14825 //
14826 //=======================================================================--
14827
14828 -typedef struct tagNwcMapDriveElem {
14829 - u32 ElemLen; // Lenght of drive element
14830 - u32 ConnRefernce; // Connection reference
14831 - u32 LinkPathLen; // Local/link dir path, length includes nul
14832 - unsigned char LinkPath[1]; // LinkPath[LinkPathLen]
14833 -// u32 DirPathLen; // NetWare dir path, length includes nul (vol:path)
14834 -// unsigned char DirPath[DirPathLen]; // NetWarePath[DirPathLen]
14835 -} NwcMapDriveElem, *PNwcMapDriveElem;
14836 -
14837 -typedef struct tagNwcMapDriveBuff {
14838 - u32 MapCount; // Number of mapped drives
14839 - NwcMapDriveElem MapDriveElem[1]; // MapDriveElem[MapCount]
14840 -
14841 -} NwcMapDriveBuff, *PNwcMapDriveBuff;
14842 -
14843 -typedef struct tagNwcGetMappedDrives {
14844 +struct nwc_get_mapped_drives {
14845 u32 MapBuffLen; // Buffer length (actual buffer size returned)
14846 - PNwcMapDriveBuff MapBuffer; // Pointer to map buffer
14847 + struct nwc_mapped_drive_buf *MapBuffer; // Pointer to map buffer
14848
14849 -} NwcGetMappedDrives, *PNwcGetMappedDrives;
14850 +};
14851
14852 //++=======================================================================
14853 // API Name: NwcGetMountPath
14854 @@ -1178,39 +713,11 @@ typedef struct tagNwcGetMappedDrives {
14855 //
14856 //=======================================================================--
14857
14858 -typedef struct tagNwcGetMountPath {
14859 +struct nwc_get_mount_path {
14860 u32 MountPathLen;
14861 unsigned char *pMountPath;
14862
14863 -} NwcGetMountPath, *PNwcGetMountPath;
14864 -
14865 -//++=======================================================================
14866 -// API Name: NwcMonitorConn
14867 -//
14868 -// Arguments In: ConnHandle - The handle associated with the connection
14869 -// that is to be marked as the monitored connection.
14870 -//
14871 -// Arguments Out: NONE
14872 -//
14873 -// Returns: STATUS_SUCCESS
14874 -// NWE_ACCESS_VIOLATION
14875 -// NWE_RESOURCE_LOCK
14876 -// NWE_CONN_INVALID
14877 -//
14878 -//
14879 -// Abstract: This call marks the connection associated with the
14880 -// connection handle as monitored.
14881 -//
14882 -// Notes:
14883 -//
14884 -// Environment: PASSIVE_LEVEL, LINUX
14885 -//
14886 -//=======================================================================--
14887 -
14888 -typedef struct tagNwcMonitorConn {
14889 - NW_CONN_HANDLE ConnHandle;
14890 -
14891 -} NwcMonitorConn, *PNwcMonitorConn;
14892 +};
14893
14894 //++=======================================================================
14895 // API Name: NwcOpenConnByAddr
14896 @@ -1244,13 +751,13 @@ typedef struct tagNwcMonitorConn {
14897 //
14898 //=======================================================================--
14899
14900 -typedef struct tagNwcOpenConnByAddr {
14901 +struct nwc_open_conn_by_addr {
14902 char *pServiceType;
14903 u32 uConnFlags;
14904 - PNwcTranAddr pTranAddr;
14905 - NW_CONN_HANDLE ConnHandle;
14906 + struct nwc_tran_addr *pTranAddr;
14907 + u32 ConnHandle;
14908
14909 -} NwcOpenConnByAddr, *PNwcOpenConnByAddr;
14910 +};
14911
14912 //++=======================================================================
14913 // API Name: NwcOpenConnByName
14914 @@ -1304,15 +811,15 @@ typedef struct tagNwcOpenConnByAddr {
14915 //
14916 //=======================================================================--
14917
14918 -typedef struct tagNwcOpenConnByName {
14919 - NW_CONN_HANDLE ConnHandle;
14920 - PNwcConnString pName;
14921 +struct nwc_open_conn_by_name {
14922 + u32 ConnHandle;
14923 + struct nwc_conn_string *pName;
14924 char *pServiceType;
14925 u32 uConnFlags;
14926 u32 uTranType;
14927 - NW_CONN_HANDLE RetConnHandle;
14928 + u32 RetConnHandle;
14929
14930 -} NwcOpenConnByName, *PNwcOpenConnByName;
14931 +};
14932
14933 //++=======================================================================
14934 // API Name: NwcOpenConnByReference
14935 @@ -1346,12 +853,12 @@ typedef struct tagNwcOpenConnByName {
14936 //
14937 //=======================================================================--
14938
14939 -typedef struct tagNwcOpenConnByReference {
14940 +struct nwc_open_conn_by_ref {
14941 u32 uConnReference;
14942 u32 uConnFlags;
14943 - NW_CONN_HANDLE ConnHandle;
14944 + u32 ConnHandle;
14945
14946 -} NwcOpenConnByReference, *PNwcOpenConnByReference;
14947 +};
14948
14949 //++=======================================================================
14950 // API Name: NwcRawRequest
14951 @@ -1390,55 +897,16 @@ typedef struct tagNwcOpenConnByReference
14952 //
14953 //=======================================================================--
14954
14955 -typedef struct tagNwcRequest {
14956 - NW_CONN_HANDLE ConnHandle;
14957 +struct nwc_request {
14958 + u32 ConnHandle;
14959 u32 uFunction;
14960 u32 uNumRequestFrags;
14961 - PNwcFrag pRequestFrags;
14962 + struct nwc_frag *pRequestFrags;
14963 u32 uNumReplyFrags;
14964 - PNwcFrag pReplyFrags;
14965 + struct nwc_frag *pReplyFrags;
14966 u32 uActualReplyLength;
14967
14968 -} NwcRequest, *PNwcRequest;
14969 -
14970 -//++=======================================================================
14971 -// API Name: NwcRawRequestAll
14972 -//
14973 -// Arguments In: uFunction - The NCP function that is being called.
14974 -//
14975 -// uNumRequestFrags - The number of fragments that the
14976 -// request packet has been broken into.
14977 -//
14978 -// pRequestFrags - List of fragments that make up the
14979 -// request packet. Each fragment includes the length
14980 -// of the fragment data and a pointer to the data.
14981 -//
14982 -// Arguments Out: NONE
14983 -//
14984 -// Returns: STATUS_SUCCESS
14985 -// NWE_ACCESS_VIOLATION
14986 -// NWE_CONN_INVALID
14987 -//
14988 -// Abstract: API for sending the given NCP request to all valid
14989 -// connections. If there is a private connection that
14990 -// is not owned by the caller of this function, that
14991 -// connection will not be included. Also, if the
14992 -// caller has both a private and a public connection
14993 -// to the same server, only the private connection
14994 -// will receive the request.
14995 -//
14996 -// Notes:
14997 -//
14998 -// Environment: PASSIVE_LEVEL, LINUX
14999 -//
15000 -//=======================================================================--
15001 -
15002 -typedef struct tagNwcRequestAll {
15003 - u32 uFunction;
15004 - u32 uNumRequestFrags;
15005 - PNwcFrag pRequestFrags;
15006 -
15007 -} NwcRequestAll, *PNwcRequestAll;
15008 +};
15009
15010 //++=======================================================================
15011 // API Name: NwcScanConnInfo
15012 @@ -1544,7 +1012,7 @@ typedef struct tagNwcRequestAll {
15013 //
15014 //=======================================================================--
15015
15016 -typedef struct tagNwcScanConnInfo {
15017 +struct nwc_scan_conn_info {
15018 u32 uScanIndex;
15019 u32 uScanInfoLevel;
15020 u32 uScanInfoLen;
15021 @@ -1555,7 +1023,7 @@ typedef struct tagNwcScanConnInfo {
15022 u32 uConnectionReference;
15023 void *pReturnConnInfo;
15024
15025 -} NwcScanConnInfo, *PNwcScanConnInfo;
15026 +};
15027
15028 //++=======================================================================
15029 // API Name: NwcSetConnInfo
15030 @@ -1589,13 +1057,13 @@ typedef struct tagNwcScanConnInfo {
15031 //
15032 //=======================================================================--
15033
15034 -typedef struct tagNwcSetConnInfo {
15035 - NW_CONN_HANDLE ConnHandle;
15036 +struct nwc_set_conn_info {
15037 + u32 ConnHandle;
15038 u32 uInfoLevel;
15039 u32 uInfoLength;
15040 void *pConnInfo;
15041
15042 -} NwcSetConnInfo, *PNwcSetConnInfo;
15043 +};
15044
15045 //++=======================================================================
15046 // API Name: NwcSetDefaultNameContext
15047 @@ -1626,14 +1094,14 @@ typedef struct tagNwcSetConnInfo {
15048 //
15049 //=======================================================================--
15050
15051 -typedef struct tagNwcSetDefaultNameContext {
15052 +struct nwc_set_def_name_ctx {
15053 u32 uTreeLength;
15054 unsigned char *pDsTreeName;
15055 u32 uNameLength;
15056 // unsined short *pNameContext;
15057 unsigned char *pNameContext;
15058
15059 -} NwcSetDefaultNameContext, *PNwcSetDefaultNameContext;
15060 +};
15061
15062 //++=======================================================================
15063 // API Name: NwcSetPreferredDsTree
15064 @@ -1658,41 +1126,11 @@ typedef struct tagNwcSetDefaultNameConte
15065 //
15066 //=======================================================================--
15067
15068 -typedef struct tagNwcSetPreferredDsTree {
15069 +struct nwc_set_pref_ds_tree {
15070 u32 uTreeLength;
15071 unsigned char *pDsTreeName;
15072
15073 -} NwcSetPreferredDsTree, *PNwcSetPreferredDsTree;
15074 -
15075 -//++=======================================================================
15076 -// API Name: NwcSetPreferredServer
15077 -//
15078 -// Arguments In: uServerNameLength - The length in bytes of the
15079 -// preferred server string.
15080 -//
15081 -// pServerName - a pointer to an ASCIIZ string of the
15082 -// preferred bindery server.
15083 -//
15084 -// Arguments Out: NONE
15085 -//
15086 -// Returns: STATUS_SUCCESS
15087 -// NWE_ACCESS_VIOLATION
15088 -// NWE_INSUFFICIENT_RESOURCES
15089 -// NWE_RESOURCE_LOCK
15090 -//
15091 -// Abstract: This API sets the preferred server name.
15092 -//
15093 -// Notes:
15094 -//
15095 -// Environment: PASSIVE_LEVEL, LINUX
15096 -//
15097 -//=======================================================================--
15098 -
15099 -typedef struct tagNwcSetPreferredServer {
15100 - u32 uServerNameLength;
15101 - char *pServerName;
15102 -
15103 -} NwcSetPreferredServer, *PNwcSetPreferredServer;
15104 +};
15105
15106 //++=======================================================================
15107 // API Name: NwcSetPrimaryConnection
15108 @@ -1716,69 +1154,11 @@ typedef struct tagNwcSetPreferredServer
15109 //
15110 //=======================================================================--
15111
15112 -typedef struct tagNwcSetPrimaryConnection {
15113 - NW_CONN_HANDLE ConnHandle;
15114 -
15115 -} NwcSetPrimaryConnection, *PNwcSetPrimaryConnection;
15116 -
15117 -//++=======================================================================
15118 -// API Name: NwcSysCloseConn
15119 -//
15120 -// Arguments In: ConnHandle - The handle to a connection that is
15121 -// to be destroyed.
15122 -//
15123 -// Arguments Out: NONE
15124 -//
15125 -// Returns: STATUS_SUCCESS
15126 -// NWE_ACCESS_VIOLATION
15127 -// NWE_CONN_INVALID
15128 -//
15129 -// Abstract: This API is similiar to the NwcCloseConn API, except
15130 -// that it forces all handles to the connection closed
15131 -// and destroys the service connection. This is a system
15132 -// level request that will cause all processes that are
15133 -// accessing this connection to lose access to the
15134 -// resources associated to the connection.
15135 -//
15136 -// Notes:
15137 -//
15138 -// Environment: PASSIVE_LEVEL, LINUX
15139 -//
15140 -//=======================================================================--
15141 -
15142 -typedef struct tagNwcSysCloseConn {
15143 - NW_CONN_HANDLE ConnHandle;
15144 -
15145 -} NwcSysCloseConn, *PNwcSysCloseConn;
15146 -
15147 -//++=======================================================================
15148 -// API Name: NwcUnlicenseConn
15149 -//
15150 -// Arguments In: ConnHandle - Open connection handle that will be
15151 -// accessing the connection in an unlicensed manner.
15152 -//
15153 -// Arguments Out: NONE
15154 -//
15155 -// Returns: STATUS_SUCCESS
15156 -// NWE_ACCESS_VIOLATION
15157 -// NWE_CONN_INVALID
15158 -// NWE_HANDLE_ALREADY_UNLICENSED
15159 -//
15160 -// Abstract: This API is used to change the state of a connection
15161 -// handle from licensed to unlicensed. If all handles
15162 -// to the connection have been changed to the unlicensed
15163 -// state, the unlicensed NCP is sent to the server.
15164 -//
15165 -// Notes:
15166 -//
15167 -// Environment: PASSIVE_LEVEL, LINUX
15168 -//
15169 -//=======================================================================--
15170 +struct nwc_set_primary_conn {
15171 + u32 ConnHandle;
15172
15173 -typedef struct tagNwcUnlicenseConn {
15174 - NW_CONN_HANDLE ConnHandle;
15175 +};
15176
15177 -} NwcUnlicenseConn, *PNwcUnlicenseConn;
15178
15179 //++=======================================================================
15180 // API Name: NwcQueryFeature
15181 @@ -1801,10 +1181,10 @@ typedef struct tagNwcUnlicenseConn {
15182 //
15183 //=======================================================================--
15184
15185 -typedef struct tagNwcQueryFeature {
15186 +struct nwc_query_feature {
15187 u32 Feature;
15188
15189 -} NwcQueryFeature, *PNwcQueryFeature;
15190 +};
15191
15192 //++=======================================================================
15193 // API Name: NWCChangePassword
15194 @@ -1824,16 +1204,16 @@ typedef struct tagNwcQueryFeature {
15195 //
15196 //=======================================================================--
15197
15198 -typedef struct tagNwcChangeKey {
15199 - PNwcString pDomainName;
15200 +struct nwc_change_key {
15201 + struct nwc_string *pDomainName;
15202 u32 AuthType;
15203 - PNwcString pObjectName;
15204 + struct nwc_string *pObjectName;
15205 u32 NameType;
15206 u16 ObjectType;
15207 - PNwcString pVerifyPassword;
15208 - PNwcString pNewPassword;
15209 + struct nwc_string *pVerifyPassword;
15210 + struct nwc_string *pNewPassword;
15211
15212 -} NwcChangeKey, *PNwcChangeKey;
15213 +};
15214
15215 //++=======================================================================
15216 // API Name: NWCEnumerateIdentities `
15217 @@ -1853,17 +1233,17 @@ typedef struct tagNwcChangeKey {
15218 //
15219 //=======================================================================--
15220
15221 -typedef struct tagNwcEnumerateIdentities {
15222 +struct nwc_enum_ids {
15223 u32 Iterator;
15224 - PNwcString pDomainName;
15225 + struct nwc_string *pDomainName;
15226 u32 AuthType;
15227 - PNwcString pObjectName;
15228 + struct nwc_string *pObjectName;
15229 u32 NameType;
15230 u16 ObjectType;
15231 u32 IdentityFlags;
15232 - AUTHEN_ID AuthenticationId;
15233 + u32 AuthenticationId;
15234
15235 -} NwcEnumerateIdentities, *PNwcEnumerateIdentities;
15236 +};
15237
15238 //++=======================================================================
15239 // API Name: NWCGetIdentityInfo
15240 @@ -1883,16 +1263,16 @@ typedef struct tagNwcEnumerateIdentities
15241 //
15242 //=======================================================================--
15243
15244 -typedef struct tagNwcGetIdentityInfo {
15245 - AUTHEN_ID AuthenticationId;
15246 - PNwcString pDomainName;
15247 +struct nwc_get_id_info {
15248 + u32 AuthenticationId;
15249 + struct nwc_string *pDomainName;
15250 u32 AuthType;
15251 - PNwcString pObjectName;
15252 + struct nwc_string *pObjectName;
15253 u32 NameType;
15254 u16 ObjectType;
15255 u32 IdentityFlags;
15256
15257 -} NwcGetIdentityInfo, *PNwcGetIdentityInfo;
15258 +};
15259
15260 //++=======================================================================
15261 // API Name: NWCLoginIdentity
15262 @@ -1912,41 +1292,18 @@ typedef struct tagNwcGetIdentityInfo {
15263 //
15264 //=======================================================================--
15265
15266 -typedef struct tagNwcLoginIdentity {
15267 - PNwcString pDomainName;
15268 +struct nwc_login_id {
15269 + struct nwc_string *pDomainName;
15270 u32 AuthType;
15271 - PNwcString pObjectName;
15272 + struct nwc_string *pObjectName;
15273 u32 NameType;
15274 u16 ObjectType;
15275 u32 IdentityFlags;
15276 - PNwcString pPassword;
15277 - AUTHEN_ID AuthenticationId;
15278 -
15279 -} NwcLoginIdentity, *PNwcLoginIdentity;
15280 -
15281 -//++=======================================================================
15282 -// API Name: NWCLogoutIdentity
15283 -////
15284 -
15285 -// Arguments In:
15286 -//
15287 -// Arguments Out:
15288 -//
15289 -// Returns: STATUS_SUCCESS
15290 -// NWE_ACCESS_VIOLATION
15291 -//
15292 -// Abstract:
15293 -//
15294 -// Notes:
15295 -//
15296 -// Environment: PASSIVE_LEVEL, LINUX
15297 -//
15298 -//=======================================================================--
15299 + struct nwc_string *pPassword;
15300 + u32 AuthenticationId;
15301
15302 -typedef struct tagNwcLogoutIdentity {
15303 - AUTHEN_ID AuthenticationId;
15304 +};
15305
15306 -} NwcLogoutIdentity, *PNwcLogoutIdentity;
15307
15308 //++=======================================================================
15309 // API Name: NWCSetPassword
15310 @@ -1966,14 +1323,14 @@ typedef struct tagNwcLogoutIdentity {
15311 //
15312 //=======================================================================--
15313
15314 -typedef struct tagNwcSetKey {
15315 - NW_CONN_HANDLE ConnHandle;
15316 - AUTHEN_ID AuthenticationId;
15317 - PNwcString pObjectName;
15318 +struct nwc_set_key {
15319 + u32 ConnHandle;
15320 + u32 AuthenticationId;
15321 + struct nwc_string *pObjectName;
15322 u16 ObjectType;
15323 - PNwcString pNewPassword;
15324 + struct nwc_string *pNewPassword;
15325
15326 -} NwcSetKey, *PNwcSetKey;
15327 +};
15328
15329 //++=======================================================================
15330 // API Name: NWCVerifyPassword
15331 @@ -1993,15 +1350,15 @@ typedef struct tagNwcSetKey {
15332 //
15333 //++=======================================================================
15334
15335 -typedef struct tagNwcVerifyKey {
15336 - PNwcString pDomainName;
15337 +struct nwc_verify_key {
15338 + struct nwc_string *pDomainName;
15339 u32 AuthType;
15340 - PNwcString pObjectName;
15341 + struct nwc_string *pObjectName;
15342 u32 NameType;
15343 u16 ObjectType;
15344 - PNwcString pVerifyPassword;
15345 + struct nwc_string *pVerifyPassword;
15346
15347 -} NwcVerifyKey, *PNwcVerifyKey;
15348 +};
15349
15350 //++=======================================================================
15351 // API Name: NwcAuthenticateWithId
15352 @@ -2026,188 +1383,34 @@ typedef struct tagNwcVerifyKey {
15353 //
15354 //=======================================================================--
15355
15356 -typedef struct tagNwcAuthenticateWithId {
15357 - NW_CONN_HANDLE ConnHandle;
15358 - AUTHEN_ID AuthenticationId;
15359 -
15360 -} NwcAuthenticateWithId, *PNwcAuthenticateWithId;
15361 -
15362 -//++=======================================================================
15363 -// API Name: NwcUnauthenticate
15364 -//
15365 -// Arguments In: ConnHandle - The connection to unauthenticate.
15366 -//
15367 -// Arguments Out: NONE
15368 -//
15369 -// Returns: STATUS_SUCCESS
15370 -// NWE_ACCESS_VIOLATION
15371 -// NWE_CONN_INVALID
15372 -// NWE_INVALID_OWNER
15373 -// NWE_RESOURCE_LOCK
15374 -//
15375 -// Abstract: This API removes the authentication for the specified
15376 -// connection.
15377 -//
15378 -// Notes:
15379 -//
15380 -// Environment: PASSIVE_LEVEL, LINUX
15381 -//
15382 -//=======================================================================--
15383 -
15384 -typedef struct tagNwcUnauthenticate {
15385 - NW_CONN_HANDLE ConnHandle;
15386 - AUTHEN_ID AuthenticationId;
15387 -
15388 -} NwcUnauthenticate, *PNwcUnauthenticate;
15389 -
15390 -//++=======================================================================
15391 -// API Name: NwcGetCfgNameServiceProviders
15392 -//
15393 -// Arguments In:
15394 -//
15395 -// Arguments Out:
15396 -//
15397 -// Returns: STATUS_SUCCESS
15398 -// NWE_ACCESS_VIOLATION
15399 -//
15400 -// Abstract:
15401 -//
15402 -// Notes:
15403 -//
15404 -// Environment: PASSIVE_LEVEL, LINUX
15405 -//
15406 -//=======================================================================--
15407 -
15408 -typedef struct {
15409 - u32 providerCount;
15410 - u32 providers[MAX_NAME_SERVICE_PROVIDERS];
15411 -
15412 -} NwcGetCfgNameServiceProviders, *PNwcGetCfgNameServiceProviders;
15413 -
15414 -//++=======================================================================
15415 -// API Name: NwcNdsResolveNameToId
15416 -//
15417 -// Arguments In: connHandle
15418 -// Specifies connection to use to resolve name with.
15419 -//
15420 -// pName
15421 -// Points to the name of the NDS entry to resolve.
15422 -//
15423 -// uReqTranType
15424 -// Specifies the preferred or required transport to
15425 -// be used.
15426 -//
15427 -// pResolveInfo
15428 -// Points to the NwcNdsResolveInfo structure
15429 -// containing information on how the entry is to be
15430 -// resolved.
15431 -//
15432 -// Arguments Out: pResolveInfo
15433 -// Points to the NwcNdsResolveInfo structure
15434 -// containing return information on the resolved
15435 -// entry.
15436 -//
15437 -// pluEntryId
15438 -// Points to the resolved name's entry ID.
15439 -//
15440 -// pReferral
15441 -// Points to the NwcReferral structure which describes
15442 -// network addresses that can be used to locate other
15443 -// NDS partitions that contain the entry name.
15444 -//
15445 -// Returns: STATUS_SUCCESS
15446 -// NWE_CONN_INVALID,
15447 -// NWE_BUFFER_OVERFLOW,
15448 -// NWE_TRAN_INVALID_TYPE,
15449 -// NWE_ACCESS_VIOLATION,
15450 -// NWE_UNSUPPORTED_TRAN_TYPE,
15451 -// Nds error code
15452 -//
15453 -// Abstract: This API resolves a NDS entry name.
15454 -//
15455 -// Notes:
15456 -//
15457 -// Environment: PASSIVE_LEVEL, LINUX
15458 -//
15459 -//=======================================================================--
15460 -
15461 -typedef struct tagNwcNdsResolveNameToId {
15462 - NW_CONN_HANDLE connHandle;
15463 - PNwcString pName;
15464 - u32 uReqTranType;
15465 - PNwcResolveInfo pResolveInfo;
15466 - u32 entryId;
15467 - PNwcReferral pReferral;
15468 -
15469 -} NwcNdsResolveNameToId, *PNwcNdsResolveNameToId;
15470 -
15471 -//++=======================================================================
15472 -// API Name: NwcOrderedRequest
15473 -//
15474 -// Arguments In: uFunction - The NCP function that is being called.
15475 -//
15476 -// uNumRequestFrags - The number of fragments that the
15477 -// request packet has been broken into.
15478 -//
15479 -// pRequestFrags - List of fragments that make up the
15480 -// request packet. Each fragment includes the length
15481 -// of the fragment data and a pointer to the data.
15482 -//
15483 -// uInverseReqCode - The NCP function that will be called
15484 -// if the request fails.
15485 -//
15486 -// uNumInverseFrags - The number of fragments the inverse
15487 -// request packet has been broken into.
15488 -//
15489 -// pReplyFrags - List of fragments that make up the
15490 -// inverse request packet. Each fragment includes the length
15491 -// of the fragment data and a pointer to the data.
15492 -//
15493 -// Returns: STATUS_SUCCESS
15494 -// NWE_ACCESS_VIOLATION
15495 -// NWE_CONN_INVALID
15496 -//
15497 -// Abstract: API for sending raw NCP packets directly to a server.
15498 -//
15499 -// Notes:
15500 -//
15501 -// Environment: PASSIVE_LEVEL, LINUX
15502 -//
15503 -//=======================================================================--
15504 +struct nwc_auth_with_id {
15505 + u32 ConnHandle;
15506 + u32 AuthenticationId;
15507
15508 -typedef struct tagNwcOrderedRequest {
15509 - u32 uReqCode;
15510 - u32 uNumRequestFrags;
15511 - PNwcFrag pRequestFrags;
15512 - u32 uInverseReqCode;
15513 - u32 uNumInverseFrags;
15514 - PNwcFrag pInverseFrags;
15515 +};
15516
15517 -} NwcOrderedRequest, *PNwcOrderedRequest;
15518
15519 -#if 1 //sgled
15520 -typedef struct tagNwcUnmapDriveEx {
15521 +struct nwc_unmap_drive_ex {
15522 // unsigned long connHdl;
15523 unsigned int linkLen;
15524 char linkData[1];
15525
15526 -} NwcUnmapDriveEx, *PNwcUnmapDriveEx;
15527 +};
15528
15529 -typedef struct tagNwcMapDriveEx {
15530 - NW_CONN_HANDLE ConnHandle;
15531 +struct nwc_map_drive_ex {
15532 + u32 ConnHandle;
15533 unsigned int localUid;
15534 unsigned int linkOffsetLength;
15535 unsigned int linkOffset;
15536 unsigned int dirPathOffsetLength;
15537 unsigned int dirPathOffset;
15538 -} NwcMapDriveEx, *PNwcMapDriveEx;
15539 +};
15540
15541 -typedef struct tagNwcGetBroadcastNotification {
15542 +struct nwc_get_bcast_notification {
15543 u32 uMessageFlags;
15544 u32 uConnReference;
15545 u32 messageLen;
15546 char message[1];
15547 -} NwcGetBroadcastNotification, *PNwcGetBroadcastNotification;
15548 +};
15549
15550 -#endif
15551 #endif /* __NWCLNX_H__ */
15552 --- a/fs/novfs/proc.c
15553 +++ b/fs/novfs/proc.c
15554 @@ -20,13 +20,13 @@
15555
15556 #include "vfs.h"
15557
15558 -struct proc_dir_entry *Novfs_Procfs_dir;
15559 -static struct proc_dir_entry *Novfs_Control;
15560 -static struct proc_dir_entry *Novfs_Library;
15561 -static struct proc_dir_entry *Novfs_Version;
15562 +struct proc_dir_entry *novfs_procfs_dir;
15563 +struct proc_dir_entry *Novfs_Control;
15564 +struct proc_dir_entry *Novfs_Library;
15565 +struct proc_dir_entry *Novfs_Version;
15566
15567 -static struct file_operations Daemon_proc_fops;
15568 -static struct file_operations Library_proc_fops;
15569 +static struct file_operations novfs_daemon_proc_fops;
15570 +static struct file_operations novfs_lib_proc_fops;
15571
15572 /*===[ Code ]=============================================================*/
15573
15574 @@ -39,17 +39,17 @@ static int Novfs_Get_Version(char *page,
15575 buf = page + off;
15576 *start = buf;
15577 len = sprintf(buf, "Novfs Version=%s\n", NOVFS_VERSION_STRING);
15578 - i = Daemon_getversion(tbuf, sizeof(tbuf));
15579 + i = novfs_daemon_getversion(tbuf, sizeof(tbuf));
15580 if ((i > 0) && i < (count - len)) {
15581 len += sprintf(buf + len, "Novfsd Version=%s\n", tbuf);
15582 }
15583
15584 - if (Novfs_CurrentMount) {
15585 - i = strlen(Novfs_CurrentMount);
15586 + if (novfs_current_mnt) {
15587 + i = strlen(novfs_current_mnt);
15588 if ((i > 0) && i < (count - len)) {
15589 len +=
15590 sprintf(buf + len, "Novfs mount=%s\n",
15591 - Novfs_CurrentMount);
15592 + novfs_current_mnt);
15593 }
15594 }
15595 DbgPrint("Novfs_Get_Version:\n%s\n", buf);
15596 @@ -58,39 +58,40 @@ static int Novfs_Get_Version(char *page,
15597 return (len);
15598 }
15599
15600 -int Init_Procfs_Interface(void)
15601 +int novfs_proc_init(void)
15602 {
15603 int retCode = 0;
15604
15605 - Novfs_Procfs_dir = proc_mkdir(MODULE_NAME, NULL);
15606 - if (Novfs_Procfs_dir) {
15607 - Novfs_Procfs_dir->owner = THIS_MODULE;
15608 + novfs_procfs_dir = proc_mkdir(MODULE_NAME, NULL);
15609 + if (novfs_procfs_dir) {
15610 + novfs_procfs_dir->owner = THIS_MODULE;
15611
15612 - Novfs_Control = create_proc_entry("Control", 0600, Novfs_Procfs_dir);
15613 + Novfs_Control = create_proc_entry("Control", 0600, novfs_procfs_dir);
15614
15615 if (Novfs_Control) {
15616 Novfs_Control->owner = THIS_MODULE;
15617 Novfs_Control->size = 0;
15618 - memcpy(&Daemon_proc_fops, Novfs_Control->proc_fops,
15619 - sizeof(struct file_operations));
15620 + memcpy(&novfs_daemon_proc_fops,
15621 + Novfs_Control->proc_fops,
15622 + sizeof(struct file_operations));
15623
15624 /*
15625 * Setup our functions
15626 */
15627 - Daemon_proc_fops.owner = THIS_MODULE;
15628 - Daemon_proc_fops.open = Daemon_Open_Control;
15629 - Daemon_proc_fops.release = Daemon_Close_Control;
15630 - Daemon_proc_fops.read = Daemon_Send_Command;
15631 - Daemon_proc_fops.write = Daemon_Receive_Reply;
15632 - Daemon_proc_fops.ioctl = Daemon_ioctl;
15633 + novfs_daemon_proc_fops.owner = THIS_MODULE;
15634 + novfs_daemon_proc_fops.open = novfs_daemon_open_control;
15635 + novfs_daemon_proc_fops.release = novfs_daemon_close_control;
15636 + novfs_daemon_proc_fops.read = novfs_daemon_cmd_send;
15637 + novfs_daemon_proc_fops.write = novfs_daemon_recv_reply;
15638 + novfs_daemon_proc_fops.ioctl = novfs_daemon_ioctl;
15639
15640 - Novfs_Control->proc_fops = &Daemon_proc_fops;
15641 + Novfs_Control->proc_fops = &novfs_daemon_proc_fops;
15642 } else {
15643 remove_proc_entry(MODULE_NAME, NULL);
15644 return (-ENOENT);
15645 }
15646
15647 - Novfs_Library = create_proc_entry("Library", 0666, Novfs_Procfs_dir);
15648 + Novfs_Library = create_proc_entry("Library", 0666, novfs_procfs_dir);
15649 if (Novfs_Library) {
15650 Novfs_Library->owner = THIS_MODULE;
15651 Novfs_Library->size = 0;
15652 @@ -98,31 +99,31 @@ int Init_Procfs_Interface(void)
15653 /*
15654 * Setup our file functions
15655 */
15656 - memcpy(&Library_proc_fops, Novfs_Library->proc_fops,
15657 + memcpy(&novfs_lib_proc_fops, Novfs_Library->proc_fops,
15658 sizeof(struct file_operations));
15659 - Library_proc_fops.owner = THIS_MODULE;
15660 - Library_proc_fops.open = Daemon_Library_open;
15661 - Library_proc_fops.release = Daemon_Library_close;
15662 - Library_proc_fops.read = Daemon_Library_read;
15663 - Library_proc_fops.write = Daemon_Library_write;
15664 - Library_proc_fops.llseek = Daemon_Library_llseek;
15665 - Library_proc_fops.ioctl = Daemon_Library_ioctl;
15666 - Novfs_Library->proc_fops = &Library_proc_fops;
15667 + novfs_lib_proc_fops.owner = THIS_MODULE;
15668 + novfs_lib_proc_fops.open = novfs_daemon_lib_open;
15669 + novfs_lib_proc_fops.release = novfs_daemon_lib_close;
15670 + novfs_lib_proc_fops.read = novfs_daemon_lib_read;
15671 + novfs_lib_proc_fops.write = novfs_daemon_lib_write;
15672 + novfs_lib_proc_fops.llseek = novfs_daemon_lib_llseek;
15673 + novfs_lib_proc_fops.ioctl = novfs_daemon_lib_ioctl;
15674 + Novfs_Library->proc_fops = &novfs_lib_proc_fops;
15675 } else {
15676 - remove_proc_entry("Control", Novfs_Procfs_dir);
15677 + remove_proc_entry("Control", novfs_procfs_dir);
15678 remove_proc_entry(MODULE_NAME, NULL);
15679 return (-ENOENT);
15680 }
15681
15682 Novfs_Version =
15683 - create_proc_read_entry("Version", 0444, Novfs_Procfs_dir,
15684 + create_proc_read_entry("Version", 0444, novfs_procfs_dir,
15685 Novfs_Get_Version, NULL);
15686 if (Novfs_Version) {
15687 Novfs_Version->owner = THIS_MODULE;
15688 Novfs_Version->size = 0;
15689 } else {
15690 - remove_proc_entry("Library", Novfs_Procfs_dir);
15691 - remove_proc_entry("Control", Novfs_Procfs_dir);
15692 + remove_proc_entry("Library", novfs_procfs_dir);
15693 + remove_proc_entry("Control", novfs_procfs_dir);
15694 remove_proc_entry(MODULE_NAME, NULL);
15695 retCode = -ENOENT;
15696 }
15697 @@ -132,17 +133,17 @@ int Init_Procfs_Interface(void)
15698 return (retCode);
15699 }
15700
15701 -void Uninit_Procfs_Interface(void)
15702 +void novfs_proc_exit(void)
15703 {
15704
15705 DbgPrint("Uninit_Procfs_Interface remove_proc_entry(Version, NULL)\n");
15706 - remove_proc_entry("Version", Novfs_Procfs_dir);
15707 + remove_proc_entry("Version", novfs_procfs_dir);
15708
15709 DbgPrint("Uninit_Procfs_Interface remove_proc_entry(Control, NULL)\n");
15710 - remove_proc_entry("Control", Novfs_Procfs_dir);
15711 + remove_proc_entry("Control", novfs_procfs_dir);
15712
15713 DbgPrint("Uninit_Procfs_Interface remove_proc_entry(Library, NULL)\n");
15714 - remove_proc_entry("Library", Novfs_Procfs_dir);
15715 + remove_proc_entry("Library", novfs_procfs_dir);
15716
15717 DbgPrint("Uninit_Procfs_Interface remove_proc_entry(%s, NULL)\n",
15718 MODULE_NAME);
15719 --- a/fs/novfs/profile.c
15720 +++ b/fs/novfs/profile.c
15721 @@ -17,11 +17,12 @@
15722 #include <linux/init.h>
15723 #include <linux/proc_fs.h>
15724 #include <linux/sched.h>
15725 +#include <asm/uaccess.h>
15726 #include <linux/vmalloc.h>
15727 #include <linux/time.h>
15728 +
15729 #include <linux/profile.h>
15730 #include <linux/notifier.h>
15731 -#include <asm/uaccess.h>
15732
15733 #include "vfs.h"
15734
15735 @@ -41,10 +42,10 @@ struct local_rtc_time {
15736 int tm_isdst;
15737 };
15738
15739 -static char *DbgPrintBuffer = NULL;
15740 -static char DbgPrintOn = 0;
15741 -static char DbgSyslogOn = 0;
15742 -static char DbgProfileOn = 0;
15743 +char *DbgPrintBuffer = NULL;
15744 +char DbgPrintOn = 0;
15745 +char DbgSyslogOn = 0;
15746 +char DbgProfileOn = 0;
15747
15748 static unsigned long DbgPrintBufferOffset = 0;
15749 static unsigned long DbgPrintBufferReadOffset = 0;
15750 @@ -64,23 +65,22 @@ static DECLARE_MUTEX(LocalPrint_lock);
15751 static ssize_t User_proc_write_DbgBuffer(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
15752 {
15753 ssize_t retval = nbytes;
15754 - unsigned char *lbuf;
15755 - unsigned char *p;
15756 + u_char *lbuf, *p;
15757 int i;
15758 + u_long cpylen;
15759
15760 lbuf = kmalloc(nbytes + 1, GFP_KERNEL);
15761 if (lbuf) {
15762 - if (copy_from_user(lbuf, buf, nbytes))
15763 - return -EFAULT;
15764 + cpylen = copy_from_user(lbuf, buf, nbytes);
15765
15766 lbuf[nbytes] = 0;
15767 DbgPrint("User_proc_write_DbgBuffer: %s\n", lbuf);
15768
15769 - for (i = 0; lbuf[i] && lbuf[i] != '\n'; i++)
15770 - ;
15771 + for (i = 0; lbuf[i] && lbuf[i] != '\n'; i++) ;
15772
15773 - if ('\n' == lbuf[i])
15774 + if ('\n' == lbuf[i]) {
15775 lbuf[i] = '\0';
15776 + }
15777
15778 if (!strcmp("on", lbuf)) {
15779 DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
15780 @@ -99,15 +99,15 @@ static ssize_t User_proc_write_DbgBuffer
15781 DbgSyslogOn = 0;
15782 }
15783 } else if (!strcmp("novfsd", lbuf)) {
15784 - Daemon_SendDebugCmd(p);
15785 + novfs_daemon_debug_cmd_send(p);
15786 } else if (!strcmp("file_update_timeout", lbuf)) {
15787 - File_update_timeout =
15788 + novfs_update_timeout =
15789 simple_strtoul(p, NULL, 0);
15790 } else if (!strcmp("cache", lbuf)) {
15791 if (!strcmp("on", p)) {
15792 - PageCache = 1;
15793 + novfs_page_cache = 1;
15794 } else if (!strcmp("off", p)) {
15795 - PageCache = 0;
15796 + novfs_page_cache = 0;
15797 }
15798 } else if (!strcmp("profile", lbuf)) {
15799 if (!strcmp("on", p)) {
15800 @@ -123,7 +123,7 @@ static ssize_t User_proc_write_DbgBuffer
15801 return (retval);
15802 }
15803
15804 -static ssize_t User_proc_read_DbgBuffer(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
15805 +static ssize_t User_proc_read_DbgBuffer(struct file *file, char *buf, size_t nbytes, loff_t * ppos)
15806 {
15807 ssize_t retval = 0;
15808 size_t count;
15809 @@ -273,7 +273,7 @@ static void doline(unsigned char *b, uns
15810 }
15811 }
15812
15813 -void mydump(int size, void *dumpptr)
15814 +void novfs_dump(int size, void *dumpptr)
15815 {
15816 unsigned char *ptr = (unsigned char *)dumpptr;
15817 unsigned char *line = NULL, buf[100], *bptr = buf;
15818 @@ -314,7 +314,7 @@ static int month_days[12] = {
15819 /*
15820 * This only works for the Gregorian calendar - i.e. after 1752 (in the UK)
15821 */
15822 -static void Novfs_GregorianDay(struct local_rtc_time *tm)
15823 +static void GregorianDay(struct local_rtc_time *tm)
15824 {
15825 int leapsToDate;
15826 int lastYear;
15827 @@ -384,14 +384,17 @@ static void private_to_tm(int tim, struc
15828 /*
15829 * Determine the day of week
15830 */
15831 - Novfs_GregorianDay(tm);
15832 + GregorianDay(tm);
15833 }
15834
15835 char *ctime_r(time_t * clock, char *buf)
15836 {
15837 struct local_rtc_time tm;
15838 - static char *DAYOFWEEK[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
15839 - static char *MONTHOFYEAR[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
15840 + static char *DAYOFWEEK[] =
15841 + { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
15842 + static char *MONTHOFYEAR[] =
15843 + { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
15844 +"Oct", "Nov", "Dec" };
15845
15846 private_to_tm(*clock, &tm);
15847
15848 @@ -401,7 +404,7 @@ char *ctime_r(time_t * clock, char *buf)
15849 return (buf);
15850 }
15851
15852 -static void profile_dump_dt(struct dentry *parent, void *pf)
15853 +static void dump(struct dentry *parent, void *pf)
15854 {
15855 void (*pfunc) (char *Fmt, ...) = pf;
15856 struct l {
15857 @@ -413,9 +416,11 @@ static void profile_dump_dt(struct dentr
15858 char *buf, *path, *sd;
15859 char inode_number[16];
15860
15861 - buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
15862 - if (!buf)
15863 + buf = (char *)kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
15864 +
15865 + if (NULL == buf) {
15866 return;
15867 + }
15868
15869 if (parent) {
15870 pfunc("starting 0x%p %.*s\n", parent, parent->d_name.len,
15871 @@ -432,20 +437,25 @@ static void profile_dump_dt(struct dentr
15872 p = l->dentry->d_subdirs.next;
15873 while (p != &l->dentry->d_subdirs) {
15874 d = list_entry(p, struct dentry,
15875 - D_CHILD);
15876 + d_u.d_child);
15877 p = p->next;
15878
15879 - if (d->d_subdirs.next != &d->d_subdirs) {
15880 - n = kmalloc(sizeof(*n), GFP_KERNEL);
15881 + if (d->d_subdirs.next !=
15882 + &d->d_subdirs) {
15883 + n = kmalloc(sizeof
15884 + (*n),
15885 + GFP_KERNEL);
15886 if (n) {
15887 - n->next = l->next;
15888 + n->next =
15889 + l->next;
15890 l->next = n;
15891 n->dentry = d;
15892 }
15893 } else {
15894 - path = Scope_dget_path(d, buf, PATH_LENGTH_BUFFER, 1);
15895 + path = novfs_scope_dget_path(d, buf, PATH_LENGTH_BUFFER, 1);
15896 if (path) {
15897 - pfunc("1-0x%p %s\n"
15898 + pfunc
15899 + ("1-0x%p %s\n"
15900 " d_name: %.*s\n"
15901 " d_parent: 0x%p\n"
15902 " d_count: %d\n"
15903 @@ -453,14 +463,21 @@ static void profile_dump_dt(struct dentr
15904 " d_subdirs: 0x%p\n"
15905 " d_inode: 0x%p\n",
15906 d, path,
15907 - d->d_name.len,
15908 - d->d_name.name,
15909 - d->d_parent,
15910 - atomic_read(&d->d_count),
15911 + d->d_name.
15912 + len,
15913 + d->d_name.
15914 + name,
15915 + d->
15916 + d_parent,
15917 + atomic_read
15918 + (&d->
15919 + d_count),
15920 d->d_flags,
15921 - d->d_subdirs.
15922 + d->
15923 + d_subdirs.
15924 next,
15925 - d->d_inode);
15926 + d->
15927 + d_inode);
15928 }
15929 }
15930 }
15931 @@ -469,11 +486,16 @@ static void profile_dump_dt(struct dentr
15932 l = start;
15933 while (l) {
15934 d = l->dentry;
15935 - path = Scope_dget_path(d, buf, PATH_LENGTH_BUFFER, 1);
15936 + path =
15937 + novfs_scope_dget_path(d, buf,
15938 + PATH_LENGTH_BUFFER,
15939 + 1);
15940 if (path) {
15941 sd = " (None)";
15942 - if (&d->d_subdirs != d->d_subdirs.next)
15943 + if (&d->d_subdirs !=
15944 + d->d_subdirs.next) {
15945 sd = "";
15946 + }
15947 inode_number[0] = '\0';
15948 if (d->d_inode) {
15949 sprintf(inode_number,
15950 @@ -506,7 +528,7 @@ static void profile_dump_dt(struct dentr
15951
15952 }
15953
15954 -static ssize_t profile_common_read(char __user *buf, size_t len, loff_t *off)
15955 +static ssize_t common_read(char *buf, size_t len, loff_t * off)
15956 {
15957 ssize_t retval = 0;
15958 size_t count;
15959 @@ -530,7 +552,8 @@ static ssize_t profile_common_read(char
15960
15961 }
15962
15963 -static ssize_t profile_inode_read(struct file * file, char __user *buf, size_t len, loff_t *off)
15964 +static ssize_t novfs_profile_read_inode(struct file * file, char *buf, size_t len,
15965 + loff_t * off)
15966 {
15967 ssize_t retval = 0;
15968 unsigned long offset = *off;
15969 @@ -542,10 +565,11 @@ static ssize_t profile_inode_read(struct
15970 DbgPrintOn = 0;
15971
15972 DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
15973 - Novfs_dump_inode(LocalPrint);
15974 + novfs_dump_inode(LocalPrint);
15975 }
15976
15977 - retval = profile_common_read(buf, len, off);
15978 +
15979 + retval = common_read(buf, len, off);
15980
15981 if (0 == retval) {
15982 DbgPrintOn = save_DbgPrintOn;
15983 @@ -558,7 +582,8 @@ static ssize_t profile_inode_read(struct
15984
15985 }
15986
15987 -static ssize_t profile_dentry_read(struct file *file, char __user *buf, size_t len, loff_t * off)
15988 +static ssize_t novfs_profile_dentry_read(struct file * file, char *buf, size_t len,
15989 + loff_t * off)
15990 {
15991 ssize_t retval = 0;
15992 unsigned long offset = *off;
15993 @@ -569,10 +594,10 @@ static ssize_t profile_dentry_read(struc
15994 save_DbgPrintOn = DbgPrintOn;
15995 DbgPrintOn = 0;
15996 DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
15997 - profile_dump_dt(Novfs_root, LocalPrint);
15998 + dump(novfs_root, LocalPrint);
15999 }
16000
16001 - retval = profile_common_read(buf, len, off);
16002 + retval = common_read(buf, len, off);
16003
16004 if (0 == retval) {
16005 DbgPrintBufferOffset = DbgPrintBufferReadOffset = 0;
16006 @@ -585,7 +610,7 @@ static ssize_t profile_dentry_read(struc
16007
16008 }
16009
16010 -uint64_t get_nanosecond_time(void)
16011 +uint64_t get_nanosecond_time()
16012 {
16013 struct timespec ts;
16014 uint64_t retVal;
16015 @@ -599,15 +624,12 @@ uint64_t get_nanosecond_time(void)
16016 return (retVal);
16017 }
16018
16019 -int init_profile(void)
16020 +void novfs_profile_init()
16021 {
16022 - int retCode = 0;
16023 -
16024 - if (Novfs_Procfs_dir) {
16025 - dbg_dir = Novfs_Procfs_dir;
16026 - } else {
16027 + if (novfs_procfs_dir)
16028 + dbg_dir = novfs_procfs_dir;
16029 + else
16030 dbg_dir = proc_mkdir(MODULE_NAME, NULL);
16031 - }
16032
16033 if (dbg_dir) {
16034 dbg_dir->owner = THIS_MODULE;
16035 @@ -620,8 +642,10 @@ int init_profile(void)
16036 dbg_file->size = DBGBUFFERSIZE;
16037 memcpy(&Dbg_proc_file_operations, dbg_file->proc_fops,
16038 sizeof(struct file_operations));
16039 - Dbg_proc_file_operations.read = User_proc_read_DbgBuffer;
16040 - Dbg_proc_file_operations.write = User_proc_write_DbgBuffer;
16041 + Dbg_proc_file_operations.read =
16042 + User_proc_read_DbgBuffer;
16043 + Dbg_proc_file_operations.write =
16044 + User_proc_write_DbgBuffer;
16045 dbg_file->proc_fops = &Dbg_proc_file_operations;
16046 } else {
16047 remove_proc_entry(MODULE_NAME, NULL);
16048 @@ -640,7 +664,8 @@ int init_profile(void)
16049 inode_file->proc_fops,
16050 sizeof(struct file_operations));
16051 inode_proc_file_ops.owner = THIS_MODULE;
16052 - inode_proc_file_ops.read = profile_inode_read;
16053 + inode_proc_file_ops.read =
16054 + novfs_profile_read_inode;
16055 inode_file->proc_fops = &inode_proc_file_ops;
16056 }
16057
16058 @@ -653,32 +678,30 @@ int init_profile(void)
16059 dentry_file->proc_fops,
16060 sizeof(struct file_operations));
16061 dentry_proc_file_ops.owner = THIS_MODULE;
16062 - dentry_proc_file_ops.read = profile_dentry_read;
16063 + dentry_proc_file_ops.read = novfs_profile_dentry_read;
16064 dentry_file->proc_fops = &dentry_proc_file_ops;
16065 }
16066 +
16067 } else {
16068 vfree(DbgPrintBuffer);
16069 DbgPrintBuffer = NULL;
16070 }
16071 }
16072 - return (retCode);
16073 }
16074
16075 -void uninit_profile(void)
16076 +void novfs_profile_exit(void)
16077 {
16078 - if (dbg_file) {
16079 - DbgPrint("Calling remove_proc_entry(Debug, NULL)\n");
16080 - remove_proc_entry("Debug", dbg_dir);
16081 - }
16082 - if (inode_file) {
16083 - DbgPrint("Calling remove_proc_entry(inode, NULL)\n");
16084 - remove_proc_entry("inode", dbg_dir);
16085 - }
16086 - if (dentry_file) {
16087 - DbgPrint("Calling remove_proc_entry(dentry, NULL)\n");
16088 - remove_proc_entry("dentry", dbg_dir);
16089 - }
16090 - if (dbg_dir && (dbg_dir != Novfs_Procfs_dir)) {
16091 + if (dbg_file)
16092 + DbgPrint("Calling remove_proc_entry(Debug, NULL)\n"),
16093 + remove_proc_entry("Debug", dbg_dir);
16094 + if (inode_file)
16095 + DbgPrint("Calling remove_proc_entry(inode, NULL)\n"),
16096 + remove_proc_entry("inode", dbg_dir);
16097 + if (dentry_file)
16098 + DbgPrint("Calling remove_proc_entry(dentry, NULL)\n"),
16099 + remove_proc_entry("dentry", dbg_dir);
16100 +
16101 + if (dbg_dir && (dbg_dir != novfs_procfs_dir)) {
16102 DbgPrint("Calling remove_proc_entry(%s, NULL)\n", MODULE_NAME);
16103 remove_proc_entry(MODULE_NAME, NULL);
16104 }
16105 --- a/fs/novfs/scope.c
16106 +++ b/fs/novfs/scope.c
16107 @@ -33,55 +33,40 @@
16108 #define CLEANUP_INTERVAL 10
16109 #define MAX_USERNAME_LENGTH 32
16110
16111 -struct scope_list {
16112 - struct list_head entry;
16113 - struct schandle ScopeId;
16114 - struct schandle SessionId;
16115 - pid_t ScopePid;
16116 - struct task_struct *ScopeTask;
16117 - unsigned int ScopeHash;
16118 - uid_t ScopeUid;
16119 - u64 ScopeUSize;
16120 - u64 ScopeUFree;
16121 - u64 ScopeUTEnties;
16122 - u64 ScopeUAEnties;
16123 - int ScopeUserNameLength;
16124 - unsigned char ScopeUserName[MAX_USERNAME_LENGTH];
16125 -};
16126
16127 static struct list_head Scope_List;
16128 static struct semaphore Scope_Lock;
16129 static struct semaphore Scope_Thread_Delay;
16130 -static int Scope_Thread_Terminate;
16131 +static int Scope_Thread_Terminate = 0;
16132 static struct timer_list Scope_Timer;
16133 static unsigned int Scope_Hash_Val = 1;
16134
16135 -static struct scope_list *Scope_Search4Scope(struct schandle *Id, bool Session,
16136 - bool Locked)
16137 +static struct novfs_scope_list *Scope_Search4Scope(struct novfs_schandle Id,
16138 + int Session, int Locked)
16139 {
16140 - struct scope_list *scope;
16141 - struct scope_list *rscope = NULL;
16142 - struct schandle *cur_scope;
16143 + struct novfs_scope_list *scope, *rscope = NULL;
16144 + struct novfs_schandle cur_scope;
16145 struct list_head *sl;
16146 int offset;
16147
16148 - DbgPrint("Scope_Search4Scope: 0x%p:%p 0x%x 0x%x\n",
16149 - Id->hTypeId, Id->hId, Session, Locked);
16150 + DbgPrint("Scope_Search4Scope: 0x%p:%p 0x%x 0x%x\n", Id.hTypeId, Id.hId,
16151 + Session, Locked);
16152
16153 if (Session)
16154 - offset = offsetof(struct scope_list, SessionId);
16155 + offset = offsetof(struct novfs_scope_list, SessionId);
16156 else
16157 - offset = offsetof(struct scope_list, ScopeId);
16158 + offset = offsetof(struct novfs_scope_list, ScopeId);
16159
16160 - if (!Locked)
16161 + if (!Locked) {
16162 down(&Scope_Lock);
16163 + }
16164
16165 sl = Scope_List.next;
16166 DbgPrint("Scope_Search4Scope: 0x%p\n", sl);
16167 while (sl != &Scope_List) {
16168 - scope = list_entry(sl, struct scope_list, entry);
16169 + scope = list_entry(sl, struct novfs_scope_list, ScopeList);
16170
16171 - cur_scope = (session_t *) ((char *)scope + offset);
16172 + cur_scope = *(struct novfs_schandle *) ((char *)scope + offset);
16173 if (SC_EQUAL(Id, cur_scope)) {
16174 rscope = scope;
16175 break;
16176 @@ -90,19 +75,19 @@ static struct scope_list *Scope_Search4S
16177 sl = sl->next;
16178 }
16179
16180 - if (!Locked)
16181 + if (!Locked) {
16182 up(&Scope_Lock);
16183 + }
16184
16185 DbgPrint("Scope_Search4Scope: return 0x%p\n", rscope);
16186 - return rscope;
16187 + return (rscope);
16188 }
16189
16190 -static struct scope_list *Scope_Find_Scope(bool Create)
16191 +static struct novfs_scope_list *Scope_Find_Scope(int Create)
16192 {
16193 - struct scope_list *scope = NULL;
16194 - struct scope_list *pscope = NULL;
16195 + struct novfs_scope_list *scope = NULL, *pscope = NULL;
16196 struct task_struct *task;
16197 - struct schandle scopeId;
16198 + struct novfs_schandle scopeId;
16199 int addscope = 0;
16200
16201 task = current;
16202 @@ -110,84 +95,94 @@ static struct scope_list *Scope_Find_Sco
16203 DbgPrint("Scope_Find_Scope: %d %d %d %d\n", task->uid, task->euid,
16204 task->suid, task->fsuid);
16205
16206 - /* scopeId = task->euid; */
16207 + //scopeId = task->euid;
16208 UID_TO_SCHANDLE(scopeId, task->euid);
16209
16210 - scope = Scope_Search4Scope(&scopeId, 0, 0);
16211 - if (scope || (!Create))
16212 - return scope;
16213 + scope = Scope_Search4Scope(scopeId, 0, 0);
16214
16215 - scope = kmalloc(sizeof(*pscope), GFP_KERNEL);
16216 - if (!scope)
16217 - return NULL;
16218 - scope->ScopeId = scopeId;
16219 - SC_INITIALIZE(scope->SessionId);
16220 - scope->ScopePid = task->pid;
16221 - scope->ScopeTask = task;
16222 - scope->ScopeHash = 0;
16223 - scope->ScopeUid = task->euid;
16224 - scope->ScopeUserName[0] = '\0';
16225 -
16226 - if (!Daemon_CreateSessionId(&scope->SessionId)) {
16227 - DbgPrint("Scope_Find_Scope2: %d %d %d %d\n", task->uid,
16228 - task->euid, task->suid, task->fsuid);
16229 - memset(scope->ScopeUserName, 0, sizeof(scope->ScopeUserName));
16230 - scope->ScopeUserNameLength = 0;
16231 - Daemon_getpwuid(task->euid, sizeof(scope->ScopeUserName),
16232 - scope->ScopeUserName);
16233 - scope->ScopeUserNameLength = strlen(scope->ScopeUserName);
16234 - addscope = 1;
16235 - }
16236 -
16237 - scope->ScopeHash = Scope_Hash_Val++;
16238 - DbgPrint("Scope_Find_Scope: Adding 0x%p\n"
16239 - " ScopeId: 0x%p:%p\n"
16240 - " SessionId: 0x%p:%p\n"
16241 - " ScopePid: %d\n"
16242 - " ScopeTask: 0x%p\n"
16243 - " ScopeHash: %u\n"
16244 - " ScopeUid: %u\n"
16245 - " ScopeUserNameLength: %u\n"
16246 - " ScopeUserName: %s\n",
16247 - scope,
16248 - scope->ScopeId.hTypeId, scope->ScopeId.hId,
16249 - scope->SessionId.hTypeId, scope->SessionId.hId,
16250 - scope->ScopePid,
16251 - scope->ScopeTask,
16252 - scope->ScopeHash,
16253 - scope->ScopeUid,
16254 - scope->ScopeUserNameLength,
16255 - scope->ScopeUserName);
16256 + if (!scope && Create) {
16257 + scope = kmalloc(sizeof(*pscope), GFP_KERNEL);
16258 + if (scope) {
16259 + scope->ScopeId = scopeId;
16260 + SC_INITIALIZE(scope->SessionId);
16261 + scope->ScopePid = task->pid;
16262 + scope->ScopeTask = task;
16263 + scope->ScopeHash = 0;
16264 + scope->ScopeUid = task->euid;
16265 + scope->ScopeUserName[0] = '\0';
16266 +
16267 + if (!novfs_daemon_create_sessionId(&scope->SessionId)) {
16268 + DbgPrint("Scope_Find_Scope2: %d %d %d %d\n",
16269 + task->uid, task->euid, task->suid,
16270 + task->fsuid);
16271 + memset(scope->ScopeUserName, 0,
16272 + sizeof(scope->ScopeUserName));
16273 + scope->ScopeUserNameLength = 0;
16274 + novfs_daemon_getpwuid(task->euid,
16275 + sizeof(scope->ScopeUserName),
16276 + scope->ScopeUserName);
16277 + scope->ScopeUserNameLength =
16278 + strlen(scope->ScopeUserName);
16279 + addscope = 1;
16280 + }
16281
16282 - if (SC_PRESENT(scope->SessionId)) {
16283 - down(&Scope_Lock);
16284 - pscope = Scope_Search4Scope(&scopeId, 0, 1);
16285 - if (!pscope)
16286 - list_add(&scope->entry, &Scope_List);
16287 - up(&Scope_Lock);
16288 + scope->ScopeHash = Scope_Hash_Val++;
16289 + DbgPrint("Scope_Find_Scope: Adding 0x%p\n"
16290 + " ScopeId: 0x%p:%p\n"
16291 + " SessionId: 0x%p:%p\n"
16292 + " ScopePid: %d\n"
16293 + " ScopeTask: 0x%p\n"
16294 + " ScopeHash: %u\n"
16295 + " ScopeUid: %u\n"
16296 + " ScopeUserNameLength: %u\n"
16297 + " ScopeUserName: %s\n",
16298 + scope,
16299 + scope->ScopeId.hTypeId, scope->ScopeId.hId,
16300 + scope->SessionId.hTypeId, scope->SessionId.hId,
16301 + scope->ScopePid,
16302 + scope->ScopeTask,
16303 + scope->ScopeHash,
16304 + scope->ScopeUid,
16305 + scope->ScopeUserNameLength,
16306 + scope->ScopeUserName);
16307 +
16308 + if (SC_PRESENT(scope->SessionId)) {
16309 + down(&Scope_Lock);
16310 + pscope =
16311 + Scope_Search4Scope(scopeId, 0, 1);
16312 +
16313 + if (!pscope) {
16314 + list_add(&scope->ScopeList,
16315 + &Scope_List);
16316 + }
16317 + up(&Scope_Lock);
16318
16319 - if (pscope) {
16320 - printk(KERN_ERR "Scope_Find_Scope scope not added "
16321 - "because it was already there...\n");
16322 - Daemon_DestroySessionId(&scope->SessionId);
16323 - kfree(scope);
16324 - scope = pscope;
16325 - addscope = 0;
16326 + if (pscope) {
16327 + printk
16328 + ("<6>Scope_Find_Scope scope not added because it was already there...\n");
16329 + novfs_daemon_destroy_sessionId(scope->
16330 + SessionId);
16331 + kfree(scope);
16332 + scope = pscope;
16333 + addscope = 0;
16334 + }
16335 + } else {
16336 + kfree(scope);
16337 + scope = NULL;
16338 + }
16339 }
16340 - } else {
16341 - kfree(scope);
16342 - scope = NULL;
16343 - }
16344
16345 - if (addscope)
16346 - Novfs_Add_to_Root(scope->ScopeUserName);
16347 + if (addscope) {
16348 + novfs_add_to_root(scope->ScopeUserName);
16349 + }
16350 + }
16351
16352 - return scope;
16353 + return (scope);
16354 }
16355
16356 -static int Scope_Validate_Scope(struct scope_list *Scope)
16357 +static int Scope_Validate_Scope(struct novfs_scope_list *Scope)
16358 {
16359 - struct scope_list *s;
16360 + struct novfs_scope_list *s;
16361 struct list_head *sl;
16362 int retVal = 0;
16363
16364 @@ -197,7 +192,7 @@ static int Scope_Validate_Scope(struct s
16365
16366 sl = Scope_List.next;
16367 while (sl != &Scope_List) {
16368 - s = list_entry(sl, struct scope_list, entry);
16369 + s = list_entry(sl, struct novfs_scope_list, ScopeList);
16370
16371 if (s == Scope) {
16372 retVal = 1;
16373 @@ -209,28 +204,24 @@ static int Scope_Validate_Scope(struct s
16374
16375 up(&Scope_Lock);
16376
16377 - return retVal;
16378 + return (retVal);
16379 }
16380
16381 -/* FIXME void stuff */
16382 -uid_t Scope_Get_Uid(void *foo)
16383 +uid_t novfs_scope_get_uid(struct novfs_scope_list *scope)
16384 {
16385 - struct scope_list *scope = foo;
16386 uid_t uid = 0;
16387 -
16388 if (!scope)
16389 scope = Scope_Find_Scope(1);
16390
16391 if (scope && Scope_Validate_Scope(scope))
16392 uid = scope->ScopeUid;
16393 -
16394 return uid;
16395 }
16396
16397 -char *Scope_Get_UserName(void)
16398 +char *novfs_scope_get_username(void)
16399 {
16400 char *name = NULL;
16401 - struct scope_list *Scope;
16402 + struct novfs_scope_list *Scope;
16403
16404 Scope = Scope_Find_Scope(1);
16405
16406 @@ -240,12 +231,10 @@ char *Scope_Get_UserName(void)
16407 return name;
16408 }
16409
16410 -/* FIXME the void * needs to get fixed... */
16411 -session_t Scope_Get_SessionId(void *foo)
16412 +struct novfs_schandle novfs_scope_get_sessionId(struct novfs_scope_list
16413 + *Scope)
16414 {
16415 - session_t sessionId;
16416 - struct scope_list *Scope = foo;
16417 -
16418 + struct novfs_schandle sessionId;
16419 DbgPrint("Scope_Get_SessionId: 0x%p\n", Scope);
16420 SC_INITIALIZE(sessionId);
16421 if (!Scope)
16422 @@ -253,43 +242,43 @@ session_t Scope_Get_SessionId(void *foo)
16423
16424 if (Scope && Scope_Validate_Scope(Scope))
16425 sessionId = Scope->SessionId;
16426 -
16427 DbgPrint("Scope_Get_SessionId: return 0x%p:%p\n", sessionId.hTypeId,
16428 sessionId.hId);
16429 - return sessionId;
16430 + return (sessionId);
16431 }
16432
16433 -struct scope_list *Scope_Get_ScopefromName(struct qstr *name)
16434 +struct novfs_scope_list *novfs_get_scope_from_name(struct qstr * Name)
16435 {
16436 - struct scope_list *scope;
16437 - struct scope_list *rscope = NULL;
16438 + struct novfs_scope_list *scope, *rscope = NULL;
16439 struct list_head *sl;
16440
16441 - DbgPrint("Scope_Get_ScopefromName: %.*s\n", name->len, name->name);
16442 + DbgPrint("Scope_Get_ScopefromName: %.*s\n", Name->len, Name->name);
16443
16444 down(&Scope_Lock);
16445
16446 sl = Scope_List.next;
16447 while (sl != &Scope_List) {
16448 - scope = list_entry(sl, struct scope_list, entry);
16449 + scope = list_entry(sl, struct novfs_scope_list, ScopeList);
16450
16451 - if ((name->len == scope->ScopeUserNameLength) &&
16452 - (strncmp(scope->ScopeUserName, name->name, name->len) == 0)) {
16453 + if ((Name->len == scope->ScopeUserNameLength) &&
16454 + (0 == strncmp(scope->ScopeUserName, Name->name, Name->len)))
16455 + {
16456 rscope = scope;
16457 break;
16458 }
16459 +
16460 sl = sl->next;
16461 }
16462
16463 up(&Scope_Lock);
16464
16465 - return rscope;
16466 + return (rscope);
16467 }
16468
16469 -int Scope_Set_UserSpace(u64 *TotalSize, u64 *Free,
16470 - u64 *TotalEnties, u64 *FreeEnties)
16471 +int novfs_scope_set_userspace(uint64_t * TotalSize, uint64_t * Free,
16472 + uint64_t * TotalEnties, uint64_t * FreeEnties)
16473 {
16474 - struct scope_list *scope;
16475 + struct novfs_scope_list *scope;
16476 int retVal = 0;
16477
16478 scope = Scope_Find_Scope(1);
16479 @@ -305,24 +294,24 @@ int Scope_Set_UserSpace(u64 *TotalSize,
16480 scope->ScopeUAEnties = *FreeEnties;
16481 }
16482
16483 - return retVal;
16484 + return (retVal);
16485 }
16486
16487 -int Scope_Get_UserSpace(u64 *TotalSize, u64 *Free,
16488 - u64 *TotalEnties, u64 *FreeEnties)
16489 +int novfs_scope_get_userspace(uint64_t * TotalSize, uint64_t * Free,
16490 + uint64_t * TotalEnties, uint64_t * FreeEnties)
16491 {
16492 - struct scope_list *scope;
16493 + struct novfs_scope_list *scope;
16494 int retVal = 0;
16495
16496 - u64 td, fd, te, fe;
16497 + uint64_t td, fd, te, fe;
16498
16499 scope = Scope_Find_Scope(1);
16500
16501 td = fd = te = fe = 0;
16502 if (scope) {
16503
16504 - retVal = Daemon_Get_UserSpace(&scope->SessionId,
16505 - &td, &fd, &te, &fe);
16506 + retVal =
16507 + novfs_daemon_get_userspace(scope->SessionId, &td, &fd, &te, &fe);
16508
16509 scope->ScopeUSize = td;
16510 scope->ScopeUFree = fd;
16511 @@ -339,18 +328,18 @@ int Scope_Get_UserSpace(u64 *TotalSize,
16512 if (FreeEnties)
16513 *FreeEnties = fe;
16514
16515 - return retVal;
16516 + return (retVal);
16517 }
16518
16519 -struct scope_list *Scope_Get_ScopefromPath(struct dentry *dentry)
16520 +struct novfs_scope_list *novfs_get_scope(struct dentry * Dentry)
16521 {
16522 - struct scope_list *scope = NULL;
16523 + struct novfs_scope_list *scope = NULL;
16524 char *buf, *path, *cp;
16525 struct qstr name;
16526
16527 - buf = kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
16528 + buf = (char *)kmalloc(PATH_LENGTH_BUFFER, GFP_KERNEL);
16529 if (buf) {
16530 - path = Scope_dget_path(dentry, buf, PATH_LENGTH_BUFFER, 0);
16531 + path = novfs_scope_dget_path(Dentry, buf, PATH_LENGTH_BUFFER, 0);
16532 if (path) {
16533 DbgPrint("Scope_Get_ScopefromPath: %s\n", path);
16534
16535 @@ -366,29 +355,30 @@ struct scope_list *Scope_Get_ScopefromPa
16536 name.hash = 0;
16537 name.len = (int)(cp - path);
16538 name.name = path;
16539 - scope = Scope_Get_ScopefromName(&name);
16540 + scope = novfs_get_scope_from_name(&name);
16541 }
16542 }
16543 kfree(buf);
16544 }
16545
16546 - return scope;
16547 + return (scope);
16548 }
16549
16550 -static char *add_to_list(char *name, char *list, char *endoflist)
16551 +static char *add_to_list(char *Name, char *List, char *EndOfList)
16552 {
16553 - while (*name && (list < endoflist))
16554 - *list++ = *name++;
16555 -
16556 - if (list < endoflist)
16557 - *list++ = '\0';
16558 + while (*Name && (List < EndOfList)) {
16559 + *List++ = *Name++;
16560 + }
16561
16562 - return list;
16563 + if (List < EndOfList) {
16564 + *List++ = '\0';
16565 + }
16566 + return (List);
16567 }
16568
16569 -char *Scope_Get_ScopeUsers(void)
16570 +char *novfs_get_scopeusers(void)
16571 {
16572 - struct scope_list *scope;
16573 + struct novfs_scope_list *scope;
16574 struct list_head *sl;
16575 int asize = 8 * MAX_USERNAME_LENGTH;
16576 char *list, *cp, *ep;
16577 @@ -413,7 +403,7 @@ char *Scope_Get_ScopeUsers(void)
16578
16579 sl = Scope_List.next;
16580 while ((sl != &Scope_List) && (cp < ep)) {
16581 - scope = list_entry(sl, struct scope_list, entry);
16582 + scope = list_entry(sl, struct novfs_scope_list, ScopeList);
16583
16584 DbgPrint("Scope_Get_ScopeUsers found 0x%p %s\n",
16585 scope, scope->ScopeUserName);
16586 @@ -429,6 +419,7 @@ char *Scope_Get_ScopeUsers(void)
16587 *cp++ = '\0';
16588 asize = 0;
16589 } else { /* Allocation was to small, up size */
16590 +
16591 asize *= 4;
16592 kfree(list);
16593 list = NULL;
16594 @@ -437,12 +428,12 @@ char *Scope_Get_ScopeUsers(void)
16595
16596 break;
16597 }
16598 - } while (!list); /* list was to small try again */
16599 + } while (!list); /* List was to small try again */
16600
16601 - return list;
16602 + return (list);
16603 }
16604
16605 -void *Scope_Lookup(void)
16606 +void *novfs_scope_lookup(void)
16607 {
16608 return Scope_Find_Scope(1);
16609 }
16610 @@ -454,8 +445,7 @@ static void Scope_Timer_Function(unsigne
16611
16612 static int Scope_Cleanup_Thread(void *Args)
16613 {
16614 - struct scope_list *scope;
16615 - struct scope_list *rscope;
16616 + struct novfs_scope_list *scope, *rscope;
16617 struct list_head *sl, cleanup;
16618 struct task_struct *task;
16619
16620 @@ -468,8 +458,9 @@ static int Scope_Cleanup_Thread(void *Ar
16621
16622 while (0 == Scope_Thread_Terminate) {
16623 DbgPrint("Scope_Cleanup_Thread: looping\n");
16624 - if (Scope_Thread_Terminate)
16625 + if (Scope_Thread_Terminate) {
16626 break;
16627 + }
16628
16629 /*
16630 * Check scope list for any terminated processes
16631 @@ -480,7 +471,7 @@ static int Scope_Cleanup_Thread(void *Ar
16632 INIT_LIST_HEAD(&cleanup);
16633
16634 while (sl != &Scope_List) {
16635 - scope = list_entry(sl, struct scope_list, entry);
16636 + scope = list_entry(sl, struct novfs_scope_list, ScopeList);
16637 sl = sl->next;
16638
16639 rscope = NULL;
16640 @@ -495,7 +486,7 @@ static int Scope_Cleanup_Thread(void *Ar
16641 rcu_read_unlock();
16642
16643 if (!rscope) {
16644 - list_move(&scope->entry, &cleanup);
16645 + list_move(&scope->ScopeList, &cleanup);
16646 DbgPrint("Scope_Cleanup_Thread: Scope=0x%p\n",
16647 rscope);
16648 }
16649 @@ -505,7 +496,7 @@ static int Scope_Cleanup_Thread(void *Ar
16650
16651 sl = cleanup.next;
16652 while (sl != &cleanup) {
16653 - scope = list_entry(sl, struct scope_list, entry);
16654 + scope = list_entry(sl, struct novfs_scope_list, ScopeList);
16655 sl = sl->next;
16656
16657 DbgPrint("Scope_Cleanup_Thread: Removing 0x%p\n"
16658 @@ -523,9 +514,9 @@ static int Scope_Cleanup_Thread(void *Ar
16659 scope->ScopeTask,
16660 scope->ScopeHash,
16661 scope->ScopeUid, scope->ScopeUserName);
16662 - if (!Scope_Search4Scope(&scope->SessionId, 1, 0)) {
16663 - Novfs_Remove_from_Root(scope->ScopeUserName);
16664 - Daemon_DestroySessionId(&scope->SessionId);
16665 + if (!Scope_Search4Scope(scope->SessionId, 1, 0)) {
16666 + novfs_remove_from_root(scope->ScopeUserName);
16667 + novfs_daemon_destroy_sessionId(scope->SessionId);
16668 }
16669 kfree(scope);
16670 }
16671 @@ -536,21 +527,21 @@ static int Scope_Cleanup_Thread(void *Ar
16672 add_timer(&Scope_Timer);
16673 DbgPrint("Scope_Cleanup_Thread: sleeping\n");
16674
16675 - if (down_interruptible(&Scope_Thread_Delay))
16676 + if (down_interruptible(&Scope_Thread_Delay)) {
16677 break;
16678 -
16679 + }
16680 del_timer(&Scope_Timer);
16681 }
16682 Scope_Thread_Terminate = 0;
16683
16684 printk(KERN_INFO "Scope_Cleanup_Thread: Exit\n");
16685 DbgPrint("Scope_Cleanup_Thread: Exit\n");
16686 - return 0;
16687 + return (0);
16688 }
16689
16690 -void Scope_Cleanup(void)
16691 +void novfs_scope_cleanup(void)
16692 {
16693 - struct scope_list *scope;
16694 + struct novfs_scope_list *scope;
16695 struct list_head *sl;
16696
16697 DbgPrint("Scope_Cleanup:\n");
16698 @@ -563,10 +554,10 @@ void Scope_Cleanup(void)
16699 sl = Scope_List.next;
16700
16701 while (sl != &Scope_List) {
16702 - scope = list_entry(sl, struct scope_list, entry);
16703 + scope = list_entry(sl, struct novfs_scope_list, ScopeList);
16704 sl = sl->next;
16705
16706 - list_del(&scope->entry);
16707 + list_del(&scope->ScopeList);
16708
16709 DbgPrint("Scope_Cleanup: Removing 0x%p\n"
16710 " ScopeId: 0x%p:%p\n"
16711 @@ -583,9 +574,9 @@ void Scope_Cleanup(void)
16712 scope->ScopeTask,
16713 scope->ScopeHash,
16714 scope->ScopeUid, scope->ScopeUserName);
16715 - if (!Scope_Search4Scope(&scope->SessionId, 1, 1)) {
16716 - Novfs_Remove_from_Root(scope->ScopeUserName);
16717 - Daemon_DestroySessionId(&scope->SessionId);
16718 + if (!Scope_Search4Scope(scope->SessionId, 1, 1)) {
16719 + novfs_remove_from_root(scope->ScopeUserName);
16720 + novfs_daemon_destroy_sessionId(scope->SessionId);
16721 }
16722 kfree(scope);
16723 }
16724 @@ -595,19 +586,13 @@ void Scope_Cleanup(void)
16725 }
16726
16727 /*
16728 - * Arguments: struct dentry *dentry - starting entry
16729 - * char *Buf - pointer to memory buffer
16730 - * unsigned int Buflen - size of memory buffer
16731 - *
16732 - * Returns: pointer to path.
16733 - *
16734 - * Abstract: Walks the dentry chain building a path.
16735 + * Walks the dentry chain building a path.
16736 */
16737 -char *Scope_dget_path(struct dentry *dentry, char *Buf, unsigned int Buflen,
16738 +char *novfs_scope_dget_path(struct dentry *Dentry, char *Buf, unsigned int Buflen,
16739 int Flags)
16740 {
16741 char *retval = &Buf[Buflen];
16742 - struct dentry *p = dentry;
16743 + struct dentry *p = Dentry;
16744 int len;
16745
16746 *(--retval) = '\0';
16747 @@ -627,8 +612,9 @@ char *Scope_dget_path(struct dentry *den
16748 }
16749 } while (!IS_ROOT(p));
16750
16751 - if (IS_ROOT(dentry))
16752 + if (IS_ROOT(Dentry)) {
16753 retval++;
16754 + }
16755
16756 if (Flags) {
16757 len = strlen(p->d_sb->s_type->name);
16758 @@ -641,19 +627,18 @@ char *Scope_dget_path(struct dentry *den
16759 }
16760 }
16761
16762 - return retval;
16763 + return (retval);
16764 }
16765
16766 -void Scope_Init(void)
16767 +void novfs_scope_init(void)
16768 {
16769 INIT_LIST_HEAD(&Scope_List);
16770 init_MUTEX(&Scope_Lock);
16771 init_MUTEX_LOCKED(&Scope_Thread_Delay);
16772 -
16773 kthread_run(Scope_Cleanup_Thread, NULL, "novfs_ST");
16774 }
16775
16776 -void Scope_Uninit(void)
16777 +void novfs_scope_exit(void)
16778 {
16779 unsigned long expires = jiffies + HZ * SHUTDOWN_INTERVAL;
16780
16781 @@ -666,7 +651,6 @@ void Scope_Uninit(void)
16782 mb();
16783 while (Scope_Thread_Terminate && (jiffies < expires))
16784 yield();
16785 -
16786 /* down(&Scope_Thread_Delay); */
16787 printk(KERN_INFO "Scope_Uninit: Exit\n");
16788
16789 --- a/fs/novfs/vfs.h
16790 +++ b/fs/novfs/vfs.h
16791 @@ -20,37 +20,31 @@
16792
16793 #include <linux/version.h>
16794 #include <linux/namei.h>
16795 -#include <linux/string.h>
16796
16797 #include "nwcapi.h"
16798
16799 -typedef void *HANDLE;
16800
16801 -struct schandle {
16802 - void *hTypeId;
16803 - void *hId;
16804 -};
16805 -
16806 -static inline void copy_schandle(struct schandle *dest, struct schandle *source)
16807 -{
16808 - memcpy(dest, source, sizeof(struct schandle));
16809 -}
16810 -#define copy_session_id copy_schandle
16811 +#ifndef XTIER_SCHANDLE
16812 +struct novfs_schandle {
16813 + void * hTypeId;
16814 + void * hId;
16815
16816 -typedef struct schandle session_t;
16817 +};
16818
16819 #include "commands.h"
16820
16821 #define SC_PRESENT(X) ((X.hTypeId != NULL) || (X.hId != NULL)) ? 1 : 0
16822 -#define SC_EQUAL(X, Y) ((X->hTypeId == Y->hTypeId) && (X->hId == Y->hId)) ? 1 : 0
16823 +#define SC_EQUAL(X, Y) ((X.hTypeId == Y.hTypeId) && (X.hId == Y.hId)) ? 1 : 0
16824 #define SC_INITIALIZE(X) {X.hTypeId = X.hId = NULL;}
16825
16826 #define UID_TO_SCHANDLE(hSC, uid) \
16827 { \
16828 hSC.hTypeId = NULL; \
16829 - hSC.hId = (HANDLE)(unsigned long)(uid); \
16830 + hSC.hId = (void *)(unsigned long)(uid); \
16831 }
16832
16833 +#define XTIER_SCHANDLE
16834 +#endif
16835
16836
16837 /*===[ Manifest constants ]===============================================*/
16838 @@ -71,16 +65,6 @@ typedef struct schandle session_t;
16839 #define IOC_SESSION 0x4a540003
16840 #define IOC_DEBUGPRINT 0x4a540004
16841
16842 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
16843 -#define D_CHILD d_u.d_child
16844 -#define AS_TREE_LOCK(l) read_lock_irq(l)
16845 -#define AS_TREE_UNLOCK(l) read_unlock_irq(l)
16846 -#else
16847 -#define D_CHILD d_child
16848 -#define AS_TREE_LOCK(l) spin_lock_irq(l)
16849 -#define AS_TREE_UNLOCK(l) spin_unlock_irq(l)
16850 -#endif
16851 -
16852 /*
16853 * NetWare file attributes
16854 */
16855 @@ -96,7 +80,7 @@ typedef struct schandle session_t;
16856 #define NW_ATTRIBUTE_SHAREABLE 0x80
16857
16858 /*
16859 - * Define READ/WRITE flag for struct data_list
16860 + * Define READ/WRITE flag for DATA_LIST
16861 */
16862 #define DLREAD 0
16863 #define DLWRITE 1
16864 @@ -156,7 +140,8 @@ typedef struct schandle session_t;
16865 DEFINE_TO_STR(NOVFS_VFS_RELEASE) \
16866 "\0"
16867
16868 -struct entry_info {
16869 +/*===[ Type definitions ]=================================================*/
16870 +struct novfs_entry_info {
16871 int type;
16872 umode_t mode;
16873 uid_t uid;
16874 @@ -174,17 +159,17 @@ struct novfs_string {
16875 unsigned char *data;
16876 };
16877
16878 -struct login {
16879 +struct novfs_login {
16880 struct novfs_string Server;
16881 struct novfs_string UserName;
16882 struct novfs_string Password;
16883 };
16884
16885 -struct logout {
16886 +struct novfs_logout {
16887 struct novfs_string Server;
16888 };
16889
16890 -struct dir_cache {
16891 +struct novfs_dir_cache {
16892 struct list_head list;
16893 int flags;
16894 u64 jiffies;
16895 @@ -199,7 +184,7 @@ struct dir_cache {
16896 char name[1];
16897 };
16898
16899 -struct data_list {
16900 +struct novfs_data_list {
16901 void *page;
16902 void *offset;
16903 int len;
16904 @@ -209,227 +194,256 @@ struct data_list {
16905
16906 extern char *ctime_r(time_t * clock, char *buf);
16907
16908 -static inline u32 HandletoUint32(HANDLE h)
16909 /*
16910 - *
16911 - * Arguments: HANDLE h - handle value
16912 - *
16913 - * Returns: u32 - u32 value
16914 - *
16915 - * Abstract: Converts a HANDLE to a u32 type.
16916 - *
16917 - * Notes:
16918 - *
16919 - * Environment:
16920 - *
16921 - *========================================================================*/
16922 + * Converts a HANDLE to a u32 type.
16923 + */
16924 +static inline u32 HandletoUint32(void * h)
16925 {
16926 return (u32) ((unsigned long) h);
16927 }
16928
16929 -/*++======================================================================*/
16930 -static inline HANDLE Uint32toHandle(u32 ui32)
16931 /*
16932 - *
16933 - * Arguments: u32 ui32
16934 - *
16935 - * Returns: HANDLE - Handle type.
16936 - *
16937 - * Abstract: Converts a u32 to a HANDLE type.
16938 - *
16939 - * Notes:
16940 - *
16941 - * Environment:
16942 - *
16943 - *========================================================================*/
16944 + * Converts a u32 to a HANDLE type.
16945 + */
16946 +static inline void *Uint32toHandle(u32 ui32)
16947 {
16948 - return ((HANDLE) (unsigned long) ui32);
16949 + return ((void *) (unsigned long) ui32);
16950 }
16951
16952 /* Global variables */
16953
16954 -extern int Novfs_Version_Major;
16955 -extern int Novfs_Version_Minor;
16956 -extern int Novfs_Version_Sub;
16957 -extern int Novfs_Version_Release;
16958 -extern struct dentry *Novfs_root;
16959 -extern struct proc_dir_entry *Novfs_Procfs_dir;
16960 -extern unsigned long File_update_timeout;
16961 -extern int PageCache;
16962 -extern char *Novfs_CurrentMount;
16963 -extern struct dentry_operations Novfs_dentry_operations;
16964 -extern int MaxIoSize;
16965 +extern struct dentry *novfs_root;
16966 +extern struct proc_dir_entry *novfs_procfs_dir;
16967 +extern unsigned long novfs_update_timeout;
16968 +extern int novfs_page_cache;
16969 +extern char *novfs_current_mnt;
16970 +extern int novfs_max_iosize;
16971
16972
16973 /* Global functions */
16974 -extern int Novfs_Remove_from_Root(char *);
16975 -extern void Novfs_dump_inode(void *pf);
16976 +extern int novfs_remove_from_root(char *);
16977 +extern void novfs_dump_inode(void *pf);
16978
16979 -extern void mydump(int size, void *dumpptr);
16980 +extern void novfs_dump(int size, void *dumpptr);
16981
16982 extern int Queue_Daemon_Command(void *request, unsigned long reqlen, void *data,
16983 int dlen, void **reply, unsigned long * replen,
16984 int interruptible);
16985 +extern int novfs_do_login(struct ncl_string * Server, struct ncl_string* Username, struct ncl_string * Password, void **lgnId, struct novfs_schandle *Session);
16986
16987 -extern int Init_Procfs_Interface(void);
16988 -extern void Uninit_Procfs_Interface(void);
16989 +extern int novfs_proc_init(void);
16990 +extern void novfs_proc_exit(void);
16991
16992 /*
16993 * daemon.c functions
16994 */
16995 -extern void Init_Daemon_Queue(void);
16996 -extern void Uninit_Daemon_Queue(void);
16997 -extern int do_login(NclString * Server, NclString * Username, NclString * Password, HANDLE * lgnId, struct schandle *Session);
16998 -extern int do_logout(struct qstr *Server, struct schandle *Session);
16999 -extern int Daemon_SetMountPoint(char *Path);
17000 -extern int Daemon_CreateSessionId(struct schandle *SessionId);
17001 -extern int Daemon_DestroySessionId(struct schandle *SessionId);
17002 -extern int Daemon_getpwuid(uid_t uid, int unamelen, char *uname);
17003 -extern int Daemon_Get_UserSpace(struct schandle *session_id, u64 *TotalSize,
17004 - u64 *TotalFree, u64 *TotalDirectoryEnties,
17005 - u64 *FreeDirectoryEnties);
17006 -extern int Daemon_SendDebugCmd(char *Command);
17007 -extern ssize_t Daemon_Receive_Reply(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos);
17008 -extern ssize_t Daemon_Send_Command(struct file *file, char __user *buf, size_t len, loff_t *off);
17009 -extern int Daemon_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
17010 -extern int Daemon_Library_close(struct inode *inode, struct file *file);
17011 -extern int Daemon_Library_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
17012 -extern int Daemon_Library_open(struct inode *inode, struct file *file);
17013 -extern ssize_t Daemon_Library_write(struct file *file, const char __user *buf, size_t len, loff_t * off);
17014 -extern ssize_t Daemon_Library_read(struct file *file, char __user *buf, size_t len, loff_t * off);
17015 -extern loff_t Daemon_Library_llseek(struct file *file, loff_t offset, int origin);
17016 -extern int Daemon_Open_Control(struct inode *Inode, struct file *File);
17017 -extern int Daemon_Close_Control(struct inode *Inode, struct file *File);
17018 -extern int Daemon_getversion(char *Buf, int Length);
17019 +extern void novfs_daemon_queue_init(void);
17020 +extern void novfs_daemon_queue_exit(void);
17021 +extern int novfs_daemon_logout(struct qstr *Server, struct novfs_schandle *Session);
17022 +extern int novfs_daemon_set_mnt_point(char *Path);
17023 +extern int novfs_daemon_create_sessionId(struct novfs_schandle * SessionId);
17024 +extern int novfs_daemon_destroy_sessionId(struct novfs_schandle SessionId);
17025 +extern int novfs_daemon_getpwuid(uid_t uid, int unamelen, char *uname);
17026 +extern int novfs_daemon_get_userspace(struct novfs_schandle SessionId,
17027 + uint64_t * TotalSize, uint64_t * TotalFree,
17028 + uint64_t * TotalDirectoryEnties,
17029 + uint64_t * FreeDirectoryEnties);
17030 +extern int novfs_daemon_debug_cmd_send(char *Command);
17031 +extern ssize_t novfs_daemon_recv_reply(struct file *file,
17032 + const char *buf, size_t nbytes, loff_t * ppos);
17033 +extern ssize_t novfs_daemon_cmd_send(struct file *file, char *buf,
17034 + size_t len, loff_t * off);
17035 +extern int novfs_daemon_ioctl(struct inode *inode, struct file *file,
17036 + unsigned int cmd, unsigned long arg);
17037 +extern int novfs_daemon_lib_close(struct inode *inode, struct file *file);
17038 +extern int novfs_daemon_lib_ioctl(struct inode *inode, struct file *file,
17039 + unsigned int cmd, unsigned long arg);
17040 +extern int novfs_daemon_lib_open(struct inode *inode, struct file *file);
17041 +extern ssize_t novfs_daemon_lib_read(struct file *file, char *buf,
17042 + size_t len, loff_t * off);
17043 +extern ssize_t novfs_daemon_lib_write(struct file *file, const char *buf,
17044 + size_t len, loff_t * off);
17045 +extern loff_t novfs_daemon_lib_llseek(struct file *file, loff_t offset,
17046 + int origin);
17047 +extern int novfs_daemon_open_control(struct inode *Inode, struct file *File);
17048 +extern int novfs_daemon_close_control(struct inode *Inode, struct file *File);
17049 +extern int novfs_daemon_getversion(char *Buf, int Length);
17050
17051
17052 /*
17053 * file.c functions
17054 */
17055 -extern int Novfs_get_alltrees(struct dentry *parent);
17056 -extern int Novfs_Get_Connected_Server_List(unsigned char **ServerList, struct schandle *SessionId);
17057 -extern int Novfs_Get_Server_Volume_List(struct qstr *Server, unsigned char **VolumeList, struct schandle *SessionId);
17058 -extern int Novfs_Get_File_Info(unsigned char *Path, struct entry_info *Info, struct schandle *SessionId);
17059 -extern int Novfs_GetX_File_Info(char *Path, const char *Name, char *buffer, ssize_t buffer_size, ssize_t *dataLen, struct schandle *SessionId);
17060 -extern int Novfs_ListX_File_Info(char *Path, char *buffer, ssize_t buffer_size, ssize_t * dataLen, struct schandle *SessionId);
17061 -extern int Novfs_SetX_File_Info(char *Path, const char *Name, const void *Value,
17062 +extern int novfs_verify_file(struct qstr *Path, struct novfs_schandle SessionId);
17063 +extern int novfs_get_alltrees(struct dentry *parent);
17064 +extern int novfs_get_servers(unsigned char **ServerList,
17065 + struct novfs_schandle SessionId);
17066 +extern int novfs_get_vols(struct qstr *Server,
17067 + unsigned char **VolumeList, struct novfs_schandle SessionId);
17068 +extern int novfs_get_file_info(unsigned char *Path,
17069 + struct novfs_entry_info *Info, struct novfs_schandle SessionId);
17070 +extern int novfs_getx_file_info(char *Path, const char *Name,
17071 + char *buffer, ssize_t buffer_size, ssize_t *dataLen,
17072 + struct novfs_schandle SessionId);
17073 +extern int novfs_listx_file_info(char *Path, char *buffer,
17074 + ssize_t buffer_size, ssize_t *dataLen,
17075 + struct novfs_schandle SessionId);
17076 +extern int novfs_setx_file_info(char *Path, const char *Name, const void *Value,
17077 unsigned long valueLen,
17078 unsigned long *bytesWritten, int flags,
17079 - struct schandle *SessionId);
17080 + struct novfs_schandle SessionId);
17081
17082 -extern int Novfs_Get_Directory_ListEx(unsigned char *Path, HANDLE *EnumHandle,
17083 - int *Count, struct entry_info **Info,
17084 - struct schandle *SessionId);
17085 -extern int Novfs_Open_File(unsigned char *Path, int Flags, struct entry_info *info,
17086 - HANDLE * Handle, session_t SessionId);
17087 -extern int Novfs_Create(unsigned char *Path, int DirectoryFlag,
17088 - session_t SessionId);
17089 -extern int Novfs_Close_File(HANDLE Handle, session_t SessionId);
17090 -extern int Novfs_Read_File(HANDLE Handle, unsigned char *Buffer, size_t * Bytes,
17091 - loff_t * Offset, session_t SessionId);
17092 -extern int Novfs_Read_Pages(HANDLE Handle, struct data_list *dlist, int DList_Cnt,
17093 - size_t * Bytes, loff_t * Offset,
17094 - session_t SessionId);
17095 -extern int Novfs_Write_File(HANDLE Handle, unsigned char *Buffer,
17096 +extern int novfs_get_dir_listex(unsigned char *Path, void **EnumHandle,
17097 + int *Count, struct novfs_entry_info **Info,
17098 + struct novfs_schandle SessionId);
17099 +extern int novfs_open_file(unsigned char *Path, int Flags,
17100 + struct novfs_entry_info * Info, void **Handle,
17101 + struct novfs_schandle SessionId);
17102 +extern int novfs_create(unsigned char *Path, int DirectoryFlag,
17103 + struct novfs_schandle SessionId);
17104 +extern int novfs_close_file(void * Handle, struct novfs_schandle SessionId);
17105 +extern int novfs_read_file(void * Handle, unsigned char *Buffer,
17106 + size_t * Bytes, loff_t * Offset,
17107 + struct novfs_schandle SessionId);
17108 +extern int novfs_read_pages(void * Handle, struct novfs_data_list *DList,
17109 + int DList_Cnt, size_t * Bytes, loff_t * Offset,
17110 + struct novfs_schandle SessionId);
17111 +extern int novfs_write_file(void * Handle, unsigned char *Buffer,
17112 size_t * Bytes, loff_t * Offset,
17113 - session_t SessionId);
17114 -extern int Novfs_Write_Page(HANDLE Handle, struct page *Page,
17115 - session_t SessionId);
17116 -extern int Novfs_Write_Pages(HANDLE Handle, struct data_list *dlist, int DList_Cnt,
17117 - size_t Bytes, loff_t Offset, session_t SessionId);
17118 -extern int Novfs_Delete(unsigned char *Path, int DirectoryFlag,
17119 - session_t SessionId);
17120 -extern int Novfs_Truncate_File(unsigned char *Path, int PathLen,
17121 - session_t SessionId);
17122 -extern int Novfs_Truncate_File_Ex(HANDLE Handle, loff_t Offset,
17123 - session_t SessionId);
17124 -extern int Novfs_Rename_File(int DirectoryFlag, unsigned char *OldName,
17125 + struct novfs_schandle SessionId);
17126 +extern int novfs_write_page(void * Handle, struct page *Page,
17127 + struct novfs_schandle SessionId);
17128 +extern int novfs_write_pages(void * Handle, struct novfs_data_list *DList,
17129 + int DList_Cnt, size_t Bytes, loff_t Offset,
17130 + struct novfs_schandle SessionId);
17131 +extern int novfs_delete(unsigned char *Path, int DirectoryFlag,
17132 + struct novfs_schandle SessionId);
17133 +extern int novfs_trunc(unsigned char *Path, int PathLen,
17134 + struct novfs_schandle SessionId);
17135 +extern int novfs_trunc_ex(void * Handle, loff_t Offset,
17136 + struct novfs_schandle SessionId);
17137 +extern int novfs_rename_file(int DirectoryFlag, unsigned char *OldName,
17138 int OldLen, unsigned char *NewName, int NewLen,
17139 - session_t SessionId);
17140 -extern int Novfs_Set_Attr(unsigned char *Path, struct iattr *Attr,
17141 - session_t SessionId);
17142 -extern int Novfs_Get_File_Cache_Flag(unsigned char * Path, session_t SessionId);
17143 -extern int Novfs_Set_File_Lock(session_t SessionId, HANDLE fhandle,
17144 + struct novfs_schandle SessionId);
17145 +extern int novfs_set_attr(unsigned char *Path, struct iattr *Attr,
17146 + struct novfs_schandle SessionId);
17147 +extern int novfs_get_file_cache_flag(unsigned char * Path,
17148 + struct novfs_schandle SessionId);
17149 +extern int novfs_set_file_lock(struct novfs_schandle SessionId, void * fhandle,
17150 unsigned char fl_type, loff_t fl_start,
17151 loff_t len);
17152
17153 -extern struct inode *Novfs_get_inode(struct super_block *sb, int mode, int dev, uid_t uid, ino_t ino, struct qstr *name);
17154 -extern int Novfs_Read_Stream(HANDLE ConnHandle, unsigned char * Handle,
17155 +extern struct inode *novfs_get_inode(struct super_block *sb, int mode,
17156 + int dev, uid_t uid, ino_t ino, struct qstr *name);
17157 +extern int novfs_read_stream(void * ConnHandle, unsigned char * Handle,
17158 unsigned char * Buffer, size_t * Bytes, loff_t * Offset,
17159 - int User, session_t SessionId);
17160 -extern int Novfs_Write_Stream(HANDLE ConnHandle, unsigned char * Handle,
17161 + int User, struct novfs_schandle SessionId);
17162 +extern int novfs_write_stream(void * ConnHandle, unsigned char * Handle,
17163 unsigned char * Buffer, size_t * Bytes, loff_t * Offset,
17164 - session_t SessionId);
17165 -extern int Novfs_Close_Stream(HANDLE ConnHandle, unsigned char * Handle,
17166 - session_t SessionId);
17167 + struct novfs_schandle SessionId);
17168 +extern int novfs_close_stream(void * ConnHandle, unsigned char * Handle,
17169 + struct novfs_schandle SessionId);
17170
17171 -extern int Novfs_Add_to_Root(char *);
17172 +extern int novfs_add_to_root(char *);
17173
17174
17175 /*
17176 * scope.c functions
17177 */
17178 -extern void Scope_Init(void);
17179 -extern void Scope_Uninit(void);
17180 -extern void *Scope_Lookup(void);
17181 -extern uid_t Scope_Get_Uid(void *);
17182 -extern session_t Scope_Get_SessionId(void *Scope);
17183 -//extern session_t Scope_Get_SessionId(PSCOPE_LIST Scope);
17184 -extern char *Scope_Get_ScopeUsers(void);
17185 -extern int Scope_Set_UserSpace(u64 *TotalSize, u64 *Free,
17186 - u64 *TotalEnties, u64 *FreeEnties);
17187 -extern int Scope_Get_UserSpace(u64 *TotalSize, u64 *Free,
17188 - u64 *TotalEnties, u64 *FreeEnties);
17189 -extern char *Scope_dget_path(struct dentry *Dentry, char *Buf,
17190 +extern void novfs_scope_init(void);
17191 +extern void novfs_scope_exit(void);
17192 +extern void *novfs_scope_lookup(void);
17193 +extern uid_t novfs_scope_get_uid(struct novfs_scope_list *);
17194 +extern struct novfs_schandle novfs_scope_get_sessionId(struct
17195 + novfs_scope_list *);
17196 +extern char *novfs_get_scopeusers(void);
17197 +extern int novfs_scope_set_userspace(uint64_t * TotalSize, uint64_t * Free,
17198 + uint64_t * TotalEnties, uint64_t * FreeEnties);
17199 +extern int novfs_scope_get_userspace(uint64_t * TotalSize, uint64_t * Free,
17200 + uint64_t * TotalEnties, uint64_t * FreeEnties);
17201 +extern char *novfs_scope_dget_path(struct dentry *Dentry, char *Buf,
17202 unsigned int Buflen, int Flags);
17203 -extern char *Scope_Get_UserName(void);
17204 -extern void Scope_Cleanup(void);
17205 +extern void novfs_scope_cleanup(void);
17206 +extern struct novfs_scope_list *novfs_get_scope_from_name(struct qstr *);
17207 +extern struct novfs_scope_list *novfs_get_scope(struct dentry *);
17208 +extern char *novfs_scope_get_username(void);
17209
17210 /*
17211 * profile.c functions
17212 */
17213 extern u64 get_nanosecond_time(void);
17214 -static inline void *Novfs_Malloc(size_t size, int flags) { return kmalloc(size, flags); }
17215 extern int DbgPrint(char *Fmt, ...);
17216 -extern int init_profile(void);
17217 -extern void uninit_profile(void);
17218 +extern void novfs_profile_init(void);
17219 +extern void novfs_profile_exit(void);
17220
17221 /*
17222 * nwcapi.c functions
17223 */
17224 -extern int NwAuthConnWithId(PXPLAT pdata, session_t Session);
17225 -extern int NwConnClose(PXPLAT pdata, HANDLE * Handle, session_t Session);
17226 -extern int NwGetConnInfo(PXPLAT pdata, session_t Session);
17227 -extern int NwSetConnInfo(PXPLAT pdata, session_t Session);
17228 -extern int NwGetDaemonVersion(PXPLAT pdata, session_t Session);
17229 -extern int NwGetIdentityInfo(PXPLAT pdata, session_t Session);
17230 -extern int NwLicenseConn(PXPLAT pdata, session_t Session);
17231 -extern int NwLoginIdentity(PXPLAT pdata, struct schandle *Session);
17232 -extern int NwLogoutIdentity(PXPLAT pdata, session_t Session);
17233 -extern int NwOpenConnByAddr(PXPLAT pdata, HANDLE * Handle, session_t Session);
17234 -extern int NwOpenConnByName(PXPLAT pdata, HANDLE * Handle, session_t Session);
17235 -extern int NwOpenConnByRef(PXPLAT pdata, HANDLE * Handle, session_t Session);
17236 -extern int NwQueryFeature(PXPLAT pdata, session_t Session);
17237 -extern int NwRawSend(PXPLAT pdata, session_t Session);
17238 -extern int NwScanConnInfo(PXPLAT pdata, session_t Session);
17239 -extern int NwSysConnClose(PXPLAT pdata, unsigned long * Handle, session_t Session);
17240 -extern int NwUnAuthenticate(PXPLAT pdata, session_t Session);
17241 -extern int NwUnlicenseConn(PXPLAT pdata, session_t Session);
17242 -extern int NwcChangeAuthKey(PXPLAT pdata, session_t Session);
17243 -extern int NwcEnumIdentities(PXPLAT pdata, session_t Session);
17244 -extern int NwcGetDefaultNameCtx(PXPLAT pdata, session_t Session);
17245 -extern int NwcGetPreferredDSTree(PXPLAT pdata, session_t Session);
17246 -extern int NwcGetTreeMonitoredConn(PXPLAT pdata, session_t Session);
17247 -extern int NwcSetDefaultNameCtx(PXPLAT pdata, session_t Session);
17248 -extern int NwcSetPreferredDSTree(PXPLAT pdata, session_t Session);
17249 -extern int NwcSetPrimaryConn(PXPLAT pdata, session_t Session);
17250 -extern int NwcGetPrimaryConn(PXPLAT pdata, session_t Session);
17251 -extern int NwcSetMapDrive(PXPLAT pdata, session_t Session);
17252 -extern int NwcUnMapDrive(PXPLAT pdata, session_t Session);
17253 -extern int NwcEnumerateDrives(PXPLAT pdata, session_t Session);
17254 -extern int NwcGetBroadcastMessage(PXPLAT pdata, session_t Session);
17255 -extern int NwdSetKeyValue(PXPLAT pdata, session_t Session);
17256 -extern int NwdVerifyKeyValue(PXPLAT pdata, session_t Session);
17257 +extern int novfs_auth_conn(struct novfs_xplat *pdata,
17258 + struct novfs_schandle Session);
17259 +extern int novfs_conn_close(struct novfs_xplat *pdata,
17260 + void **Handle, struct novfs_schandle Session);
17261 +extern int novfs_get_conn_info(struct novfs_xplat *pdata,
17262 + struct novfs_schandle Session);
17263 +extern int novfs_set_conn_info(struct novfs_xplat *pdata,
17264 + struct novfs_schandle Session);
17265 +extern int novfs_get_daemon_ver(struct novfs_xplat *pdata,
17266 + struct novfs_schandle Session);
17267 +extern int novfs_get_id_info(struct novfs_xplat *pdata,
17268 + struct novfs_schandle Session);
17269 +extern int novfs_license_conn(struct novfs_xplat *pdata,
17270 + struct novfs_schandle Session);
17271 +extern int novfs_login_id(struct novfs_xplat *pdata,
17272 + struct novfs_schandle Session);
17273 +extern int novfs_logout_id(struct novfs_xplat *pdata,
17274 + struct novfs_schandle Session);
17275 +extern int novfs_open_conn_by_addr(struct novfs_xplat *pdata,
17276 + void **Handle, struct novfs_schandle Session);
17277 +extern int novfs_open_conn_by_name(struct novfs_xplat *pdata,
17278 + void **Handle, struct novfs_schandle Session);
17279 +extern int novfs_open_conn_by_ref(struct novfs_xplat *pdata,
17280 + void **Handle, struct novfs_schandle Session);
17281 +extern int novfs_query_feature(struct novfs_xplat *pdata,
17282 + struct novfs_schandle Session);
17283 +extern int novfs_raw_send(struct novfs_xplat *pdata,
17284 + struct novfs_schandle Session);
17285 +extern int novfs_scan_conn_info(struct novfs_xplat *pdata,
17286 + struct novfs_schandle Session);
17287 +extern int novfs_sys_conn_close(struct novfs_xplat *pdata,
17288 + unsigned long *Handle, struct novfs_schandle Session);
17289 +extern int novfs_unauthenticate(struct novfs_xplat *pdata,
17290 + struct novfs_schandle Session);
17291 +extern int novfs_unlicense_conn(struct novfs_xplat *pdata,
17292 + struct novfs_schandle Session);
17293 +extern int novfs_change_auth_key(struct novfs_xplat *pdata,
17294 + struct novfs_schandle Session);
17295 +extern int novfs_enum_ids(struct novfs_xplat *pdata,
17296 + struct novfs_schandle Session);
17297 +extern int novfs_get_default_ctx(struct novfs_xplat *pdata,
17298 + struct novfs_schandle Session);
17299 +extern int novfs_get_preferred_DS_tree(struct novfs_xplat *pdata,
17300 + struct novfs_schandle Session);
17301 +extern int novfs_get_tree_monitored_conn(struct novfs_xplat *pdata,
17302 + struct novfs_schandle Session);
17303 +extern int novfs_set_default_ctx(struct novfs_xplat *pdata,
17304 + struct novfs_schandle Session);
17305 +extern int novfs_set_preferred_DS_tree(struct novfs_xplat *pdata,
17306 + struct novfs_schandle Session);
17307 +extern int novfs_set_pri_conn(struct novfs_xplat *pdata,
17308 + struct novfs_schandle Session);
17309 +extern int novfs_get_pri_conn(struct novfs_xplat *pdata,
17310 + struct novfs_schandle Session);
17311 +extern int novfs_set_map_drive(struct novfs_xplat *pdata,
17312 + struct novfs_schandle Session);
17313 +extern int novfs_unmap_drive(struct novfs_xplat *pdata,
17314 + struct novfs_schandle Session);
17315 +extern int novfs_enum_drives(struct novfs_xplat *pdata,
17316 + struct novfs_schandle Session);
17317 +extern int novfs_get_bcast_msg(struct novfs_xplat *pdata,
17318 + struct novfs_schandle Session);
17319 +extern int novfs_set_key_value(struct novfs_xplat *pdata,
17320 + struct novfs_schandle Session);
17321 +extern int novfs_verify_key_value(struct novfs_xplat *pdata,
17322 + struct novfs_schandle Session);
17323
17324
17325 #endif /* __NOVFS_H */
Timo's tree of IPFire 2.x