d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fusefs: rename the SDT probes from "fuse" to "fusefs"

Browse Source 
This matches the new name of the kld.

Sponsored by:	The FreeBSD Foundation
This commit is contained in:
Alan Somers 2019-04-20 00:04:31 +00:00
parent 4423ae76ca
commit 419e7ff674
9 changed files with 94 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
sys/fs/fuse/fuse_device.c
View File

@ -83,13 +83,13 @@ __FBSDID("$FreeBSD$");
#include "fuse.h"
#include "fuse_ipc.h"
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , device, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , device, trace, "int", "char*");
static struct cdev *fuse_dev;
@ -133,14 +133,14 @@ fuse_device_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
struct fuse_data *fdata;
int error;
SDT_PROBE2(fuse, , device, trace, 1, "device open");
SDT_PROBE2(fusefs, , device, trace, 1, "device open");
fdata = fdata_alloc(dev, td->td_ucred);
error = devfs_set_cdevpriv(fdata, fdata_dtor);
if (error != 0)
fdata_trydestroy(fdata);
else
SDT_PROBE2(fuse, , device, trace, 1, "device open success");
SDT_PROBE2(fusefs, , device, trace, 1, "device open success");
return (error);
}
@ -175,7 +175,7 @@ fuse_device_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
fuse_lck_mtx_unlock(data->aw_mtx);
FUSE_UNLOCK();
SDT_PROBE2(fuse, , device, trace, 1, "device close");
SDT_PROBE2(fusefs, , device, trace, 1, "device close");
return (0);
}
@ -219,7 +219,7 @@ fuse_device_read(struct cdev *dev, struct uio *uio, int ioflag)
int buflen[3];
int i;
SDT_PROBE2(fuse, , device, trace, 1, "fuse device read");
SDT_PROBE2(fusefs, , device, trace, 1, "fuse device read");
err = devfs_get_cdevpriv((void **)&data);
if (err != 0)
@ -228,7 +228,7 @@ fuse_device_read(struct cdev *dev, struct uio *uio, int ioflag)
fuse_lck_mtx_lock(data->ms_mtx);
again:
if (fdata_get_dead(data)) {
SDT_PROBE2(fuse, , device, trace, 2,
SDT_PROBE2(fusefs, , device, trace, 2,
"we know early on that reader should be kicked so we "
"don't wait for news");
fuse_lck_mtx_unlock(data->ms_mtx);
@ -256,7 +256,7 @@ again:
* -- and some other cases, too, tho not totally clear, when
* (cv_signal/wakeup_one signals the whole process ?)
*/
SDT_PROBE2(fuse, , device, trace, 1, "no message on thread");
SDT_PROBE2(fusefs, , device, trace, 1, "no message on thread");
goto again;
}
fuse_lck_mtx_unlock(data->ms_mtx);
@ -266,9 +266,10 @@ again:
* somebody somewhere -- eg., umount routine --
* wants this liaison finished off
*/
SDT_PROBE2(fuse, , device, trace, 2, "reader is to be sacked");
SDT_PROBE2(fusefs, , device, trace, 2,
"reader is to be sacked");
if (tick) {
SDT_PROBE2(fuse, , device, trace, 2, "weird -- "
SDT_PROBE2(fusefs, , device, trace, 2, "weird -- "
"\"kick\" is set tho there is message");
FUSE_ASSERT_MS_DONE(tick);
fuse_ticket_drop(tick);
@ -276,7 +277,7 @@ again:
return (ENODEV); /* This should make the daemon get off
* of us */
}
SDT_PROBE2(fuse, , device, trace, 1,
SDT_PROBE2(fusefs, , device, trace, 1,
"fuse device read message successfully");
KASSERT(tick->tk_ms_bufdata || tick->tk_ms_bufsize == 0,
@ -311,7 +312,7 @@ again:
*/
if (uio->uio_resid < buflen[i]) {
fdata_set_dead(data);
SDT_PROBE2(fuse, , device, trace, 2,
SDT_PROBE2(fusefs, , device, trace, 2,
"daemon is stupid, kick it off...");
err = ENODEV;
break;
@ -331,12 +332,13 @@ static inline int
fuse_ohead_audit(struct fuse_out_header *ohead, struct uio *uio)
{
if (uio->uio_resid + sizeof(struct fuse_out_header) != ohead->len) {
SDT_PROBE2(fuse, , device, trace, 1, "Format error: body size "
SDT_PROBE2(fusefs, , device, trace, 1,
"Format error: body size "
"differs from size claimed by header");
return (EINVAL);
}
if (uio->uio_resid && ohead->error) {
SDT_PROBE2(fuse, , device, trace, 1,
SDT_PROBE2(fusefs, , device, trace, 1,
"Format error: non zero error but message had a body");
return (EINVAL);
}
@ -346,8 +348,10 @@ fuse_ohead_audit(struct fuse_out_header *ohead, struct uio *uio)
return (0);
}
SDT_PROBE_DEFINE1(fuse, , device, fuse_device_write_missing_ticket, "uint64_t");
SDT_PROBE_DEFINE1(fuse, , device, fuse_device_write_found, "struct fuse_ticket*");
SDT_PROBE_DEFINE1(fusefs, , device, fuse_device_write_missing_ticket,
"uint64_t");
SDT_PROBE_DEFINE1(fusefs, , device, fuse_device_write_found,
"struct fuse_ticket*");
/*
* fuse_device_write first reads the header sent by the daemon.
* If that's OK, looks up ticket/callback node by the unique id seen in header.
@ -368,7 +372,7 @@ fuse_device_write(struct cdev *dev, struct uio *uio, int ioflag)
return (err);
if (uio->uio_resid < sizeof(struct fuse_out_header)) {
SDT_PROBE2(fuse, , device, trace, 1,
SDT_PROBE2(fusefs, , device, trace, 1,
"fuse_device_write got less than a header!");
fdata_set_dead(data);
return (EINVAL);
@ -394,7 +398,7 @@ fuse_device_write(struct cdev *dev, struct uio *uio, int ioflag)
TAILQ_FOREACH_SAFE(tick, &data->aw_head, tk_aw_link,
x_tick) {
if (tick->tk_unique == ohead.unique) {
SDT_PROBE1(fuse, , device, fuse_device_write_found,
SDT_PROBE1(fusefs, , device, fuse_device_write_found,
tick);
found = 1;
fuse_aw_remove(tick);
@ -427,13 +431,13 @@ fuse_device_write(struct cdev *dev, struct uio *uio, int ioflag)
* via ticket_drop(), so no manual mucking
* around...)
*/
SDT_PROBE2(fuse, , device, trace, 1,
SDT_PROBE2(fusefs, , device, trace, 1,
"pass ticket to a callback");
memcpy(&tick->tk_aw_ohead, &ohead, sizeof(ohead));
err = tick->tk_aw_handler(tick, uio);
} else {
/* pretender doesn't wanna do anything with answer */
SDT_PROBE2(fuse, , device, trace, 1,
SDT_PROBE2(fusefs, , device, trace, 1,
"stuff devalidated, so we drop it");
}
@ -445,7 +449,7 @@ fuse_device_write(struct cdev *dev, struct uio *uio, int ioflag)
fuse_ticket_drop(tick);
} else {
/* no callback at all! */
SDT_PROBE1(fuse, , device, fuse_device_write_missing_ticket,
SDT_PROBE1(fusefs, , device, fuse_device_write_missing_ticket,
ohead.unique);
if (ohead.error == EAGAIN) {
/*

6
sys/fs/fuse/fuse_file.c
View File

@ -85,13 +85,13 @@ __FBSDID("$FreeBSD$");
MALLOC_DEFINE(M_FUSE_FILEHANDLE, "fuse_filefilehandle", "FUSE file handle");
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , file, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , file, trace, "int", "char*");
static int fuse_fh_count = 0;
@ -180,7 +180,7 @@ fuse_filehandle_open(struct vnode *vp, int a_mode,
foi->flags = oflags;
if ((err = fdisp_wait_answ(&fdi))) {
SDT_PROBE2(fuse, , file, trace, 1,
SDT_PROBE2(fusefs, , file, trace, 1,
"OUCH ... daemon didn't give fh");
if (err == ENOENT) {
fuse_internal_vnode_disappear(vp);

6
sys/fs/fuse/fuse_internal.c
View File

@ -93,13 +93,13 @@ __FBSDID("$FreeBSD$");
#include "fuse_node.h"
#include "fuse_file.h"
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , internal, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , internal, trace, "int", "char*");
#ifdef ZERO_PAD_INCOMPLETE_BUFS
static int isbzero(void *buf, size_t len);
@ -683,7 +683,7 @@ fuse_internal_init_callback(struct fuse_ticket *tick, struct uio *uio)
/* XXX: Do we want to check anything further besides this? */
if (fiio->major < 7) {
SDT_PROBE2(fuse, , internal, trace, 1,
SDT_PROBE2(fusefs, , internal, trace, 1,
"userpace version too low");
err = EPROTONOSUPPORT;
goto out;

49
sys/fs/fuse/fuse_io.c
View File

@ -98,13 +98,13 @@ __FBSDID("$FreeBSD$");
#include "fuse_ipc.h"
#include "fuse_io.h"
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , io, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , io, trace, "int", "char*");
static int
fuse_read_directbackend(struct vnode *vp, struct uio *uio,
@ -119,7 +119,7 @@ static int
fuse_write_biobackend(struct vnode *vp, struct uio *uio,
struct ucred *cred, struct fuse_filehandle *fufh, int ioflag, pid_t pid);
SDT_PROBE_DEFINE5(fuse, , io, io_dispatch, "struct vnode*", "struct uio*",
SDT_PROBE_DEFINE5(fusefs, , io, io_dispatch, "struct vnode*", "struct uio*",
"int", "struct ucred*", "struct fuse_filehandle*");
int
fuse_io_dispatch(struct vnode *vp, struct uio *uio, int ioflag,
@ -137,7 +137,7 @@ fuse_io_dispatch(struct vnode *vp, struct uio *uio, int ioflag,
printf("FUSE: io dispatch: filehandles are closed\n");
return err;
}
SDT_PROBE5(fuse, , io, io_dispatch, vp, uio, ioflag, cred, fufh);
SDT_PROBE5(fusefs, , io, io_dispatch, vp, uio, ioflag, cred, fufh);
/*
* Ideally, when the daemon asks for direct io at open time, the
@ -154,11 +154,11 @@ fuse_io_dispatch(struct vnode *vp, struct uio *uio, int ioflag,
switch (uio->uio_rw) {
case UIO_READ:
if (directio) {
SDT_PROBE2(fuse, , io, trace, 1,
SDT_PROBE2(fusefs, , io, trace, 1,
"direct read of vnode");
err = fuse_read_directbackend(vp, uio, cred, fufh);
} else {
SDT_PROBE2(fuse, , io, trace, 1,
SDT_PROBE2(fusefs, , io, trace, 1,
"buffered read of vnode");
err = fuse_read_biobackend(vp, uio, cred, fufh, pid);
}
@ -173,7 +173,7 @@ fuse_io_dispatch(struct vnode *vp, struct uio *uio, int ioflag,
if (directio || fuse_data_cache_mode == FUSE_CACHE_WT) {
off_t start, end;
SDT_PROBE2(fuse, , io, trace, 1,
SDT_PROBE2(fusefs, , io, trace, 1,
"direct write of vnode");
start = uio->uio_offset;
end = start + uio->uio_resid;
@ -181,7 +181,7 @@ fuse_io_dispatch(struct vnode *vp, struct uio *uio, int ioflag,
err = fuse_write_directbackend(vp, uio, cred, fufh,
ioflag);
} else {
SDT_PROBE2(fuse, , io, trace, 1,
SDT_PROBE2(fusefs, , io, trace, 1,
"buffered write of vnode");
err = fuse_write_biobackend(vp, uio, cred, fufh, ioflag,
pid);
@ -194,9 +194,9 @@ fuse_io_dispatch(struct vnode *vp, struct uio *uio, int ioflag,
return (err);
}
SDT_PROBE_DEFINE3(fuse, , io, read_bio_backend_start, "int", "int", "int");
SDT_PROBE_DEFINE2(fuse, , io, read_bio_backend_feed, "int", "int");
SDT_PROBE_DEFINE3(fuse, , io, read_bio_backend_end, "int", "ssize_t", "int");
SDT_PROBE_DEFINE3(fusefs, , io, read_bio_backend_start, "int", "int", "int");
SDT_PROBE_DEFINE2(fusefs, , io, read_bio_backend_feed, "int", "int");
SDT_PROBE_DEFINE3(fusefs, , io, read_bio_backend_end, "int", "ssize_t", "int");
static int
fuse_read_biobackend(struct vnode *vp, struct uio *uio,
struct ucred *cred, struct fuse_filehandle *fufh, pid_t pid)
@ -225,7 +225,7 @@ fuse_read_biobackend(struct vnode *vp, struct uio *uio,
lbn = uio->uio_offset / biosize;
on = uio->uio_offset & (biosize - 1);
SDT_PROBE3(fuse, , io, read_bio_backend_start,
SDT_PROBE3(fusefs, , io, read_bio_backend_start,
biosize, (int)lbn, on);
/*
@ -275,20 +275,21 @@ fuse_read_biobackend(struct vnode *vp, struct uio *uio,
if (on < bcount)
n = MIN((unsigned)(bcount - on), uio->uio_resid);
if (n > 0) {
SDT_PROBE2(fuse, , io, read_bio_backend_feed,
SDT_PROBE2(fusefs, , io, read_bio_backend_feed,
n, n + (int)bp->b_resid);
err = uiomove(bp->b_data + on, n, uio);
}
brelse(bp);
SDT_PROBE3(fuse, , io, read_bio_backend_end, err,
SDT_PROBE3(fusefs, , io, read_bio_backend_end, err,
uio->uio_resid, n);
} while (err == 0 && uio->uio_resid > 0 && n > 0);
return (err);
}
SDT_PROBE_DEFINE1(fuse, , io, read_directbackend_start, "struct fuse_read_in*");
SDT_PROBE_DEFINE2(fuse, , io, read_directbackend_complete,
SDT_PROBE_DEFINE1(fusefs, , io, read_directbackend_start,
"struct fuse_read_in*");
SDT_PROBE_DEFINE2(fusefs, , io, read_directbackend_complete,
"struct fuse_dispatcher*", "struct uio*");
static int
@ -321,12 +322,12 @@ fuse_read_directbackend(struct vnode *vp, struct uio *uio,
fri->size = MIN(uio->uio_resid,
fuse_get_mpdata(vp->v_mount)->max_read);
SDT_PROBE1(fuse, , io, read_directbackend_start, fri);
SDT_PROBE1(fusefs, , io, read_directbackend_start, fri);
if ((err = fdisp_wait_answ(&fdi)))
goto out;
SDT_PROBE2(fuse, , io, read_directbackend_complete,
SDT_PROBE2(fusefs, , io, read_directbackend_complete,
fdi.iosize, uio);
if ((err = uiomove(fdi.answ, MIN(fri->size, fdi.iosize), uio)))
@ -453,9 +454,9 @@ retry:
return (err);
}
SDT_PROBE_DEFINE6(fuse, , io, write_biobackend_start, "int64_t", "int", "int",
SDT_PROBE_DEFINE6(fusefs, , io, write_biobackend_start, "int64_t", "int", "int",
"struct uio*", "int", "bool");
SDT_PROBE_DEFINE2(fuse, , io, write_biobackend_append_race, "long", "int");
SDT_PROBE_DEFINE2(fusefs, , io, write_biobackend_append_race, "long", "int");
static int
fuse_write_biobackend(struct vnode *vp, struct uio *uio,
@ -509,7 +510,7 @@ again:
* readers from reading garbage.
*/
bcount = on;
SDT_PROBE6(fuse, , io, write_biobackend_start,
SDT_PROBE6(fusefs, , io, write_biobackend_start,
lbn, on, n, uio, bcount, true);
bp = getblk(vp, lbn, bcount, PCATCH, 0, 0);
@ -540,7 +541,7 @@ again:
bcount = fvdat->filesize -
(off_t)lbn *biosize;
}
SDT_PROBE6(fuse, , io, write_biobackend_start,
SDT_PROBE6(fusefs, , io, write_biobackend_start,
lbn, on, n, uio, bcount, false);
bp = getblk(vp, lbn, bcount, PCATCH, 0, 0);
if (bp && uio->uio_offset + n > fvdat->filesize) {
@ -603,7 +604,7 @@ again:
*/
if (bp->b_dirtyend > bcount) {
SDT_PROBE2(fuse, , io, write_biobackend_append_race,
SDT_PROBE2(fusefs, , io, write_biobackend_append_race,
(long)bp->b_blkno * biosize,
bp->b_dirtyend - bcount);
bp->b_dirtyend = bcount;
@ -784,7 +785,7 @@ fuse_io_strategy(struct vnode *vp, struct buf *bp)
* If we only need to commit, try to commit
*/
if (bp->b_flags & B_NEEDCOMMIT) {
SDT_PROBE2(fuse, , io, trace, 1,
SDT_PROBE2(fusefs, , io, trace, 1,
"write: B_NEEDCOMMIT flags set");
}
/*

24
sys/fs/fuse/fuse_ipc.c
View File

@ -84,13 +84,13 @@ __FBSDID("$FreeBSD$");
#include "fuse_ipc.h"
#include "fuse_internal.h"
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , ipc, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , ipc, trace, "int", "char*");
static void fdisp_make_pid(struct fuse_dispatcher *fdip, enum fuse_opcode op,
struct fuse_data *data, uint64_t nid, pid_t pid, struct ucred *cred);
@ -454,7 +454,7 @@ retry:
data->daemon_timeout * hz);
kern_sigprocmask(td, SIG_SETMASK, &oldset, NULL, 0);
if (err == EWOULDBLOCK) {
SDT_PROBE2(fuse, , ipc, trace, 3,
SDT_PROBE2(fusefs, , ipc, trace, 3,
"fticket_wait_answer: EWOULDBLOCK");
#ifdef XXXIP /* die conditionally */
if (!fdata_get_dead(data)) {
@ -477,7 +477,7 @@ retry:
*/
int sig;
SDT_PROBE2(fuse, , ipc, trace, 4,
SDT_PROBE2(fusefs, , ipc, trace, 4,
"fticket_wait_answer: interrupt");
fuse_lck_mtx_unlock(ftick->tk_aw_mtx);
fuse_interrupt_send(ftick, err);
@ -500,14 +500,14 @@ retry:
/* Return immediately for fatal signals */
}
} else if (err) {
SDT_PROBE2(fuse, , ipc, trace, 6,
SDT_PROBE2(fusefs, , ipc, trace, 6,
"fticket_wait_answer: other error");
} else {
SDT_PROBE2(fuse, , ipc, trace, 7, "fticket_wait_answer: OK");
SDT_PROBE2(fusefs, , ipc, trace, 7, "fticket_wait_answer: OK");
}
out:
if (!(err || fticket_answered(ftick))) {
SDT_PROBE2(fuse, , ipc, trace, 1,
SDT_PROBE2(fusefs, , ipc, trace, 1,
"FUSE: requester was woken up but still no answer");
err = ENXIO;
}
@ -971,7 +971,7 @@ fdisp_refresh(struct fuse_dispatcher *fdip)
fticket_refresh(fdip->tick);
}
SDT_PROBE_DEFINE2(fuse, , ipc, fdisp_wait_answ_error, "char*", "int");
SDT_PROBE_DEFINE2(fusefs, , ipc, fdisp_wait_answ_error, "char*", "int");
int
fdisp_wait_answ(struct fuse_dispatcher *fdip)
@ -991,7 +991,7 @@ fdisp_wait_answ(struct fuse_dispatcher *fdip)
* the standard handler has completed his job.
* So we drop the ticket and exit as usual.
*/
SDT_PROBE2(fuse, , ipc, fdisp_wait_answ_error,
SDT_PROBE2(fusefs, , ipc, fdisp_wait_answ_error,
"IPC: interrupted, already answered", err);
fuse_lck_mtx_unlock(fdip->tick->tk_aw_mtx);
goto out;
@ -1001,7 +1001,7 @@ fdisp_wait_answ(struct fuse_dispatcher *fdip)
* Then by setting the answered flag we get *him*
* to drop the ticket.
*/
SDT_PROBE2(fuse, , ipc, fdisp_wait_answ_error,
SDT_PROBE2(fusefs, , ipc, fdisp_wait_answ_error,
"IPC: interrupted, setting to answered", err);
fticket_set_answered(fdip->tick);
fuse_lck_mtx_unlock(fdip->tick->tk_aw_mtx);
@ -1010,13 +1010,13 @@ fdisp_wait_answ(struct fuse_dispatcher *fdip)
}
if (fdip->tick->tk_aw_errno) {
SDT_PROBE2(fuse, , ipc, fdisp_wait_answ_error,
SDT_PROBE2(fusefs, , ipc, fdisp_wait_answ_error,
"IPC: explicit EIO-ing", fdip->tick->tk_aw_errno);
err = EIO;
goto out;
}
if ((err = fdip->tick->tk_aw_ohead.error)) {
SDT_PROBE2(fuse, , ipc, fdisp_wait_answ_error,
SDT_PROBE2(fusefs, , ipc, fdisp_wait_answ_error,
"IPC: setting status", fdip->tick->tk_aw_ohead.error);
/*
* This means a "proper" fuse syscall error.

2
sys/fs/fuse/fuse_main.c
View File

@ -100,7 +100,7 @@ SYSCTL_INT(_vfs_fusefs, OID_AUTO, kernelabi_major, CTLFLAG_RD,
SYSCTL_NULL_INT_PTR, FUSE_KERNEL_VERSION, "FUSE kernel abi major version");
SYSCTL_INT(_vfs_fusefs, OID_AUTO, kernelabi_minor, CTLFLAG_RD,
SYSCTL_NULL_INT_PTR, FUSE_KERNEL_MINOR_VERSION, "FUSE kernel abi minor version");
SDT_PROVIDER_DEFINE(fuse);
SDT_PROVIDER_DEFINE(fusefs);
/******************************
*

8
sys/fs/fuse/fuse_node.c
View File

@ -90,13 +90,13 @@ __FBSDID("$FreeBSD$");
#include "fuse_io.h"
#include "fuse_ipc.h"
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , node, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , node, trace, "int", "char*");
MALLOC_DEFINE(M_FUSEVN, "fuse_vnode", "fuse vnode private data");
@ -244,7 +244,7 @@ fuse_vnode_alloc(struct mount *mp,
return (EAGAIN);
}
MPASS((*vpp)->v_data != NULL);
SDT_PROBE2(fuse, , node, trace, 1, "vnode taken from hash");
SDT_PROBE2(fusefs, , node, trace, 1, "vnode taken from hash");
return (0);
}
fvdat = malloc(sizeof(*fvdat), M_FUSEVN, M_WAITOK | M_ZERO);
@ -409,7 +409,7 @@ fuse_vnode_refreshsize(struct vnode *vp, struct ucred *cred)
return 0;
err = VOP_GETATTR(vp, &va, cred);
SDT_PROBE2(fuse, , node, trace, 1, "refreshed file size");
SDT_PROBE2(fusefs, , node, trace, 1, "refreshed file size");
return err;
}

22
sys/fs/fuse/fuse_vfsops.c
View File

@ -88,13 +88,13 @@ __FBSDID("$FreeBSD$");
#include <sys/priv.h>
#include <security/mac/mac_framework.h>
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , vfsops, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , vfsops, trace, "int", "char*");
/* This will do for privilege types for now */
#ifndef PRIV_VFS_FUSE_ALLOWOTHER
@ -207,8 +207,8 @@ fuse_getdevice(const char *fspec, struct thread *td, struct cdev **fdevp)
vfs_flagopt(opts, "__" #fnam, &__mntopts, fval); \
} while (0)
SDT_PROBE_DEFINE1(fuse, , vfsops, mntopts, "uint64_t");
SDT_PROBE_DEFINE4(fuse, , vfsops, mount_err, "char*", "struct fuse_data*",
SDT_PROBE_DEFINE1(fusefs, , vfsops, mntopts, "uint64_t");
SDT_PROBE_DEFINE4(fusefs, , vfsops, mount_err, "char*", "struct fuse_data*",
"struct mount*", "int");
static int
@ -292,11 +292,11 @@ fuse_vfsop_mount(struct mount *mp)
}
subtype = vfs_getopts(opts, "subtype=", &err);
SDT_PROBE1(fuse, , vfsops, mntopts, mntopts);
SDT_PROBE1(fusefs, , vfsops, mntopts, mntopts);
err = fget(td, fd, &cap_read_rights, &fp);
if (err != 0) {
SDT_PROBE2(fuse, , vfsops, trace, 1,
SDT_PROBE2(fusefs, , vfsops, trace, 1,
"invalid or not opened device");
goto out;
}
@ -308,14 +308,14 @@ fuse_vfsop_mount(struct mount *mp)
FUSE_LOCK();
if (err != 0 || data == NULL || data->mp != NULL) {
err = ENXIO;
SDT_PROBE4(fuse, , vfsops, mount_err,
SDT_PROBE4(fusefs, , vfsops, mount_err,
"invalid or not opened device", data, mp, err);
FUSE_UNLOCK();
goto out;
}
if (fdata_get_dead(data)) {
err = ENOTCONN;
SDT_PROBE4(fuse, , vfsops, mount_err,
SDT_PROBE4(fusefs, , vfsops, mount_err,
"device is dead during mount", data, mp, err);
FUSE_UNLOCK();
goto out;
@ -365,7 +365,7 @@ out:
* Destroy device only if we acquired reference to
* it
*/
SDT_PROBE4(fuse, , vfsops, mount_err,
SDT_PROBE4(fusefs, , vfsops, mount_err,
"mount failed, destroy device", data, mp, err);
data->mp = NULL;
fdata_trydestroy(data);
@ -453,13 +453,13 @@ fuse_vfsop_root(struct mount *mp, int lkflags, struct vnode **vpp)
FUSE_LOCK();
MPASS(data->vroot == NULL || data->vroot == *vpp);
if (data->vroot == NULL) {
SDT_PROBE2(fuse, , vfsops, trace, 1,
SDT_PROBE2(fusefs, , vfsops, trace, 1,
"new root vnode");
data->vroot = *vpp;
FUSE_UNLOCK();
vref(*vpp);
} else if (data->vroot != *vpp) {
SDT_PROBE2(fuse, , vfsops, trace, 1,
SDT_PROBE2(fusefs, , vfsops, trace, 1,
"root vnode race");
FUSE_UNLOCK();
VOP_UNLOCK(*vpp, 0);

20
sys/fs/fuse/fuse_vnops.c
View File

@ -109,13 +109,13 @@ __FBSDID("$FreeBSD$");
/* Maximum number of hardlinks to a single FUSE file */
#define FUSE_LINK_MAX UINT32_MAX
SDT_PROVIDER_DECLARE(fuse);
SDT_PROVIDER_DECLARE(fusefs);
/*
* Fuse trace probe:
* arg0: verbosity. Higher numbers give more verbose messages
* arg1: Textual message
*/
SDT_PROBE_DEFINE2(fuse, , vnops, trace, "int", "char*");
SDT_PROBE_DEFINE2(fusefs, , vnops, trace, "int", "char*");
/* vnode ops */
static vop_access_t fuse_vnop_access;
@ -815,7 +815,7 @@ fuse_lookup_alloc(struct mount *mp, void *arg, int lkflags, struct vnode **vpp)
flaa->vtyp);
}
SDT_PROBE_DEFINE3(fuse, , vnops, cache_lookup,
SDT_PROBE_DEFINE3(fusefs, , vnops, cache_lookup,
"int", "struct timespec*", "struct timespec*");
/*
struct vnop_lookup_args {
@ -882,7 +882,7 @@ fuse_vnop_lookup(struct vop_lookup_args *ap)
err = cache_lookup(dvp, vpp, cnp, &timeout, NULL);
getnanouptime(&now);
SDT_PROBE3(fuse, , vnops, cache_lookup, err, &timeout, &now);
SDT_PROBE3(fusefs, , vnops, cache_lookup, err, &timeout, &now);
switch (err) {
case -1: /* positive match */
if (timespeccmp(&timeout, &now, >)) {
@ -1404,7 +1404,7 @@ fuse_vnop_rename(struct vop_rename_args *ap)
}
if (fvp->v_mount != tdvp->v_mount ||
(tvp && fvp->v_mount != tvp->v_mount)) {
SDT_PROBE2(fuse, , vnops, trace, 1, "cross-device rename");
SDT_PROBE2(fusefs, , vnops, trace, 1, "cross-device rename");
err = EXDEV;
goto out;
}
@ -1584,7 +1584,7 @@ fuse_vnop_setattr(struct vop_setattr_args *ap)
if (vnode_vtype(vp) != vtyp) {
if (vnode_vtype(vp) == VNON && vtyp != VNON) {
SDT_PROBE2(fuse, , vnops, trace, 1, "FUSE: Dang! "
SDT_PROBE2(fusefs, , vnops, trace, 1, "FUSE: Dang! "
"vnode_vtype is VNON and vtype isn't.");
} else {
/*
@ -1732,7 +1732,7 @@ fuse_vnop_write(struct vop_write_args *ap)
return fuse_io_dispatch(vp, uio, ioflag, cred, pid);
}
SDT_PROBE_DEFINE1(fuse, , vnops, vnop_getpages_error, "int");
SDT_PROBE_DEFINE1(fusefs, , vnops, vnop_getpages_error, "int");
/*
struct vnop_getpages_args {
struct vnode *a_vp;
@ -1763,7 +1763,7 @@ fuse_vnop_getpages(struct vop_getpages_args *ap)
npages = ap->a_count;
if (!fsess_opt_mmap(vnode_mount(vp))) {
SDT_PROBE2(fuse, , vnops, trace, 1,
SDT_PROBE2(fusefs, , vnops, trace, 1,
"called on non-cacheable vnode??\n");
return (VM_PAGER_ERROR);
}
@ -1809,7 +1809,7 @@ fuse_vnop_getpages(struct vop_getpages_args *ap)
uma_zfree(fuse_pbuf_zone, bp);
if (error && (uio.uio_resid == count)) {
SDT_PROBE1(fuse, , vnops, vnop_getpages_error, error);
SDT_PROBE1(fusefs, , vnops, vnop_getpages_error, error);
return VM_PAGER_ERROR;
}
/*
@ -1900,7 +1900,7 @@ fuse_vnop_putpages(struct vop_putpages_args *ap)
offset = IDX_TO_OFF(pages[0]->pindex);
if (!fsess_opt_mmap(vnode_mount(vp))) {
SDT_PROBE2(fuse, , vnops, trace, 1,
SDT_PROBE2(fusefs, , vnops, trace, 1,
"called on non-cacheable vnode??\n");
}
for (i = 0; i < npages; i++)