← Back to branch summary

~ubuntu-branches/ubuntu/quantal/open-vm-tools/quantal-201207201942

« back to all changes in this revision

Viewing changes to modules/solaris/vmhgfs/debug.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2009-03-20 10:19:00 UTC
  • mfrom: (1.1.4 upstream) (2.4.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090320101900-1o604camiubq2de8
Tags: 2009.03.18-154848-2
http://bugs.debian.org/520493
Correcting patch system depends (Closes: #520493).

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/solaris/vmhgfs/debug.c
 
1
/*********************************************************
 
2
 * Copyright (C) 2004 VMware, Inc. All rights reserved.
 
3
 *
 
4
 * The contents of this file are subject to the terms of the Common
 
5
 * Development and Distribution License (the "License") version 1.0
 
6
 * and no later version.  You may not use this file except in
 
7
 * compliance with the License.
 
8
 *
 
9
 * You can obtain a copy of the License at
 
10
 *         http://www.opensource.org/licenses/cddl1.php
 
11
 *
 
12
 * See the License for the specific language governing permissions
 
13
 * and limitations under the License.
 
14
 *
 
15
 *********************************************************/
 
16
 
 
17
 
 
18
/*
 
19
 * debug.c --
 
20
 *
 
21
 * Routines for debugging Solaris kernel module.
 
22
 *
 
23
 */
 
24
 
 
25
 
 
26
#include "debug.h"
 
27
#include "filesystem.h"
 
28
#ifndef SOL9
 
29
#include <sys/cred_impl.h>
 
30
#endif
 
31
 
 
32
 
 
33
/*
 
34
 * Functions
 
35
 */
 
36
 
 
37
 
 
38
/*
 
39
 *----------------------------------------------------------------------------
 
40
 *
 
41
 * HgfsDebugPrintVfssw --
 
42
 *
 
43
 *    Prints the provided VFS Switch structure.
 
44
 *
 
45
 * Results:
 
46
 *    None.
 
47
 *
 
48
 * Side effects:
 
49
 *    None.
 
50
 *
 
51
 *
 
52
 *----------------------------------------------------------------------------
 
53
 */
 
54
 
 
55
INLINE void
 
56
HgfsDebugPrintVfssw(char *str, struct vfssw *vfsswp)
 
57
{
 
58
   ASSERT(str);
 
59
   ASSERT(vfsswp);
 
60
 
 
61
   DEBUG(VM_DEBUG_STRUCT, "struct vfssw from %s\n", str);
 
62
   DEBUG(VM_DEBUG_STRUCT, " vsw_name    : %s\n",
 
63
         (vfsswp->vsw_name) ? vfsswp->vsw_name : "NULL");
 
64
   DEBUG(VM_DEBUG_STRUCT, " vsw_init    : %p\n", vfsswp->vsw_init);
 
65
   DEBUG(VM_DEBUG_STRUCT, " vsw_flag    : %x\n", vfsswp->vsw_flag);
 
66
#  ifdef SOL9
 
67
   DEBUG(VM_DEBUG_STRUCT, " vsw_vfsops  : %x\n", vfsswp->vsw_vfsops);
 
68
   DEBUG(VM_DEBUG_STRUCT, " vsw_optproto: %x\n", vfsswp->vsw_optproto);
 
69
#  endif
 
70
   DEBUG(VM_DEBUG_STRUCT, " vsw_count   : %d\n", vfsswp->vsw_count);
 
71
}
 
72
 
 
73
 
 
74
/*
 
75
 *----------------------------------------------------------------------------
 
76
 *
 
77
 * HgfsDebugPrintVfs --
 
78
 *
 
79
 *    Prints the provided VFS structure.
 
80
 *
 
81
 * Results:
 
82
 *    None.
 
83
 *
 
84
 * Side effects:
 
85
 *    None.
 
86
 *
 
87
 *
 
88
 *----------------------------------------------------------------------------
 
89
 */
 
90
 
 
91
INLINE void
 
92
HgfsDebugPrintVfs(char *str, struct vfs *vfsp)
 
93
{
 
94
   ASSERT(str);
 
95
   ASSERT(vfsp);
 
96
 
 
97
   DEBUG(VM_DEBUG_STRUCT, "struct vfs from %s\n", str);
 
98
   DEBUG(VM_DEBUG_STRUCT, " vfs_next        : %p\n", vfsp->vfs_next);
 
99
   DEBUG(VM_DEBUG_STRUCT, " vfs_op          : %p\n", vfsp->vfs_op);
 
100
   DEBUG(VM_DEBUG_STRUCT, " vfs_vnodecovered: %p\n", vfsp->vfs_vnodecovered);
 
101
   DEBUG(VM_DEBUG_STRUCT, " vfs_flag        : %d\n", vfsp->vfs_flag);
 
102
   DEBUG(VM_DEBUG_STRUCT, " vfs_bsize       : %d\n", vfsp->vfs_bsize);
 
103
   DEBUG(VM_DEBUG_STRUCT, " vfs_fstype      : %d\n", vfsp->vfs_fstype);
 
104
#  ifdef SOL9
 
105
   DEBUG(VM_DEBUG_STRUCT, " vfs_fsid        : %d\n", vfsp->vfs_fsid);
 
106
#  else
 
107
   DEBUG(VM_DEBUG_STRUCT, " vfs_fsid.val[0] : %d\n", vfsp->vfs_fsid.val[0]);
 
108
   DEBUG(VM_DEBUG_STRUCT, " vfs_fsid.val[1] : %d\n", vfsp->vfs_fsid.val[1]);
 
109
#  endif
 
110
   DEBUG(VM_DEBUG_STRUCT, " vfs_vadata      : %p\n", vfsp->vfs_data);
 
111
   DEBUG(VM_DEBUG_STRUCT, " vfs_dev         : %lu\n", vfsp->vfs_dev);
 
112
   DEBUG(VM_DEBUG_STRUCT, " vfs_bcount      : %lu\n", vfsp->vfs_bcount);
 
113
#  ifdef SOL9
 
114
   DEBUG(VM_DEBUG_STRUCT, " vfs_nsubmounts  : %d\n", vfsp->vfs_nsubmounts);
 
115
#  endif
 
116
   DEBUG(VM_DEBUG_STRUCT, " vfs_list        : %p\n", vfsp->vfs_list);
 
117
   DEBUG(VM_DEBUG_STRUCT, " vfs_hash        : %p\n", vfsp->vfs_hash);
 
118
   DEBUG(VM_DEBUG_STRUCT, " vfs_reflock     : %p\n", &vfsp->vfs_reflock);
 
119
   DEBUG(VM_DEBUG_STRUCT, " vfs_count       : %d\n", vfsp->vfs_count);
 
120
#  ifdef SOL9
 
121
   DEBUG(VM_DEBUG_STRUCT, " vfs_mntopts     : %x\n", vfsp->vfs_mntopts);
 
122
   DEBUG(VM_DEBUG_STRUCT, " vfs_resource    : %s\n",
 
123
         (vfsp->vfs_resource) ? vfsp->vfs_resource : "NULL");
 
124
#  endif
 
125
   DEBUG(VM_DEBUG_STRUCT, " vfs_mtime       : %ld\n", vfsp->vfs_mtime);
 
126
 
 
127
}
 
128
 
 
129
 
 
130
/*
 
131
 *----------------------------------------------------------------------------
 
132
 *
 
133
 * HgfsDebugPrintVnode --
 
134
 *
 
135
 *    Prints the provided vnode structure.
 
136
 *
 
137
 * Results:
 
138
 *    None.
 
139
 *
 
140
 * Side effects:
 
141
 *    None.
 
142
 *
 
143
 *
 
144
 *----------------------------------------------------------------------------
 
145
 */
 
146
 
 
147
INLINE void
 
148
HgfsDebugPrintVnode(uint32 level, char *str,
 
149
                    struct vnode *vnodep, Bool printFileName)
 
150
{
 
151
   ASSERT(str);
 
152
   ASSERT(vnodep);
 
153
 
 
154
   DEBUG(level, "struct vnode from %s located at %p\n", str, vnodep);
 
155
   DEBUG(level, " v_lock          : %p\n", &vnodep->v_lock);
 
156
   DEBUG(level, " v_flag          : %d\n", vnodep->v_flag);
 
157
   DEBUG(level, " v_count         : %d\n", vnodep->v_count);
 
158
   DEBUG(level, " v_vfsmountedhere: %p\n", vnodep->v_vfsmountedhere);
 
159
   DEBUG(level, " v_op            : %p\n", vnodep->v_op);
 
160
   DEBUG(level, " v_vfsp          : %p\n", vnodep->v_vfsp);
 
161
   DEBUG(level, " v_stream        : %p\n", vnodep->v_stream);
 
162
   DEBUG(level, " v_pages         : %p\n", vnodep->v_pages);
 
163
#  ifdef SOL9
 
164
   DEBUG(level, " v_next          : %p\n", vnodep->v_next);
 
165
   DEBUG(level, " v_prev          : %p\n", vnodep->v_prev);
 
166
#  endif
 
167
   DEBUG(level, " v_type          : %d\n", vnodep->v_type);
 
168
   DEBUG(level, " v_rdev          : %lu\n", vnodep->v_rdev);
 
169
   DEBUG(level, " v_data          : %p\n", vnodep->v_data);
 
170
   DEBUG(level, " v_filocks       : %p\n", vnodep->v_filocks);
 
171
   DEBUG(level, " v_shrlocks      : %p\n", vnodep->v_shrlocks);
 
172
   DEBUG(level, " v_cv            : %p\n", &vnodep->v_cv);
 
173
   DEBUG(level, " v_locality      : %p\n", vnodep->v_locality);
 
174
   DEBUG(level, " v_nbllock       : %p\n", &vnodep->v_nbllock);
 
175
 
 
176
   if (printFileName && HGFS_VP_TO_OFP(vnodep) && HGFS_VP_TO_FP(vnodep)) {
 
177
      DEBUG(level, " filename        : %s\n", HGFS_VP_TO_FILENAME(vnodep));
 
178
   }
 
179
}
 
180
 
 
181
 
 
182
/*
 
183
 *----------------------------------------------------------------------------
 
184
 *
 
185
 * HgfsDebugPrintCred --
 
186
 *
 
187
 *    Prints the provided cred structure the describes the credentials of the
 
188
 *    caller.
 
189
 *
 
190
 * Results:
 
191
 *    None.
 
192
 *
 
193
 * Side effects:
 
194
 *    None.
 
195
 *
 
196
 *
 
197
 *----------------------------------------------------------------------------
 
198
 */
 
199
 
 
200
INLINE void
 
201
HgfsDebugPrintCred(char *str, struct cred *credp)
 
202
{
 
203
   DEBUG(VM_DEBUG_STRUCT, "struct cred from %s\n", str);
 
204
   DEBUG(VM_DEBUG_STRUCT, " cr_ref    : %d\n", credp->cr_ref);
 
205
   DEBUG(VM_DEBUG_STRUCT, " cr_uid    : %d\n", credp->cr_uid);
 
206
   DEBUG(VM_DEBUG_STRUCT, " cr_gid    : %d\n", credp->cr_gid);
 
207
   DEBUG(VM_DEBUG_STRUCT, " cr_ruid   : %d\n", credp->cr_ruid);
 
208
   DEBUG(VM_DEBUG_STRUCT, " cr_rgid   : %d\n", credp->cr_rgid);
 
209
   DEBUG(VM_DEBUG_STRUCT, " cr_suid   : %d\n", credp->cr_suid);
 
210
   DEBUG(VM_DEBUG_STRUCT, " cr_sgid   : %d\n", credp->cr_sgid);
 
211
   DEBUG(VM_DEBUG_STRUCT, " cr_ngroups: %d\n", credp->cr_ngroups);
 
212
   DEBUG(VM_DEBUG_STRUCT, " cr_groups : %p\n", credp->cr_groups);
 
213
}
 
214
 
 
215
 
 
216
/*
 
217
 *----------------------------------------------------------------------------
 
218
 *
 
219
 * HgfsDebugMounta --
 
220
 *
 
221
 *    Prints the provided mounta structure that describes the arguments
 
222
 *    provided to users.
 
223
 *
 
224
 * Results:
 
225
 *    None.
 
226
 *
 
227
 * Side effects:
 
228
 *    None.
 
229
 *
 
230
 *
 
231
 *----------------------------------------------------------------------------
 
232
 */
 
233
 
 
234
INLINE void
 
235
HgfsDebugPrintMounta(char *str, struct mounta *mntp)
 
236
{
 
237
   ASSERT(str);
 
238
   ASSERT(mntp);
 
239
 
 
240
   DEBUG(VM_DEBUG_STRUCT, "struct mounta from %s\n", str);
 
241
   DEBUG(VM_DEBUG_STRUCT, " spec    : %s\n",
 
242
         (mntp->spec) ? mntp->spec : "NULL");
 
243
   DEBUG(VM_DEBUG_STRUCT, " dir     : %s\n",
 
244
         (mntp->dir) ? mntp->dir : "NULL");
 
245
   DEBUG(VM_DEBUG_STRUCT, " flags   : %x\n", mntp->flags);
 
246
   DEBUG(VM_DEBUG_STRUCT, " fstype  : %s\n",
 
247
         (mntp->fstype) ? mntp->fstype : "NULL");
 
248
   DEBUG(VM_DEBUG_STRUCT, " dataptr : %p\n", mntp->dataptr);
 
249
   DEBUG(VM_DEBUG_STRUCT, " datalen : %d\n", mntp->datalen);
 
250
   DEBUG(VM_DEBUG_STRUCT, " optptr  : %p\n", mntp->optptr);
 
251
   DEBUG(VM_DEBUG_STRUCT, " optlen  : %d\n", mntp->optlen);
 
252
}
 
253
 
 
254
 
 
255
/*
 
256
 *----------------------------------------------------------------------------
 
257
 *
 
258
 * HgfsDebugPrintVattr --
 
259
 *
 
260
 *    Prints the contents of an attributes structure.
 
261
 *
 
262
 * Results:
 
263
 *    None.
 
264
 *
 
265
 * Side effects:
 
266
 *    None.
 
267
 *
 
268
 *----------------------------------------------------------------------------
 
269
 */
 
270
 
 
271
INLINE void
 
272
HgfsDebugPrintVattr(const struct vattr *vap)
 
273
{
 
274
   DEBUG(VM_DEBUG_STRUCT, " va_mask: %x\n", vap->va_mask);
 
275
   DEBUG(VM_DEBUG_STRUCT, " va_type: %d\n", vap->va_type);
 
276
   DEBUG(VM_DEBUG_STRUCT, " va_mode: %x\n", vap->va_mode);
 
277
   DEBUG(VM_DEBUG_STRUCT, " va_uid:  %u\n", vap->va_uid);
 
278
   DEBUG(VM_DEBUG_STRUCT, " va_gid: %u\n", vap->va_gid);
 
279
   DEBUG(VM_DEBUG_STRUCT, " va_fsid: %lu\n", vap->va_fsid);
 
280
   DEBUG(VM_DEBUG_STRUCT, " va_nodeid: %llu\n", vap->va_nodeid);
 
281
   DEBUG(VM_DEBUG_STRUCT, " va_nlink: %x\n", vap->va_nlink);
 
282
   DEBUG(VM_DEBUG_STRUCT, " va_size: %llu\n", vap->va_size);
 
283
   DEBUG(VM_DEBUG_STRUCT, " va_atime.tv_sec: %ld\n", vap->va_atime.tv_sec);
 
284
   DEBUG(VM_DEBUG_STRUCT, " va_atime.tv_nsec: %ld\n", vap->va_atime.tv_nsec);
 
285
   DEBUG(VM_DEBUG_STRUCT, " va_mtime.tv_sec: %ld\n", vap->va_mtime.tv_sec);
 
286
   DEBUG(VM_DEBUG_STRUCT, " va_mtime.tv_nsec: %ld\n", vap->va_mtime.tv_nsec);
 
287
   DEBUG(VM_DEBUG_STRUCT, " va_ctime.tv_sec: %ld\n", vap->va_ctime.tv_sec);
 
288
   DEBUG(VM_DEBUG_STRUCT, " va_ctime.tv_nsec: %ld\n", vap->va_ctime.tv_nsec);
 
289
   DEBUG(VM_DEBUG_STRUCT, " va_rdev: %lu\n", vap->va_rdev);
 
290
   DEBUG(VM_DEBUG_STRUCT, " va_blksize: %u\n", vap->va_blksize);
 
291
   DEBUG(VM_DEBUG_STRUCT, " va_nblocks: %llu\n", vap->va_nblocks);
 
292
#ifdef SOL9
 
293
   DEBUG(VM_DEBUG_STRUCT, " va_vcode: %u\n", vap->va_vcode);
 
294
#else
 
295
   DEBUG(VM_DEBUG_STRUCT, " va_seq: %u\n", vap->va_seq);
 
296
#endif
 
297
}
 
298
 
 
299
 
 
300
/*
 
301
 *----------------------------------------------------------------------------
 
302
 *
 
303
 * HgfsDebugPrintReqList --
 
304
 *
 
305
 *    For debugging.  Prints out the request list for the provided list
 
306
 *    anchor.
 
307
 *    Note: Assumes called with the list lock held.
 
308
 *
 
309
 * Results:
 
310
 *    None.
 
311
 *
 
312
 * Side effects:
 
313
 *    None.
 
314
 *
 
315
 *----------------------------------------------------------------------------
 
316
 */
 
317
 
 
318
void
 
319
HgfsDebugPrintReqList(DblLnkLst_Links *listAnchor)   // IN: Anchor of list to print
 
320
{
 
321
   DblLnkLst_Links *currNode;
 
322
   HgfsReq *currReq;
 
323
 
 
324
   ASSERT(listAnchor);
 
325
 
 
326
   DEBUG(VM_DEBUG_STRUCT, "Request List:\n");
 
327
   DEBUG(VM_DEBUG_STRUCT, " anchor: %p\n", listAnchor);
 
328
 
 
329
   for (currNode = listAnchor->next; currNode != listAnchor; currNode = currNode->next)
 
330
   {
 
331
      currReq = DblLnkLst_Container(currNode, HgfsReq, listNode);
 
332
      DEBUG(VM_DEBUG_STRUCT, " address: %p (id=%d)\n",
 
333
            currReq, currReq->id);
 
334
   }
 
335
 
 
336
   DEBUG(VM_DEBUG_STRUCT, "--DONE--\n");
 
337
}
 
338
 
 
339
 
 
340
/*
 
341
 *----------------------------------------------------------------------------
 
342
 *
 
343
 * HgfsDebugPrintReq --
 
344
 *
 
345
 *    Prints the relevant portions of the provided HgfsReq structure.
 
346
 *
 
347
 * Results:
 
348
 *    None.
 
349
 *
 
350
 * Side effects:
 
351
 *    None.
 
352
 *
 
353
 *
 
354
 *----------------------------------------------------------------------------
 
355
 */
 
356
 
 
357
void
 
358
HgfsDebugPrintReq(const char *str,
 
359
                  HgfsReq *req)
 
360
{
 
361
   ASSERT(str);
 
362
   ASSERT(req);
 
363
 
 
364
   DEBUG(VM_DEBUG_STRUCT, "struct HgfsReq from %s\n", str);
 
365
   DEBUG(VM_DEBUG_STRUCT, " id: %d\n", req->id);
 
366
   DEBUG(VM_DEBUG_STRUCT, " listNode: %p\n", &req->listNode);
 
367
   DEBUG(VM_DEBUG_STRUCT, "  next=%p\n", req->listNode.next);
 
368
   DEBUG(VM_DEBUG_STRUCT, "  prev=%p\n", req->listNode.prev);
 
369
   DEBUG(VM_DEBUG_STRUCT, " packetSize: %d\n", req->packetSize);
 
370
   DEBUG(VM_DEBUG_STRUCT, " state: %d (see hgfsSolaris.h)\n", req->state);
 
371
}
 
372
 
 
373
 
 
374
/*
 
375
 *----------------------------------------------------------------------------
 
376
 *
 
377
 * HgfsDebugPrintReqPool --
 
378
 *
 
379
 *    Prints the contents if the request pool.
 
380
 *
 
381
 * Results:
 
382
 *    None.
 
383
 *
 
384
 * Side effects:
 
385
 *    None.
 
386
 *
 
387
 *
 
388
 *----------------------------------------------------------------------------
 
389
 */
 
390
 
 
391
void
 
392
HgfsDebugPrintReqPool(const char *str)
 
393
{
 
394
   int i;
 
395
 
 
396
   ASSERT(str);
 
397
 
 
398
   DEBUG(VM_DEBUG_STRUCT, "Request pool from %s\n", str);
 
399
 
 
400
   for (i = 0; i < ARRAYSIZE(requestPool); i++) {
 
401
      DEBUG(VM_DEBUG_STRUCT, " Index: %d, ID: %d\n", i, requestPool[i].id);
 
402
      DEBUG(VM_DEBUG_STRUCT, " listNode: %p\n", &requestPool[i].listNode);
 
403
      DEBUG(VM_DEBUG_STRUCT, "  next=%p\n", requestPool[i].listNode.next);
 
404
      DEBUG(VM_DEBUG_STRUCT, "  prev=%p\n", requestPool[i].listNode.prev);
 
405
      DEBUG(VM_DEBUG_STRUCT, " packetSize: %d\n", requestPool[i].packetSize);
 
406
      DEBUG(VM_DEBUG_STRUCT, " state: %d (see hgfsSolaris.h)\n", requestPool[i].state);
 
407
   }
 
408
 
 
409
   DEBUG(VM_DEBUG_STRUCT, "--request pool done--\n");
 
410
}
 
411
 
 
412
 
 
413
/*
 
414
 * There is a problem in Solaris 9's header files when using the va_start
 
415
 * and va_end macros, so we manually do what the preprocessor would have
 
416
 * done here.
 
417
 *
 
418
 * Note, the line using __builtin_next_arg is equivalent to:
 
419
 * args = ((char *)(&fmt) + sizeof (char *));
 
420
 *
 
421
 * That is, it just provides a pointer to the unnamed first variable
 
422
 * argument.
 
423
 */
 
424
#ifdef SOL9
 
425
# define compat_va_start(arg, fmt) arg = ((char *)__builtin_next_arg(fmt))
 
426
# define compat_va_end(arg)
 
427
#else
 
428
# define compat_va_start(arg, fmt) va_start(arg, fmt)
 
429
# define compat_va_end(arg)        va_end(arg)
 
430
#endif
 
431
 
 
432
static void
 
433
vLog(const char *fmt,
 
434
     va_list args)
 
435
{
 
436
#ifdef VM_DEBUG_LEV
 
437
   char buffer[1024];
 
438
 
 
439
   /*
 
440
    * We check this here to avoid unnecessarily manipulating buffer if we
 
441
    * aren't even going to print the log.
 
442
    */
 
443
   if (VM_DEBUG_LOG & VM_DEBUG_LEV) {
 
444
      vsprintf(buffer, fmt, args);
 
445
      cmn_err(HGFS_DEBUG, "%s", buffer);
 
446
   }
 
447
#endif
 
448
}
 
449
 
 
450
 
 
451
/*
 
452
 * For compatibility with existing code.
 
453
 */
 
454
 
 
455
void
 
456
Log(const char *fmt, ...)     // IN: format string, etc
 
457
{
 
458
   va_list args;
 
459
 
 
460
   compat_va_start(args, fmt);
 
461
   vLog(fmt, args);
 
462
   compat_va_end(args);
 
463
}
 
464
 
 
465
 
 
466
/*
 
467
 * For compatibility with existing code.
 
468
 */
 
469
 
 
470
void
 
471
Debug(const char *fmt, ...)   // IN: format string, etc.
 
472
{
 
473
   va_list args;
 
474
 
 
475
   compat_va_start(args, fmt);
 
476
   vLog(fmt, args);
 
477
   compat_va_end(args);
 
478
}
 
479
 
 
480
 
 
481
#undef compat_va_list
 
482
#undef compat_va_start
 
483
#undef compat_va_end