1TAPSET::SOCKET(3stap)                                    TAPSET::SOCKET(3stap)
2
3
4

NAME

6       tapset::socket - systemtap socket probe points
7
8
9

DESCRIPTION

11       This  family  of  probe  points is used to probe socket activities.  It
12       contains the following probe points:
13
14
15       socket.send
16
17              Fires at the conclusion of sending a message on a socket.   This
18              probe      alias     includes     the     socket.sendmsg.return,
19              socket.aio_write.return and socket.writev.return  probes  (these
20              probes  should  catch  all messages sent on sockets).  The argu‐
21              ments supplied at the beginning of the send are cached and  made
22              available in this probe.
23
24              Context:
25
26              The message sender.
27
28              Arguments:
29
30              name
31                  Name of this probe.
32
33              size
34                  Size  of message sent (in bytes) or error code if success ==
35              0
36
37              protocol
38                  Protocol used on the socket. Use sock_prot_num2str(protocol)
39                  to convert to a string.
40
41                  Common values include:
42                       0 - IP (Internet Protocol, local interprocess  communi‐
43              cations)
44                       6 - TCP (Transmission Control Protocol)
45                      17 - UDP (User Datagram Protocol)
46                     132 - SCTP (Stream Control Transmission Protocol)
47
48                   Refer  to  /etc/protocols  for  a complete list of possible
49              values.
50
51              family
52                  Protocol family of the socket (from include/linux/socket.h).
53                  Use sock_fam_num2str(family) to convert to a string.
54
55                  Possible values are:
56                      0  - UNSPEC (Unspecified)
57                      1  - LOCAL (Unix domain/local sockets)
58                      2  - INET (Internet Protocol (IP))
59                      3  - AX25 (Amateur Radio AX.25)
60                      4  - IPX (Novell IPX)
61                      5  - APPLETALK (AppleTalk DDP)
62                      6  - NETROM (Amateur Radio NET/ROM)
63                      7  - BRIDGE (Multiprotocol bridge)
64                      8  - ATMPVC (ATM PVCs)
65                      9  - X25 (X.25)
66                      10 - INET6 (IP version 6)
67                      11 - ROSE (Amateur Radio X.25 PLP)
68                      12 - DECNET (Reserved for DECnet project)
69                      13 - NETBEUI (Reserved for 802.2LLC project)
70                      14 - SECURITY (Security callback pseudo AF)
71                      15 - KEY (key management API)
72                      16 - NETLINK (Netlink protocol)
73                      17 - PACKET (Packet family)
74                      18 - ASH (Ash)
75                      19 - ECONET (Acorn Econet)
76                      20 - ATMSVC (ATM SVCs)
77                      22 - SNA (Linux SNA Project)
78                      23 - IRDA (IRDA sockets)
79                      24 - PPP0X (PPPoX sockets)
80                      25 - WANPIPE (Wanpipe API Sockets)
81                      26 - LLC (Linux LLC)
82                      30 - TIPC (TIPC sockets)
83                      31 - BLUETOOTH (Bluetooth sockets)
84
85              state
86                  State of the socket.  Use sock_state_num2str(state) to  con‐
87              vert
88                  to a string.
89
90                  Possible values are:
91                      0 - FREE (not allocated)
92                      1 - UNCONNECTED (unconnected to any socket)
93                      2 - CONNECTING (in the process of connecting)
94                      3 - CONNECTED (connected to a socket)
95                      4 - DISCONNECTING (in the process of disconnecting)
96
97              flags
98                  Socket flags.  Use sock_flags_num2str(flags) to convert
99                  to a string.
100
101                  Possible values are:
102                      0 - ASYNC_NOSPACE
103                      1 - ASYNC_WAITDATA
104                      2 - NOSPACE
105                      3 - PASSCRED
106                      4 - PASSSEC
107
108              type
109                  Socket type.  Use sock_type_num2str(type) to convert
110                  to a string.
111
112                  Possible values are:
113                      1  - STREAM (stream connection socket)
114                      2  - DGRAM (datagram connectionless socket)
115                      3  - RAW (raw socket)
116                      4  - RDM (reliably-deliverd message)
117                      5  - SEQPACKET (sequential packet socket)
118                      6  - DCCP (datagram congestion control protocol socket)
119                      10  -  PACKET  (Linux-specific way of getting packets at
120              device level)
121
122              success
123                  Was send successful?
124
125                  Possible values are:
126                      1 - Yes
127                      0 - No
128
129
130       socket.receive
131
132              Fires at the conclusion of receiving  a  message  on  a  socket.
133              This    probe    alias   includes   the   socket.recvmsg.return,
134              socket.aio_read.return  and  socket.readv.return  probes  (these
135              probes  should  catch  all  messages  received on sockets).  The
136              arguments supplied at the beginning of the  receive  are  cached
137              and made available in this probe.
138
139              Context:
140
141              The message receiver.
142
143              Arguments:
144
145              Same as socket.send.
146
147
148       socket.sendmsg
149
150              Fires when the sock_sendmsg() kernel function is entered.
151
152              Context:
153
154              The message sender.
155
156              Arguments:
157
158              Same as socket.send, with the following exceptions:
159
160              size
161
162                  Size of message being sent (in bytes).
163
164              success
165
166                  Not used.
167
168
169       socket.sendmsg.return
170
171              Fires when the sock_sendmsg() kernel function returns.
172
173              Context:
174
175              The message sender.
176
177              Arguments:
178
179              Same as socket.send
180
181
182       socket.recvmsg
183
184              Fires when the sock_recvmsg() kernel function is entered.
185
186              Context:
187
188              The message receiver.
189
190              Arguments:
191
192              Same as socket.receive, with the following exceptions:
193
194              size
195
196                  Size of message being received (in bytes).
197
198              success
199
200                  Not used.
201
202
203       socket.recvmsg.return
204
205              Fires when the sock_recvmsg() kernel function returns.
206
207              Context:
208
209              The message receiver.
210
211              Arguments:
212
213              Same as socket.receive.
214
215
216
217
218
219
220
221       socket.aio_write
222
223              Fires when the sock_aio_write() kernel function is entered.
224
225              Context:
226
227              The message sender.
228
229              Arguments:
230
231              Same as socket.send, with the following exceptions:
232
233              size
234
235                  Size of message being sent (in bytes).
236
237              success
238
239                  Not used.
240
241
242       socket.aio_write.return
243
244              Fires when the sock_aio_write() kernel function returns.
245
246              Context:
247
248              The message sender.
249
250              Arguments:
251
252              Same as socket.send.
253
254
255       socket.aio_read
256
257              Fires when the sock_aio_read() kernel function is entered.
258
259              Context:
260
261              The message receiver.
262
263              Arguments:
264
265              Same as socket.receive, with the following exceptions:
266
267              size
268
269                  Size of message being received (in bytes).
270
271              success
272
273                  Not used.
274
275
276       socket.aio_read.return
277
278              Fires when the sock_aio_read() kernel function returns.
279
280              Context:
281
282              The message receiver.
283
284              Arguments:
285
286              Same as socket.receive.
287
288
289       socket.writev
290
291              Fires when the sock_writev() kernel function is entered.
292
293              Context:
294
295              The message sender.
296
297              Arguments:
298
299              Same as socket.send, with the following exceptions:
300
301              size
302
303                  Size of message being sent (in bytes).
304
305              success
306
307                  Not used.
308
309
310       socket.writev.return
311
312              Fires when the sock_writev() kernel function returns.
313
314              Context:
315
316              The message sender.
317
318              Arguments:
319
320              Same as socket.send.
321
322
323       socket.readv
324
325              Fires when the sock_readv() kernel function is entered.
326
327              Context:
328
329              The message receiver.
330
331              Arguments:
332
333              Same as socket.receive, with the following exceptions:
334
335              size
336
337                  Size of message being received (in bytes).
338
339              success
340
341                  Not used.
342
343
344       socket.readv.return
345
346              Fires when the sock_readv() kernel function returns.
347
348              Context:
349
350              The message receiver.
351
352              Arguments:
353
354              Same as socket.receive.
355
356
357       socket.create
358
359              Fires at the beginning of creating a socket.
360
361              Context:
362
363              The socket creator.
364
365              Arguments:
366
367              name
368              protocol
369              family
370              type
371                  See socket.send.
372
373              requester
374                  Requester type.
375
376                  Possible values are:
377                      1 - kernel
378                      0 - user
379
380
381       socket.create.return
382
383              Fires at the end of creating a socket.
384
385              Context:
386
387              The socket creator.
388
389              Arguments:
390
391              Same as socket.create, plus:
392
393              err
394                  Return code.
395
396                  Possible values are:
397                      0 - success
398                    < 0 - error
399
400              success
401                  Was the socket created successfully?
402
403                  Possible values are:
404                      1 - Yes
405                      0 - No
406
407       socket.close
408
409              Fires at the beginning of closing a socket.
410
411              Context:
412
413              The socket closer.
414
415              Arguments:
416
417              name
418              protocol
419              family
420              state
421              flags
422              type
423                  See socket.send.
424
425
426       socket.close.return
427
428              Fires at the end of closing a socket.
429
430              Context:
431
432              The socket closer.
433
434              Arguments:
435
436              name
437                  Name of this probe.
438
439

SEE ALSO

441       stap(1), stapprobes(3stap), stapfuncs(3stap)
442
443
444
445IBM                                                      TAPSET::SOCKET(3stap)
Impressum