id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
150,600 |
ceph/go-ceph
|
rados/ioctx.go
|
ListLockers
|
func (ioctx *IOContext) ListLockers(oid, name string) (*LockInfo, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_tag := (*C.char)(C.malloc(C.size_t(1024)))
c_clients := (*C.char)(C.malloc(C.size_t(1024)))
c_cookies := (*C.char)(C.malloc(C.size_t(1024)))
c_addrs := (*C.char)(C.malloc(C.size_t(1024)))
var c_exclusive C.int
c_tag_len := C.size_t(1024)
c_clients_len := C.size_t(1024)
c_cookies_len := C.size_t(1024)
c_addrs_len := C.size_t(1024)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_tag))
defer C.free(unsafe.Pointer(c_clients))
defer C.free(unsafe.Pointer(c_cookies))
defer C.free(unsafe.Pointer(c_addrs))
ret := C.rados_list_lockers(
ioctx.ioctx,
c_oid,
c_name,
&c_exclusive,
c_tag,
&c_tag_len,
c_clients,
&c_clients_len,
c_cookies,
&c_cookies_len,
c_addrs,
&c_addrs_len)
splitCString := func(items *C.char, itemsLen C.size_t) []string {
currLen := 0
clients := []string{}
for currLen < int(itemsLen) {
client := C.GoString(C.nextChunk(&items))
clients = append(clients, client)
currLen += len(client) + 1
}
return clients
}
if ret < 0 {
return nil, RadosError(int(ret))
} else {
return &LockInfo{int(ret), c_exclusive == 1, C.GoString(c_tag), splitCString(c_clients, c_clients_len), splitCString(c_cookies, c_cookies_len), splitCString(c_addrs, c_addrs_len)}, nil
}
}
|
go
|
func (ioctx *IOContext) ListLockers(oid, name string) (*LockInfo, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_tag := (*C.char)(C.malloc(C.size_t(1024)))
c_clients := (*C.char)(C.malloc(C.size_t(1024)))
c_cookies := (*C.char)(C.malloc(C.size_t(1024)))
c_addrs := (*C.char)(C.malloc(C.size_t(1024)))
var c_exclusive C.int
c_tag_len := C.size_t(1024)
c_clients_len := C.size_t(1024)
c_cookies_len := C.size_t(1024)
c_addrs_len := C.size_t(1024)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_tag))
defer C.free(unsafe.Pointer(c_clients))
defer C.free(unsafe.Pointer(c_cookies))
defer C.free(unsafe.Pointer(c_addrs))
ret := C.rados_list_lockers(
ioctx.ioctx,
c_oid,
c_name,
&c_exclusive,
c_tag,
&c_tag_len,
c_clients,
&c_clients_len,
c_cookies,
&c_cookies_len,
c_addrs,
&c_addrs_len)
splitCString := func(items *C.char, itemsLen C.size_t) []string {
currLen := 0
clients := []string{}
for currLen < int(itemsLen) {
client := C.GoString(C.nextChunk(&items))
clients = append(clients, client)
currLen += len(client) + 1
}
return clients
}
if ret < 0 {
return nil, RadosError(int(ret))
} else {
return &LockInfo{int(ret), c_exclusive == 1, C.GoString(c_tag), splitCString(c_clients, c_clients_len), splitCString(c_cookies, c_cookies_len), splitCString(c_addrs, c_addrs_len)}, nil
}
}
|
[
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"ListLockers",
"(",
"oid",
",",
"name",
"string",
")",
"(",
"*",
"LockInfo",
",",
"error",
")",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n\n",
"c_tag",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n",
"c_clients",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n",
"c_cookies",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n",
"c_addrs",
":=",
"(",
"*",
"C",
".",
"char",
")",
"(",
"C",
".",
"malloc",
"(",
"C",
".",
"size_t",
"(",
"1024",
")",
")",
")",
"\n\n",
"var",
"c_exclusive",
"C",
".",
"int",
"\n",
"c_tag_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n",
"c_clients_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n",
"c_cookies_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n",
"c_addrs_len",
":=",
"C",
".",
"size_t",
"(",
"1024",
")",
"\n\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_oid",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_tag",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_clients",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_cookies",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_addrs",
")",
")",
"\n\n",
"ret",
":=",
"C",
".",
"rados_list_lockers",
"(",
"ioctx",
".",
"ioctx",
",",
"c_oid",
",",
"c_name",
",",
"&",
"c_exclusive",
",",
"c_tag",
",",
"&",
"c_tag_len",
",",
"c_clients",
",",
"&",
"c_clients_len",
",",
"c_cookies",
",",
"&",
"c_cookies_len",
",",
"c_addrs",
",",
"&",
"c_addrs_len",
")",
"\n\n",
"splitCString",
":=",
"func",
"(",
"items",
"*",
"C",
".",
"char",
",",
"itemsLen",
"C",
".",
"size_t",
")",
"[",
"]",
"string",
"{",
"currLen",
":=",
"0",
"\n",
"clients",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"currLen",
"<",
"int",
"(",
"itemsLen",
")",
"{",
"client",
":=",
"C",
".",
"GoString",
"(",
"C",
".",
"nextChunk",
"(",
"&",
"items",
")",
")",
"\n",
"clients",
"=",
"append",
"(",
"clients",
",",
"client",
")",
"\n",
"currLen",
"+=",
"len",
"(",
"client",
")",
"+",
"1",
"\n",
"}",
"\n",
"return",
"clients",
"\n",
"}",
"\n\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"&",
"LockInfo",
"{",
"int",
"(",
"ret",
")",
",",
"c_exclusive",
"==",
"1",
",",
"C",
".",
"GoString",
"(",
"c_tag",
")",
",",
"splitCString",
"(",
"c_clients",
",",
"c_clients_len",
")",
",",
"splitCString",
"(",
"c_cookies",
",",
"c_cookies_len",
")",
",",
"splitCString",
"(",
"c_addrs",
",",
"c_addrs_len",
")",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// List clients that have locked the named object lock and information about the lock.
// The number of bytes required in each buffer is put in the corresponding size out parameter.
// If any of the provided buffers are too short, -ERANGE is returned after these sizes are filled in.
|
[
"List",
"clients",
"that",
"have",
"locked",
"the",
"named",
"object",
"lock",
"and",
"information",
"about",
"the",
"lock",
".",
"The",
"number",
"of",
"bytes",
"required",
"in",
"each",
"buffer",
"is",
"put",
"in",
"the",
"corresponding",
"size",
"out",
"parameter",
".",
"If",
"any",
"of",
"the",
"provided",
"buffers",
"are",
"too",
"short",
"-",
"ERANGE",
"is",
"returned",
"after",
"these",
"sizes",
"are",
"filled",
"in",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L803-L855
|
150,601 |
ceph/go-ceph
|
rados/ioctx.go
|
BreakLock
|
func (ioctx *IOContext) BreakLock(oid, name, client, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_client := C.CString(client)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_client))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
// -EINVAL if the client cannot be parsed
ret := C.rados_break_lock(
ioctx.ioctx,
c_oid,
c_name,
c_client,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
case -C.EINVAL: // -EINVAL
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
}
|
go
|
func (ioctx *IOContext) BreakLock(oid, name, client, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_client := C.CString(client)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_client))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
// -EINVAL if the client cannot be parsed
ret := C.rados_break_lock(
ioctx.ioctx,
c_oid,
c_name,
c_client,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
case -C.EINVAL: // -EINVAL
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
}
|
[
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"BreakLock",
"(",
"oid",
",",
"name",
",",
"client",
",",
"cookie",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"c_client",
":=",
"C",
".",
"CString",
"(",
"client",
")",
"\n",
"c_cookie",
":=",
"C",
".",
"CString",
"(",
"cookie",
")",
"\n\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_oid",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_client",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_cookie",
")",
")",
"\n\n",
"// 0 on success, negative error code on failure",
"// -ENOENT if the lock is not held by the specified (client, cookie) pair",
"// -EINVAL if the client cannot be parsed",
"ret",
":=",
"C",
".",
"rados_break_lock",
"(",
"ioctx",
".",
"ioctx",
",",
"c_oid",
",",
"c_name",
",",
"c_client",
",",
"c_cookie",
")",
"\n\n",
"switch",
"ret",
"{",
"case",
"0",
":",
"return",
"int",
"(",
"ret",
")",
",",
"nil",
"\n",
"case",
"-",
"C",
".",
"ENOENT",
":",
"return",
"int",
"(",
"ret",
")",
",",
"nil",
"\n",
"case",
"-",
"C",
".",
"EINVAL",
":",
"// -EINVAL",
"return",
"int",
"(",
"ret",
")",
",",
"nil",
"\n",
"default",
":",
"return",
"int",
"(",
"ret",
")",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// Releases a shared or exclusive lock on an object, which was taken by the specified client.
|
[
"Releases",
"a",
"shared",
"or",
"exclusive",
"lock",
"on",
"an",
"object",
"which",
"was",
"taken",
"by",
"the",
"specified",
"client",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L858-L890
|
150,602 |
ceph/go-ceph
|
rbd/rbd.go
|
GetTrashList
|
func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
var num_entries C.size_t
// Call rbd_trash_list with nil pointer to get number of trash entries.
if C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), nil, &num_entries); num_entries == 0 {
return nil, nil
}
c_entries := make([]C.rbd_trash_image_info_t, num_entries)
trashList := make([]TrashInfo, num_entries)
if ret := C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), &c_entries[0], &num_entries); ret < 0 {
return nil, RBDError(ret)
}
for i, ti := range c_entries {
trashList[i] = TrashInfo{
Id: C.GoString(ti.id),
Name: C.GoString(ti.name),
DeletionTime: time.Unix(int64(ti.deletion_time), 0),
DefermentEndTime: time.Unix(int64(ti.deferment_end_time), 0),
}
}
// Free rbd_trash_image_info_t pointers
C.rbd_trash_list_cleanup(&c_entries[0], num_entries)
return trashList, nil
}
|
go
|
func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
var num_entries C.size_t
// Call rbd_trash_list with nil pointer to get number of trash entries.
if C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), nil, &num_entries); num_entries == 0 {
return nil, nil
}
c_entries := make([]C.rbd_trash_image_info_t, num_entries)
trashList := make([]TrashInfo, num_entries)
if ret := C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), &c_entries[0], &num_entries); ret < 0 {
return nil, RBDError(ret)
}
for i, ti := range c_entries {
trashList[i] = TrashInfo{
Id: C.GoString(ti.id),
Name: C.GoString(ti.name),
DeletionTime: time.Unix(int64(ti.deletion_time), 0),
DefermentEndTime: time.Unix(int64(ti.deferment_end_time), 0),
}
}
// Free rbd_trash_image_info_t pointers
C.rbd_trash_list_cleanup(&c_entries[0], num_entries)
return trashList, nil
}
|
[
"func",
"GetTrashList",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
")",
"(",
"[",
"]",
"TrashInfo",
",",
"error",
")",
"{",
"var",
"num_entries",
"C",
".",
"size_t",
"\n\n",
"// Call rbd_trash_list with nil pointer to get number of trash entries.",
"if",
"C",
".",
"rbd_trash_list",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"nil",
",",
"&",
"num_entries",
")",
";",
"num_entries",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"c_entries",
":=",
"make",
"(",
"[",
"]",
"C",
".",
"rbd_trash_image_info_t",
",",
"num_entries",
")",
"\n",
"trashList",
":=",
"make",
"(",
"[",
"]",
"TrashInfo",
",",
"num_entries",
")",
"\n\n",
"if",
"ret",
":=",
"C",
".",
"rbd_trash_list",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"&",
"c_entries",
"[",
"0",
"]",
",",
"&",
"num_entries",
")",
";",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"RBDError",
"(",
"ret",
")",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"ti",
":=",
"range",
"c_entries",
"{",
"trashList",
"[",
"i",
"]",
"=",
"TrashInfo",
"{",
"Id",
":",
"C",
".",
"GoString",
"(",
"ti",
".",
"id",
")",
",",
"Name",
":",
"C",
".",
"GoString",
"(",
"ti",
".",
"name",
")",
",",
"DeletionTime",
":",
"time",
".",
"Unix",
"(",
"int64",
"(",
"ti",
".",
"deletion_time",
")",
",",
"0",
")",
",",
"DefermentEndTime",
":",
"time",
".",
"Unix",
"(",
"int64",
"(",
"ti",
".",
"deferment_end_time",
")",
",",
"0",
")",
",",
"}",
"\n",
"}",
"\n\n",
"// Free rbd_trash_image_info_t pointers",
"C",
".",
"rbd_trash_list_cleanup",
"(",
"&",
"c_entries",
"[",
"0",
"]",
",",
"num_entries",
")",
"\n\n",
"return",
"trashList",
",",
"nil",
"\n",
"}"
] |
// GetTrashList returns a slice of TrashInfo structs, containing information about all RBD images
// currently residing in the trash.
|
[
"GetTrashList",
"returns",
"a",
"slice",
"of",
"TrashInfo",
"structs",
"containing",
"information",
"about",
"all",
"RBD",
"images",
"currently",
"residing",
"in",
"the",
"trash",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L944-L972
|
150,603 |
ceph/go-ceph
|
rbd/rbd.go
|
TrashRemove
|
func TrashRemove(ioctx *rados.IOContext, id string, force bool) error {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
return GetError(C.rbd_trash_remove(C.rados_ioctx_t(ioctx.Pointer()), c_id, C.bool(force)))
}
|
go
|
func TrashRemove(ioctx *rados.IOContext, id string, force bool) error {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
return GetError(C.rbd_trash_remove(C.rados_ioctx_t(ioctx.Pointer()), c_id, C.bool(force)))
}
|
[
"func",
"TrashRemove",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
",",
"id",
"string",
",",
"force",
"bool",
")",
"error",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_id",
")",
")",
"\n\n",
"return",
"GetError",
"(",
"C",
".",
"rbd_trash_remove",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"c_id",
",",
"C",
".",
"bool",
"(",
"force",
")",
")",
")",
"\n",
"}"
] |
// TrashRemove permanently deletes the trashed RBD with the specified id.
|
[
"TrashRemove",
"permanently",
"deletes",
"the",
"trashed",
"RBD",
"with",
"the",
"specified",
"id",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L975-L980
|
150,604 |
ceph/go-ceph
|
rbd/rbd.go
|
TrashRestore
|
func TrashRestore(ioctx *rados.IOContext, id, name string) error {
c_id := C.CString(id)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_id))
defer C.free(unsafe.Pointer(c_name))
return GetError(C.rbd_trash_restore(C.rados_ioctx_t(ioctx.Pointer()), c_id, c_name))
}
|
go
|
func TrashRestore(ioctx *rados.IOContext, id, name string) error {
c_id := C.CString(id)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_id))
defer C.free(unsafe.Pointer(c_name))
return GetError(C.rbd_trash_restore(C.rados_ioctx_t(ioctx.Pointer()), c_id, c_name))
}
|
[
"func",
"TrashRestore",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
",",
"id",
",",
"name",
"string",
")",
"error",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_id",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n\n",
"return",
"GetError",
"(",
"C",
".",
"rbd_trash_restore",
"(",
"C",
".",
"rados_ioctx_t",
"(",
"ioctx",
".",
"Pointer",
"(",
")",
")",
",",
"c_id",
",",
"c_name",
")",
")",
"\n",
"}"
] |
// TrashRestore restores the trashed RBD with the specified id back to the pool from whence it
// came, with the specified new name.
|
[
"TrashRestore",
"restores",
"the",
"trashed",
"RBD",
"with",
"the",
"specified",
"id",
"back",
"to",
"the",
"pool",
"from",
"whence",
"it",
"came",
"with",
"the",
"specified",
"new",
"name",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L984-L991
|
150,605 |
ceph/go-ceph
|
rados/rados.go
|
Version
|
func Version() (int, int, int) {
var c_major, c_minor, c_patch C.int
C.rados_version(&c_major, &c_minor, &c_patch)
return int(c_major), int(c_minor), int(c_patch)
}
|
go
|
func Version() (int, int, int) {
var c_major, c_minor, c_patch C.int
C.rados_version(&c_major, &c_minor, &c_patch)
return int(c_major), int(c_minor), int(c_patch)
}
|
[
"func",
"Version",
"(",
")",
"(",
"int",
",",
"int",
",",
"int",
")",
"{",
"var",
"c_major",
",",
"c_minor",
",",
"c_patch",
"C",
".",
"int",
"\n",
"C",
".",
"rados_version",
"(",
"&",
"c_major",
",",
"&",
"c_minor",
",",
"&",
"c_patch",
")",
"\n",
"return",
"int",
"(",
"c_major",
")",
",",
"int",
"(",
"c_minor",
")",
",",
"int",
"(",
"c_patch",
")",
"\n",
"}"
] |
// Version returns the major, minor, and patch components of the version of
// the RADOS library linked against.
|
[
"Version",
"returns",
"the",
"major",
"minor",
"and",
"patch",
"components",
"of",
"the",
"version",
"of",
"the",
"RADOS",
"library",
"linked",
"against",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/rados.go#L34-L38
|
150,606 |
ceph/go-ceph
|
rados/rados.go
|
NewConnWithClusterAndUser
|
func NewConnWithClusterAndUser(clusterName string, userName string) (*Conn, error) {
c_cluster_name := C.CString(clusterName)
defer C.free(unsafe.Pointer(c_cluster_name))
c_name := C.CString(userName)
defer C.free(unsafe.Pointer(c_name))
conn := makeConn()
ret := C.rados_create2(&conn.cluster, c_cluster_name, c_name, 0)
if ret == 0 {
return conn, nil
} else {
return nil, RadosError(int(ret))
}
}
|
go
|
func NewConnWithClusterAndUser(clusterName string, userName string) (*Conn, error) {
c_cluster_name := C.CString(clusterName)
defer C.free(unsafe.Pointer(c_cluster_name))
c_name := C.CString(userName)
defer C.free(unsafe.Pointer(c_name))
conn := makeConn()
ret := C.rados_create2(&conn.cluster, c_cluster_name, c_name, 0)
if ret == 0 {
return conn, nil
} else {
return nil, RadosError(int(ret))
}
}
|
[
"func",
"NewConnWithClusterAndUser",
"(",
"clusterName",
"string",
",",
"userName",
"string",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"c_cluster_name",
":=",
"C",
".",
"CString",
"(",
"clusterName",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_cluster_name",
")",
")",
"\n\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"userName",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n\n",
"conn",
":=",
"makeConn",
"(",
")",
"\n",
"ret",
":=",
"C",
".",
"rados_create2",
"(",
"&",
"conn",
".",
"cluster",
",",
"c_cluster_name",
",",
"c_name",
",",
"0",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"conn",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// NewConnWithClusterAndUser creates a new connection object for a specific cluster and username.
// It returns the connection and an error, if any.
|
[
"NewConnWithClusterAndUser",
"creates",
"a",
"new",
"connection",
"object",
"for",
"a",
"specific",
"cluster",
"and",
"username",
".",
"It",
"returns",
"the",
"connection",
"and",
"an",
"error",
"if",
"any",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/rados.go#L71-L85
|
150,607 |
ceph/go-ceph
|
cephfs/cephfs.go
|
CreateMount
|
func CreateMount() (*MountInfo, error) {
mount := &MountInfo{}
ret := C.ceph_create(&mount.mount, nil)
if ret != 0 {
log.Errorf("CreateMount: Failed to create mount")
return nil, cephError(ret)
}
return mount, nil
}
|
go
|
func CreateMount() (*MountInfo, error) {
mount := &MountInfo{}
ret := C.ceph_create(&mount.mount, nil)
if ret != 0 {
log.Errorf("CreateMount: Failed to create mount")
return nil, cephError(ret)
}
return mount, nil
}
|
[
"func",
"CreateMount",
"(",
")",
"(",
"*",
"MountInfo",
",",
"error",
")",
"{",
"mount",
":=",
"&",
"MountInfo",
"{",
"}",
"\n",
"ret",
":=",
"C",
".",
"ceph_create",
"(",
"&",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
",",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"mount",
",",
"nil",
"\n",
"}"
] |
// CreateMount creates a mount handle for interacting with Ceph.
|
[
"CreateMount",
"creates",
"a",
"mount",
"handle",
"for",
"interacting",
"with",
"Ceph",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L35-L43
|
150,608 |
ceph/go-ceph
|
cephfs/cephfs.go
|
ReadDefaultConfigFile
|
func (mount *MountInfo) ReadDefaultConfigFile() error {
ret := C.ceph_conf_read_file(mount.mount, nil)
if ret != 0 {
log.Errorf("ReadDefaultConfigFile: Failed to read ceph config")
return cephError(ret)
}
return nil
}
|
go
|
func (mount *MountInfo) ReadDefaultConfigFile() error {
ret := C.ceph_conf_read_file(mount.mount, nil)
if ret != 0 {
log.Errorf("ReadDefaultConfigFile: Failed to read ceph config")
return cephError(ret)
}
return nil
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"ReadDefaultConfigFile",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_conf_read_file",
"(",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ReadDefaultConfigFile loads the ceph configuration from the specified config file.
|
[
"ReadDefaultConfigFile",
"loads",
"the",
"ceph",
"configuration",
"from",
"the",
"specified",
"config",
"file",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L46-L53
|
150,609 |
ceph/go-ceph
|
cephfs/cephfs.go
|
Mount
|
func (mount *MountInfo) Mount() error {
ret := C.ceph_mount(mount.mount, nil)
if ret != 0 {
log.Errorf("Mount: Failed to mount")
return cephError(ret)
}
return nil
}
|
go
|
func (mount *MountInfo) Mount() error {
ret := C.ceph_mount(mount.mount, nil)
if ret != 0 {
log.Errorf("Mount: Failed to mount")
return cephError(ret)
}
return nil
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Mount",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_mount",
"(",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Mount mounts the mount handle.
|
[
"Mount",
"mounts",
"the",
"mount",
"handle",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L56-L63
|
150,610 |
ceph/go-ceph
|
cephfs/cephfs.go
|
Unmount
|
func (mount *MountInfo) Unmount() error {
ret := C.ceph_unmount(mount.mount)
if ret != 0 {
log.Errorf("Unmount: Failed to unmount")
return cephError(ret)
}
return nil
}
|
go
|
func (mount *MountInfo) Unmount() error {
ret := C.ceph_unmount(mount.mount)
if ret != 0 {
log.Errorf("Unmount: Failed to unmount")
return cephError(ret)
}
return nil
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Unmount",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_unmount",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Unmount unmounts the mount handle.
|
[
"Unmount",
"unmounts",
"the",
"mount",
"handle",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L66-L73
|
150,611 |
ceph/go-ceph
|
cephfs/cephfs.go
|
Release
|
func (mount *MountInfo) Release() error {
ret := C.ceph_release(mount.mount)
if ret != 0 {
log.Errorf("Release: Failed to release mount")
return cephError(ret)
}
return nil
}
|
go
|
func (mount *MountInfo) Release() error {
ret := C.ceph_release(mount.mount)
if ret != 0 {
log.Errorf("Release: Failed to release mount")
return cephError(ret)
}
return nil
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Release",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_release",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Release destroys the mount handle.
|
[
"Release",
"destroys",
"the",
"mount",
"handle",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L76-L83
|
150,612 |
ceph/go-ceph
|
cephfs/cephfs.go
|
SyncFs
|
func (mount *MountInfo) SyncFs() error {
ret := C.ceph_sync_fs(mount.mount)
if ret != 0 {
log.Errorf("Mount: Failed to sync filesystem")
return cephError(ret)
}
return nil
}
|
go
|
func (mount *MountInfo) SyncFs() error {
ret := C.ceph_sync_fs(mount.mount)
if ret != 0 {
log.Errorf("Mount: Failed to sync filesystem")
return cephError(ret)
}
return nil
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"SyncFs",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_sync_fs",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SyncFs synchronizes all filesystem data to persistent media.
|
[
"SyncFs",
"synchronizes",
"all",
"filesystem",
"data",
"to",
"persistent",
"media",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L86-L93
|
150,613 |
ceph/go-ceph
|
cephfs/cephfs.go
|
CurrentDir
|
func (mount *MountInfo) CurrentDir() string {
cDir := C.ceph_getcwd(mount.mount)
return C.GoString(cDir)
}
|
go
|
func (mount *MountInfo) CurrentDir() string {
cDir := C.ceph_getcwd(mount.mount)
return C.GoString(cDir)
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"CurrentDir",
"(",
")",
"string",
"{",
"cDir",
":=",
"C",
".",
"ceph_getcwd",
"(",
"mount",
".",
"mount",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"cDir",
")",
"\n",
"}"
] |
// CurrentDir gets the current working directory.
|
[
"CurrentDir",
"gets",
"the",
"current",
"working",
"directory",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L96-L99
|
150,614 |
ceph/go-ceph
|
cephfs/cephfs.go
|
ChangeDir
|
func (mount *MountInfo) ChangeDir(path string) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_chdir(mount.mount, cPath)
if ret != 0 {
log.Errorf("ChangeDir: Failed to change directory")
return cephError(ret)
}
return nil
}
|
go
|
func (mount *MountInfo) ChangeDir(path string) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_chdir(mount.mount, cPath)
if ret != 0 {
log.Errorf("ChangeDir: Failed to change directory")
return cephError(ret)
}
return nil
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"ChangeDir",
"(",
"path",
"string",
")",
"error",
"{",
"cPath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cPath",
")",
")",
"\n\n",
"ret",
":=",
"C",
".",
"ceph_chdir",
"(",
"mount",
".",
"mount",
",",
"cPath",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ChangeDir changes the current working directory.
|
[
"ChangeDir",
"changes",
"the",
"current",
"working",
"directory",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L102-L112
|
150,615 |
ceph/go-ceph
|
cephfs/cephfs.go
|
MakeDir
|
func (mount *MountInfo) MakeDir(path string, mode uint32) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_mkdir(mount.mount, cPath, C.mode_t(mode))
if ret != 0 {
log.Errorf("MakeDir: Failed to make directory %s", path)
return cephError(ret)
}
return nil
}
|
go
|
func (mount *MountInfo) MakeDir(path string, mode uint32) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_mkdir(mount.mount, cPath, C.mode_t(mode))
if ret != 0 {
log.Errorf("MakeDir: Failed to make directory %s", path)
return cephError(ret)
}
return nil
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"MakeDir",
"(",
"path",
"string",
",",
"mode",
"uint32",
")",
"error",
"{",
"cPath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cPath",
")",
")",
"\n\n",
"ret",
":=",
"C",
".",
"ceph_mkdir",
"(",
"mount",
".",
"mount",
",",
"cPath",
",",
"C",
".",
"mode_t",
"(",
"mode",
")",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"return",
"cephError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// MakeDir creates a directory.
|
[
"MakeDir",
"creates",
"a",
"directory",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L115-L125
|
150,616 |
ceph/go-ceph
|
cephfs/cephfs.go
|
IsMounted
|
func (mount *MountInfo) IsMounted() bool {
ret := C.ceph_is_mounted(mount.mount)
return ret == 1
}
|
go
|
func (mount *MountInfo) IsMounted() bool {
ret := C.ceph_is_mounted(mount.mount)
return ret == 1
}
|
[
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"IsMounted",
"(",
")",
"bool",
"{",
"ret",
":=",
"C",
".",
"ceph_is_mounted",
"(",
"mount",
".",
"mount",
")",
"\n",
"return",
"ret",
"==",
"1",
"\n",
"}"
] |
// IsMounted checks mount status.
|
[
"IsMounted",
"checks",
"mount",
"status",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L167-L170
|
150,617 |
ceph/go-ceph
|
rados/conn.go
|
PingMonitor
|
func (c *Conn) PingMonitor(id string) (string, error) {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
var strlen C.size_t
var strout *C.char
ret := C.rados_ping_monitor(c.cluster, c_id, &strout, &strlen)
defer C.rados_buffer_free(strout)
if ret == 0 {
reply := C.GoStringN(strout, (C.int)(strlen))
return reply, nil
} else {
return "", RadosError(int(ret))
}
}
|
go
|
func (c *Conn) PingMonitor(id string) (string, error) {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
var strlen C.size_t
var strout *C.char
ret := C.rados_ping_monitor(c.cluster, c_id, &strout, &strlen)
defer C.rados_buffer_free(strout)
if ret == 0 {
reply := C.GoStringN(strout, (C.int)(strlen))
return reply, nil
} else {
return "", RadosError(int(ret))
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"PingMonitor",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_id",
")",
")",
"\n\n",
"var",
"strlen",
"C",
".",
"size_t",
"\n",
"var",
"strout",
"*",
"C",
".",
"char",
"\n\n",
"ret",
":=",
"C",
".",
"rados_ping_monitor",
"(",
"c",
".",
"cluster",
",",
"c_id",
",",
"&",
"strout",
",",
"&",
"strlen",
")",
"\n",
"defer",
"C",
".",
"rados_buffer_free",
"(",
"strout",
")",
"\n\n",
"if",
"ret",
"==",
"0",
"{",
"reply",
":=",
"C",
".",
"GoStringN",
"(",
"strout",
",",
"(",
"C",
".",
"int",
")",
"(",
"strlen",
")",
")",
"\n",
"return",
"reply",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"\"",
"\"",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// PingMonitor sends a ping to a monitor and returns the reply.
|
[
"PingMonitor",
"sends",
"a",
"ping",
"to",
"a",
"monitor",
"and",
"returns",
"the",
"reply",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L27-L43
|
150,618 |
ceph/go-ceph
|
rados/conn.go
|
Connect
|
func (c *Conn) Connect() error {
ret := C.rados_connect(c.cluster)
if ret != 0 {
return RadosError(int(ret))
}
c.connected = true
return nil
}
|
go
|
func (c *Conn) Connect() error {
ret := C.rados_connect(c.cluster)
if ret != 0 {
return RadosError(int(ret))
}
c.connected = true
return nil
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"Connect",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"rados_connect",
"(",
"c",
".",
"cluster",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"c",
".",
"connected",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Connect establishes a connection to a RADOS cluster. It returns an error,
// if any.
|
[
"Connect",
"establishes",
"a",
"connection",
"to",
"a",
"RADOS",
"cluster",
".",
"It",
"returns",
"an",
"error",
"if",
"any",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L47-L54
|
150,619 |
ceph/go-ceph
|
rados/conn.go
|
Shutdown
|
func (c *Conn) Shutdown() {
if err := c.ensure_connected(); err != nil {
return
}
C.rados_shutdown(c.cluster)
}
|
go
|
func (c *Conn) Shutdown() {
if err := c.ensure_connected(); err != nil {
return
}
C.rados_shutdown(c.cluster)
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"Shutdown",
"(",
")",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"C",
".",
"rados_shutdown",
"(",
"c",
".",
"cluster",
")",
"\n",
"}"
] |
// Shutdown disconnects from the cluster.
|
[
"Shutdown",
"disconnects",
"from",
"the",
"cluster",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L57-L62
|
150,620 |
ceph/go-ceph
|
rados/conn.go
|
ReadConfigFile
|
func (c *Conn) ReadConfigFile(path string) error {
c_path := C.CString(path)
defer C.free(unsafe.Pointer(c_path))
ret := C.rados_conf_read_file(c.cluster, c_path)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
}
|
go
|
func (c *Conn) ReadConfigFile(path string) error {
c_path := C.CString(path)
defer C.free(unsafe.Pointer(c_path))
ret := C.rados_conf_read_file(c.cluster, c_path)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"ReadConfigFile",
"(",
"path",
"string",
")",
"error",
"{",
"c_path",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_path",
")",
")",
"\n",
"ret",
":=",
"C",
".",
"rados_conf_read_file",
"(",
"c",
".",
"cluster",
",",
"c_path",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// ReadConfigFile configures the connection using a Ceph configuration file.
|
[
"ReadConfigFile",
"configures",
"the",
"connection",
"using",
"a",
"Ceph",
"configuration",
"file",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L65-L74
|
150,621 |
ceph/go-ceph
|
rados/conn.go
|
ReadDefaultConfigFile
|
func (c *Conn) ReadDefaultConfigFile() error {
ret := C.rados_conf_read_file(c.cluster, nil)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
}
|
go
|
func (c *Conn) ReadDefaultConfigFile() error {
ret := C.rados_conf_read_file(c.cluster, nil)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"ReadDefaultConfigFile",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"rados_conf_read_file",
"(",
"c",
".",
"cluster",
",",
"nil",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// ReadDefaultConfigFile configures the connection using a Ceph configuration
// file located at default locations.
|
[
"ReadDefaultConfigFile",
"configures",
"the",
"connection",
"using",
"a",
"Ceph",
"configuration",
"file",
"located",
"at",
"default",
"locations",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L78-L85
|
150,622 |
ceph/go-ceph
|
rados/conn.go
|
ListPools
|
func (c *Conn) ListPools() (names []string, err error) {
buf := make([]byte, 4096)
for {
ret := int(C.rados_pool_list(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
if ret < 0 {
return nil, RadosError(int(ret))
}
if ret > len(buf) {
buf = make([]byte, ret)
continue
}
tmp := bytes.SplitAfter(buf[:ret-1], []byte{0})
for _, s := range tmp {
if len(s) > 0 {
name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
names = append(names, name)
}
}
return names, nil
}
}
|
go
|
func (c *Conn) ListPools() (names []string, err error) {
buf := make([]byte, 4096)
for {
ret := int(C.rados_pool_list(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
if ret < 0 {
return nil, RadosError(int(ret))
}
if ret > len(buf) {
buf = make([]byte, ret)
continue
}
tmp := bytes.SplitAfter(buf[:ret-1], []byte{0})
for _, s := range tmp {
if len(s) > 0 {
name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
names = append(names, name)
}
}
return names, nil
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"ListPools",
"(",
")",
"(",
"names",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n",
"for",
"{",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_pool_list",
"(",
"c",
".",
"cluster",
",",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"size_t",
"(",
"len",
"(",
"buf",
")",
")",
")",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"nil",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n\n",
"if",
"ret",
">",
"len",
"(",
"buf",
")",
"{",
"buf",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"ret",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"tmp",
":=",
"bytes",
".",
"SplitAfter",
"(",
"buf",
"[",
":",
"ret",
"-",
"1",
"]",
",",
"[",
"]",
"byte",
"{",
"0",
"}",
")",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"tmp",
"{",
"if",
"len",
"(",
"s",
")",
">",
"0",
"{",
"name",
":=",
"C",
".",
"GoString",
"(",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"s",
"[",
"0",
"]",
")",
")",
")",
"\n",
"names",
"=",
"append",
"(",
"names",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"names",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// ListPools returns the names of all existing pools.
|
[
"ListPools",
"returns",
"the",
"names",
"of",
"all",
"existing",
"pools",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L100-L124
|
150,623 |
ceph/go-ceph
|
rados/conn.go
|
SetConfigOption
|
func (c *Conn) SetConfigOption(option, value string) error {
c_opt, c_val := C.CString(option), C.CString(value)
defer C.free(unsafe.Pointer(c_opt))
defer C.free(unsafe.Pointer(c_val))
ret := C.rados_conf_set(c.cluster, c_opt, c_val)
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
}
|
go
|
func (c *Conn) SetConfigOption(option, value string) error {
c_opt, c_val := C.CString(option), C.CString(value)
defer C.free(unsafe.Pointer(c_opt))
defer C.free(unsafe.Pointer(c_val))
ret := C.rados_conf_set(c.cluster, c_opt, c_val)
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"SetConfigOption",
"(",
"option",
",",
"value",
"string",
")",
"error",
"{",
"c_opt",
",",
"c_val",
":=",
"C",
".",
"CString",
"(",
"option",
")",
",",
"C",
".",
"CString",
"(",
"value",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_opt",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_val",
")",
")",
"\n",
"ret",
":=",
"C",
".",
"rados_conf_set",
"(",
"c",
".",
"cluster",
",",
"c_opt",
",",
"c_val",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetConfigOption sets the value of the configuration option identified by
// the given name.
|
[
"SetConfigOption",
"sets",
"the",
"value",
"of",
"the",
"configuration",
"option",
"identified",
"by",
"the",
"given",
"name",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L128-L138
|
150,624 |
ceph/go-ceph
|
rados/conn.go
|
GetConfigOption
|
func (c *Conn) GetConfigOption(name string) (value string, err error) {
buf := make([]byte, 4096)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_conf_get(c.cluster, c_name,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We
// can handle this case, but we need a reliable way to test for
// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?
if ret == 0 {
value = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return value, nil
} else {
return "", RadosError(ret)
}
}
|
go
|
func (c *Conn) GetConfigOption(name string) (value string, err error) {
buf := make([]byte, 4096)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_conf_get(c.cluster, c_name,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We
// can handle this case, but we need a reliable way to test for
// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?
if ret == 0 {
value = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return value, nil
} else {
return "", RadosError(ret)
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"GetConfigOption",
"(",
"name",
"string",
")",
"(",
"value",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_conf_get",
"(",
"c",
".",
"cluster",
",",
"c_name",
",",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"size_t",
"(",
"len",
"(",
"buf",
")",
")",
")",
")",
"\n",
"// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We",
"// can handle this case, but we need a reliable way to test for",
"// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?",
"if",
"ret",
"==",
"0",
"{",
"value",
"=",
"C",
".",
"GoString",
"(",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
")",
"\n",
"return",
"value",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"\"",
"\"",
",",
"RadosError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"}"
] |
// GetConfigOption returns the value of the Ceph configuration option
// identified by the given name.
|
[
"GetConfigOption",
"returns",
"the",
"value",
"of",
"the",
"Ceph",
"configuration",
"option",
"identified",
"by",
"the",
"given",
"name",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L142-L157
|
150,625 |
ceph/go-ceph
|
rados/conn.go
|
GetClusterStats
|
func (c *Conn) GetClusterStats() (stat ClusterStat, err error) {
if err := c.ensure_connected(); err != nil {
return ClusterStat{}, err
}
c_stat := C.struct_rados_cluster_stat_t{}
ret := C.rados_cluster_stat(c.cluster, &c_stat)
if ret < 0 {
return ClusterStat{}, RadosError(int(ret))
} else {
return ClusterStat{
Kb: uint64(c_stat.kb),
Kb_used: uint64(c_stat.kb_used),
Kb_avail: uint64(c_stat.kb_avail),
Num_objects: uint64(c_stat.num_objects),
}, nil
}
}
|
go
|
func (c *Conn) GetClusterStats() (stat ClusterStat, err error) {
if err := c.ensure_connected(); err != nil {
return ClusterStat{}, err
}
c_stat := C.struct_rados_cluster_stat_t{}
ret := C.rados_cluster_stat(c.cluster, &c_stat)
if ret < 0 {
return ClusterStat{}, RadosError(int(ret))
} else {
return ClusterStat{
Kb: uint64(c_stat.kb),
Kb_used: uint64(c_stat.kb_used),
Kb_avail: uint64(c_stat.kb_avail),
Num_objects: uint64(c_stat.num_objects),
}, nil
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"GetClusterStats",
"(",
")",
"(",
"stat",
"ClusterStat",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ClusterStat",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"c_stat",
":=",
"C",
".",
"struct_rados_cluster_stat_t",
"{",
"}",
"\n",
"ret",
":=",
"C",
".",
"rados_cluster_stat",
"(",
"c",
".",
"cluster",
",",
"&",
"c_stat",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"ClusterStat",
"{",
"}",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"ClusterStat",
"{",
"Kb",
":",
"uint64",
"(",
"c_stat",
".",
"kb",
")",
",",
"Kb_used",
":",
"uint64",
"(",
"c_stat",
".",
"kb_used",
")",
",",
"Kb_avail",
":",
"uint64",
"(",
"c_stat",
".",
"kb_avail",
")",
",",
"Num_objects",
":",
"uint64",
"(",
"c_stat",
".",
"num_objects",
")",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// GetClusterStat returns statistics about the cluster associated with the
// connection.
|
[
"GetClusterStat",
"returns",
"statistics",
"about",
"the",
"cluster",
"associated",
"with",
"the",
"connection",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L180-L196
|
150,626 |
ceph/go-ceph
|
rados/conn.go
|
ParseCmdLineArgs
|
func (c *Conn) ParseCmdLineArgs(args []string) error {
// add an empty element 0 -- Ceph treats the array as the actual contents
// of argv and skips the first element (the executable name)
argc := C.int(len(args) + 1)
argv := make([]*C.char, argc)
// make the first element a string just in case it is ever examined
argv[0] = C.CString("placeholder")
defer C.free(unsafe.Pointer(argv[0]))
for i, arg := range args {
argv[i+1] = C.CString(arg)
defer C.free(unsafe.Pointer(argv[i+1]))
}
ret := C.rados_conf_parse_argv(c.cluster, argc, &argv[0])
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
}
|
go
|
func (c *Conn) ParseCmdLineArgs(args []string) error {
// add an empty element 0 -- Ceph treats the array as the actual contents
// of argv and skips the first element (the executable name)
argc := C.int(len(args) + 1)
argv := make([]*C.char, argc)
// make the first element a string just in case it is ever examined
argv[0] = C.CString("placeholder")
defer C.free(unsafe.Pointer(argv[0]))
for i, arg := range args {
argv[i+1] = C.CString(arg)
defer C.free(unsafe.Pointer(argv[i+1]))
}
ret := C.rados_conf_parse_argv(c.cluster, argc, &argv[0])
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"ParseCmdLineArgs",
"(",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"// add an empty element 0 -- Ceph treats the array as the actual contents",
"// of argv and skips the first element (the executable name)",
"argc",
":=",
"C",
".",
"int",
"(",
"len",
"(",
"args",
")",
"+",
"1",
")",
"\n",
"argv",
":=",
"make",
"(",
"[",
"]",
"*",
"C",
".",
"char",
",",
"argc",
")",
"\n\n",
"// make the first element a string just in case it is ever examined",
"argv",
"[",
"0",
"]",
"=",
"C",
".",
"CString",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"argv",
"[",
"0",
"]",
")",
")",
"\n\n",
"for",
"i",
",",
"arg",
":=",
"range",
"args",
"{",
"argv",
"[",
"i",
"+",
"1",
"]",
"=",
"C",
".",
"CString",
"(",
"arg",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"argv",
"[",
"i",
"+",
"1",
"]",
")",
")",
"\n",
"}",
"\n\n",
"ret",
":=",
"C",
".",
"rados_conf_parse_argv",
"(",
"c",
".",
"cluster",
",",
"argc",
",",
"&",
"argv",
"[",
"0",
"]",
")",
"\n",
"if",
"ret",
"<",
"0",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// ParseCmdLineArgs configures the connection from command line arguments.
|
[
"ParseCmdLineArgs",
"configures",
"the",
"connection",
"from",
"command",
"line",
"arguments",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L199-L220
|
150,627 |
ceph/go-ceph
|
rados/conn.go
|
GetFSID
|
func (c *Conn) GetFSID() (fsid string, err error) {
buf := make([]byte, 37)
ret := int(C.rados_cluster_fsid(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: the success case isn't documented correctly in librados.h
if ret == 36 {
fsid = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return fsid, nil
} else {
return "", RadosError(int(ret))
}
}
|
go
|
func (c *Conn) GetFSID() (fsid string, err error) {
buf := make([]byte, 37)
ret := int(C.rados_cluster_fsid(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: the success case isn't documented correctly in librados.h
if ret == 36 {
fsid = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return fsid, nil
} else {
return "", RadosError(int(ret))
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"GetFSID",
"(",
")",
"(",
"fsid",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"37",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_cluster_fsid",
"(",
"c",
".",
"cluster",
",",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
",",
"C",
".",
"size_t",
"(",
"len",
"(",
"buf",
")",
")",
")",
")",
"\n",
"// FIXME: the success case isn't documented correctly in librados.h",
"if",
"ret",
"==",
"36",
"{",
"fsid",
"=",
"C",
".",
"GoString",
"(",
"(",
"*",
"C",
".",
"char",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
")",
"\n",
"return",
"fsid",
",",
"nil",
"\n",
"}",
"else",
"{",
"return",
"\"",
"\"",
",",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// GetFSID returns the fsid of the cluster as a hexadecimal string. The fsid
// is a unique identifier of an entire Ceph cluster.
|
[
"GetFSID",
"returns",
"the",
"fsid",
"of",
"the",
"cluster",
"as",
"a",
"hexadecimal",
"string",
".",
"The",
"fsid",
"is",
"a",
"unique",
"identifier",
"of",
"an",
"entire",
"Ceph",
"cluster",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L235-L246
|
150,628 |
ceph/go-ceph
|
rados/conn.go
|
MakePool
|
func (c *Conn) MakePool(name string) error {
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_create(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
}
|
go
|
func (c *Conn) MakePool(name string) error {
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_create(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"MakePool",
"(",
"name",
"string",
")",
"error",
"{",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_pool_create",
"(",
"c",
".",
"cluster",
",",
"c_name",
")",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"}"
] |
// MakePool creates a new pool with default settings.
|
[
"MakePool",
"creates",
"a",
"new",
"pool",
"with",
"default",
"settings",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L256-L265
|
150,629 |
ceph/go-ceph
|
rados/conn.go
|
DeletePool
|
func (c *Conn) DeletePool(name string) error {
if err := c.ensure_connected(); err != nil {
fmt.Println("NOT CONNECTED WHOOPS")
return err
}
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_delete(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
}
|
go
|
func (c *Conn) DeletePool(name string) error {
if err := c.ensure_connected(); err != nil {
fmt.Println("NOT CONNECTED WHOOPS")
return err
}
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_delete(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"DeletePool",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_pool_delete",
"(",
"c",
".",
"cluster",
",",
"c_name",
")",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{",
"return",
"RadosError",
"(",
"ret",
")",
"\n",
"}",
"\n",
"}"
] |
// DeletePool deletes a pool and all the data inside the pool.
|
[
"DeletePool",
"deletes",
"a",
"pool",
"and",
"all",
"the",
"data",
"inside",
"the",
"pool",
"."
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L268-L281
|
150,630 |
ceph/go-ceph
|
rados/conn.go
|
MonCommand
|
func (c *Conn) MonCommand(args []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, nil)
}
|
go
|
func (c *Conn) MonCommand(args []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, nil)
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"MonCommand",
"(",
"args",
"[",
"]",
"byte",
")",
"(",
"buffer",
"[",
"]",
"byte",
",",
"info",
"string",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"monCommand",
"(",
"args",
",",
"nil",
")",
"\n",
"}"
] |
// MonCommand sends a command to one of the monitors
|
[
"MonCommand",
"sends",
"a",
"command",
"to",
"one",
"of",
"the",
"monitors"
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L284-L286
|
150,631 |
ceph/go-ceph
|
rados/conn.go
|
MonCommandWithInputBuffer
|
func (c *Conn) MonCommandWithInputBuffer(args, inputBuffer []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, inputBuffer)
}
|
go
|
func (c *Conn) MonCommandWithInputBuffer(args, inputBuffer []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, inputBuffer)
}
|
[
"func",
"(",
"c",
"*",
"Conn",
")",
"MonCommandWithInputBuffer",
"(",
"args",
",",
"inputBuffer",
"[",
"]",
"byte",
")",
"(",
"buffer",
"[",
"]",
"byte",
",",
"info",
"string",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"monCommand",
"(",
"args",
",",
"inputBuffer",
")",
"\n",
"}"
] |
// MonCommand sends a command to one of the monitors, with an input buffer
|
[
"MonCommand",
"sends",
"a",
"command",
"to",
"one",
"of",
"the",
"monitors",
"with",
"an",
"input",
"buffer"
] |
e32f9f0f2e941422937c0a6c4f0a61b8f0c82995
|
https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L289-L291
|
150,632 |
Microsoft/go-winio
|
hvsock.go
|
VsockServiceID
|
func VsockServiceID(port uint32) guid.GUID {
g, _ := guid.FromString("00000000-facb-11e6-bd58-64006a7986d3")
g.Data1 = port
return *g
}
|
go
|
func VsockServiceID(port uint32) guid.GUID {
g, _ := guid.FromString("00000000-facb-11e6-bd58-64006a7986d3")
g.Data1 = port
return *g
}
|
[
"func",
"VsockServiceID",
"(",
"port",
"uint32",
")",
"guid",
".",
"GUID",
"{",
"g",
",",
"_",
":=",
"guid",
".",
"FromString",
"(",
"\"",
"\"",
")",
"\n",
"g",
".",
"Data1",
"=",
"port",
"\n",
"return",
"*",
"g",
"\n",
"}"
] |
// VsockServiceID returns an hvsock service ID corresponding to the specified AF_VSOCK port.
|
[
"VsockServiceID",
"returns",
"an",
"hvsock",
"service",
"ID",
"corresponding",
"to",
"the",
"specified",
"AF_VSOCK",
"port",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L46-L50
|
150,633 |
Microsoft/go-winio
|
hvsock.go
|
ListenHvsock
|
func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
l := &HvsockListener{addr: *addr}
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("listen", err)
}
sa := addr.raw()
err = bind(sock.handle, unsafe.Pointer(&sa), int32(unsafe.Sizeof(sa)))
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
}
err = syscall.Listen(sock.handle, 16)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
}
return &HvsockListener{sock: sock, addr: *addr}, nil
}
|
go
|
func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
l := &HvsockListener{addr: *addr}
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("listen", err)
}
sa := addr.raw()
err = bind(sock.handle, unsafe.Pointer(&sa), int32(unsafe.Sizeof(sa)))
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
}
err = syscall.Listen(sock.handle, 16)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
}
return &HvsockListener{sock: sock, addr: *addr}, nil
}
|
[
"func",
"ListenHvsock",
"(",
"addr",
"*",
"HvsockAddr",
")",
"(",
"_",
"*",
"HvsockListener",
",",
"err",
"error",
")",
"{",
"l",
":=",
"&",
"HvsockListener",
"{",
"addr",
":",
"*",
"addr",
"}",
"\n",
"sock",
",",
"err",
":=",
"newHvSocket",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"sa",
":=",
"addr",
".",
"raw",
"(",
")",
"\n",
"err",
"=",
"bind",
"(",
"sock",
".",
"handle",
",",
"unsafe",
".",
"Pointer",
"(",
"&",
"sa",
")",
",",
"int32",
"(",
"unsafe",
".",
"Sizeof",
"(",
"sa",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"err",
"=",
"syscall",
".",
"Listen",
"(",
"sock",
".",
"handle",
",",
"16",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"&",
"HvsockListener",
"{",
"sock",
":",
"sock",
",",
"addr",
":",
"*",
"addr",
"}",
",",
"nil",
"\n",
"}"
] |
// ListenHvsock listens for connections on the specified hvsock address.
|
[
"ListenHvsock",
"listens",
"for",
"connections",
"on",
"the",
"specified",
"hvsock",
"address",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L92-L108
|
150,634 |
Microsoft/go-winio
|
hvsock.go
|
Accept
|
func (l *HvsockListener) Accept() (_ net.Conn, err error) {
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("accept", err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
c, err := l.sock.prepareIo()
if err != nil {
return nil, l.opErr("accept", err)
}
defer l.sock.wg.Done()
// AcceptEx, per documentation, requires an extra 16 bytes per address.
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
var addrbuf [addrlen * 2]byte
var bytes uint32
err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0, addrlen, addrlen, &bytes, &c.o)
_, err = l.sock.asyncIo(c, nil, bytes, err)
if err != nil {
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
}
conn := &HvsockConn{
sock: sock,
}
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
sock = nil
return conn, nil
}
|
go
|
func (l *HvsockListener) Accept() (_ net.Conn, err error) {
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("accept", err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
c, err := l.sock.prepareIo()
if err != nil {
return nil, l.opErr("accept", err)
}
defer l.sock.wg.Done()
// AcceptEx, per documentation, requires an extra 16 bytes per address.
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
var addrbuf [addrlen * 2]byte
var bytes uint32
err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0, addrlen, addrlen, &bytes, &c.o)
_, err = l.sock.asyncIo(c, nil, bytes, err)
if err != nil {
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
}
conn := &HvsockConn{
sock: sock,
}
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
sock = nil
return conn, nil
}
|
[
"func",
"(",
"l",
"*",
"HvsockListener",
")",
"Accept",
"(",
")",
"(",
"_",
"net",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"sock",
",",
"err",
":=",
"newHvSocket",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"sock",
"!=",
"nil",
"{",
"sock",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"c",
",",
"err",
":=",
"l",
".",
"sock",
".",
"prepareIo",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"l",
".",
"sock",
".",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"// AcceptEx, per documentation, requires an extra 16 bytes per address.",
"const",
"addrlen",
"=",
"uint32",
"(",
"16",
"+",
"unsafe",
".",
"Sizeof",
"(",
"rawHvsockAddr",
"{",
"}",
")",
")",
"\n",
"var",
"addrbuf",
"[",
"addrlen",
"*",
"2",
"]",
"byte",
"\n\n",
"var",
"bytes",
"uint32",
"\n",
"err",
"=",
"syscall",
".",
"AcceptEx",
"(",
"l",
".",
"sock",
".",
"handle",
",",
"sock",
".",
"handle",
",",
"&",
"addrbuf",
"[",
"0",
"]",
",",
"0",
",",
"addrlen",
",",
"addrlen",
",",
"&",
"bytes",
",",
"&",
"c",
".",
"o",
")",
"\n",
"_",
",",
"err",
"=",
"l",
".",
"sock",
".",
"asyncIo",
"(",
"c",
",",
"nil",
",",
"bytes",
",",
"err",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".",
"opErr",
"(",
"\"",
"\"",
",",
"os",
".",
"NewSyscallError",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"conn",
":=",
"&",
"HvsockConn",
"{",
"sock",
":",
"sock",
",",
"}",
"\n",
"conn",
".",
"local",
".",
"fromRaw",
"(",
"(",
"*",
"rawHvsockAddr",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"addrbuf",
"[",
"0",
"]",
")",
")",
")",
"\n",
"conn",
".",
"remote",
".",
"fromRaw",
"(",
"(",
"*",
"rawHvsockAddr",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"addrbuf",
"[",
"addrlen",
"]",
")",
")",
")",
"\n",
"sock",
"=",
"nil",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] |
// Accept waits for the next connection and returns it.
|
[
"Accept",
"waits",
"for",
"the",
"next",
"connection",
"and",
"returns",
"it",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L120-L153
|
150,635 |
Microsoft/go-winio
|
hvsock.go
|
CloseRead
|
func (conn *HvsockConn) CloseRead() error {
err := conn.shutdown(syscall.SHUT_RD)
if err != nil {
return conn.opErr("close", err)
}
return nil
}
|
go
|
func (conn *HvsockConn) CloseRead() error {
err := conn.shutdown(syscall.SHUT_RD)
if err != nil {
return conn.opErr("close", err)
}
return nil
}
|
[
"func",
"(",
"conn",
"*",
"HvsockConn",
")",
"CloseRead",
"(",
")",
"error",
"{",
"err",
":=",
"conn",
".",
"shutdown",
"(",
"syscall",
".",
"SHUT_RD",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CloseRead shuts down the read end of the socket.
|
[
"CloseRead",
"shuts",
"down",
"the",
"read",
"end",
"of",
"the",
"socket",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L262-L268
|
150,636 |
Microsoft/go-winio
|
hvsock.go
|
CloseWrite
|
func (conn *HvsockConn) CloseWrite() error {
err := conn.shutdown(syscall.SHUT_WR)
if err != nil {
return conn.opErr("close", err)
}
return nil
}
|
go
|
func (conn *HvsockConn) CloseWrite() error {
err := conn.shutdown(syscall.SHUT_WR)
if err != nil {
return conn.opErr("close", err)
}
return nil
}
|
[
"func",
"(",
"conn",
"*",
"HvsockConn",
")",
"CloseWrite",
"(",
")",
"error",
"{",
"err",
":=",
"conn",
".",
"shutdown",
"(",
"syscall",
".",
"SHUT_WR",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
".",
"opErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CloseWrite shuts down the write end of the socket, notifying the other endpoint that
// no more data will be written.
|
[
"CloseWrite",
"shuts",
"down",
"the",
"write",
"end",
"of",
"the",
"socket",
"notifying",
"the",
"other",
"endpoint",
"that",
"no",
"more",
"data",
"will",
"be",
"written",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L272-L278
|
150,637 |
Microsoft/go-winio
|
ea.go
|
DecodeExtendedAttributes
|
func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 {
ea, nb, err := parseEa(b)
if err != nil {
return nil, err
}
eas = append(eas, ea)
b = nb
}
return
}
|
go
|
func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 {
ea, nb, err := parseEa(b)
if err != nil {
return nil, err
}
eas = append(eas, ea)
b = nb
}
return
}
|
[
"func",
"DecodeExtendedAttributes",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"eas",
"[",
"]",
"ExtendedAttribute",
",",
"err",
"error",
")",
"{",
"for",
"len",
"(",
"b",
")",
"!=",
"0",
"{",
"ea",
",",
"nb",
",",
"err",
":=",
"parseEa",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"eas",
"=",
"append",
"(",
"eas",
",",
"ea",
")",
"\n",
"b",
"=",
"nb",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
// buffer retrieved from BackupRead, ZwQueryEaFile, etc.
|
[
"DecodeExtendedAttributes",
"decodes",
"a",
"list",
"of",
"EAs",
"from",
"a",
"FILE_FULL_EA_INFORMATION",
"buffer",
"retrieved",
"from",
"BackupRead",
"ZwQueryEaFile",
"etc",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/ea.go#L60-L71
|
150,638 |
Microsoft/go-winio
|
ea.go
|
EncodeExtendedAttributes
|
func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer
for i := range eas {
last := false
if i == len(eas)-1 {
last = true
}
err := writeEa(&buf, &eas[i], last)
if err != nil {
return nil, err
}
}
return buf.Bytes(), nil
}
|
go
|
func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer
for i := range eas {
last := false
if i == len(eas)-1 {
last = true
}
err := writeEa(&buf, &eas[i], last)
if err != nil {
return nil, err
}
}
return buf.Bytes(), nil
}
|
[
"func",
"EncodeExtendedAttributes",
"(",
"eas",
"[",
"]",
"ExtendedAttribute",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"for",
"i",
":=",
"range",
"eas",
"{",
"last",
":=",
"false",
"\n",
"if",
"i",
"==",
"len",
"(",
"eas",
")",
"-",
"1",
"{",
"last",
"=",
"true",
"\n",
"}",
"\n\n",
"err",
":=",
"writeEa",
"(",
"&",
"buf",
",",
"&",
"eas",
"[",
"i",
"]",
",",
"last",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
// buffer for use with BackupWrite, ZwSetEaFile, etc.
|
[
"EncodeExtendedAttributes",
"encodes",
"a",
"list",
"of",
"EAs",
"into",
"a",
"FILE_FULL_EA_INFORMATION",
"buffer",
"for",
"use",
"with",
"BackupWrite",
"ZwSetEaFile",
"etc",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/ea.go#L123-L137
|
150,639 |
Microsoft/go-winio
|
reparse.go
|
DecodeReparsePoint
|
func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
tag := binary.LittleEndian.Uint32(b[0:4])
return DecodeReparsePointData(tag, b[8:])
}
|
go
|
func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
tag := binary.LittleEndian.Uint32(b[0:4])
return DecodeReparsePointData(tag, b[8:])
}
|
[
"func",
"DecodeReparsePoint",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"*",
"ReparsePoint",
",",
"error",
")",
"{",
"tag",
":=",
"binary",
".",
"LittleEndian",
".",
"Uint32",
"(",
"b",
"[",
"0",
":",
"4",
"]",
")",
"\n",
"return",
"DecodeReparsePointData",
"(",
"tag",
",",
"b",
"[",
"8",
":",
"]",
")",
"\n",
"}"
] |
// DecodeReparsePoint decodes a Win32 REPARSE_DATA_BUFFER structure containing either a symlink
// or a mount point.
|
[
"DecodeReparsePoint",
"decodes",
"a",
"Win32",
"REPARSE_DATA_BUFFER",
"structure",
"containing",
"either",
"a",
"symlink",
"or",
"a",
"mount",
"point",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/reparse.go#L45-L48
|
150,640 |
Microsoft/go-winio
|
reparse.go
|
EncodeReparsePoint
|
func EncodeReparsePoint(rp *ReparsePoint) []byte {
// Generate an NT path and determine if this is a relative path.
var ntTarget string
relative := false
if strings.HasPrefix(rp.Target, `\\?\`) {
ntTarget = `\??\` + rp.Target[4:]
} else if strings.HasPrefix(rp.Target, `\\`) {
ntTarget = `\??\UNC\` + rp.Target[2:]
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
ntTarget = `\??\` + rp.Target
} else {
ntTarget = rp.Target
relative = true
}
// The paths must be NUL-terminated even though they are counted strings.
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
size += len(ntTarget16)*2 + len(target16)*2
tag := uint32(reparseTagMountPoint)
if !rp.IsMountPoint {
tag = reparseTagSymlink
size += 4 // Add room for symlink flags
}
data := reparseDataBuffer{
ReparseTag: tag,
ReparseDataLength: uint16(size),
SubstituteNameOffset: 0,
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
PrintNameOffset: uint16(len(ntTarget16) * 2),
PrintNameLength: uint16((len(target16) - 1) * 2),
}
var b bytes.Buffer
binary.Write(&b, binary.LittleEndian, &data)
if !rp.IsMountPoint {
flags := uint32(0)
if relative {
flags |= 1
}
binary.Write(&b, binary.LittleEndian, flags)
}
binary.Write(&b, binary.LittleEndian, ntTarget16)
binary.Write(&b, binary.LittleEndian, target16)
return b.Bytes()
}
|
go
|
func EncodeReparsePoint(rp *ReparsePoint) []byte {
// Generate an NT path and determine if this is a relative path.
var ntTarget string
relative := false
if strings.HasPrefix(rp.Target, `\\?\`) {
ntTarget = `\??\` + rp.Target[4:]
} else if strings.HasPrefix(rp.Target, `\\`) {
ntTarget = `\??\UNC\` + rp.Target[2:]
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
ntTarget = `\??\` + rp.Target
} else {
ntTarget = rp.Target
relative = true
}
// The paths must be NUL-terminated even though they are counted strings.
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
size += len(ntTarget16)*2 + len(target16)*2
tag := uint32(reparseTagMountPoint)
if !rp.IsMountPoint {
tag = reparseTagSymlink
size += 4 // Add room for symlink flags
}
data := reparseDataBuffer{
ReparseTag: tag,
ReparseDataLength: uint16(size),
SubstituteNameOffset: 0,
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
PrintNameOffset: uint16(len(ntTarget16) * 2),
PrintNameLength: uint16((len(target16) - 1) * 2),
}
var b bytes.Buffer
binary.Write(&b, binary.LittleEndian, &data)
if !rp.IsMountPoint {
flags := uint32(0)
if relative {
flags |= 1
}
binary.Write(&b, binary.LittleEndian, flags)
}
binary.Write(&b, binary.LittleEndian, ntTarget16)
binary.Write(&b, binary.LittleEndian, target16)
return b.Bytes()
}
|
[
"func",
"EncodeReparsePoint",
"(",
"rp",
"*",
"ReparsePoint",
")",
"[",
"]",
"byte",
"{",
"// Generate an NT path and determine if this is a relative path.",
"var",
"ntTarget",
"string",
"\n",
"relative",
":=",
"false",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"rp",
".",
"Target",
",",
"`\\\\?\\`",
")",
"{",
"ntTarget",
"=",
"`\\??\\`",
"+",
"rp",
".",
"Target",
"[",
"4",
":",
"]",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasPrefix",
"(",
"rp",
".",
"Target",
",",
"`\\\\`",
")",
"{",
"ntTarget",
"=",
"`\\??\\UNC\\`",
"+",
"rp",
".",
"Target",
"[",
"2",
":",
"]",
"\n",
"}",
"else",
"if",
"len",
"(",
"rp",
".",
"Target",
")",
">=",
"2",
"&&",
"isDriveLetter",
"(",
"rp",
".",
"Target",
"[",
"0",
"]",
")",
"&&",
"rp",
".",
"Target",
"[",
"1",
"]",
"==",
"':'",
"{",
"ntTarget",
"=",
"`\\??\\`",
"+",
"rp",
".",
"Target",
"\n",
"}",
"else",
"{",
"ntTarget",
"=",
"rp",
".",
"Target",
"\n",
"relative",
"=",
"true",
"\n",
"}",
"\n\n",
"// The paths must be NUL-terminated even though they are counted strings.",
"target16",
":=",
"utf16",
".",
"Encode",
"(",
"[",
"]",
"rune",
"(",
"rp",
".",
"Target",
"+",
"\"",
"\\x00",
"\"",
")",
")",
"\n",
"ntTarget16",
":=",
"utf16",
".",
"Encode",
"(",
"[",
"]",
"rune",
"(",
"ntTarget",
"+",
"\"",
"\\x00",
"\"",
")",
")",
"\n\n",
"size",
":=",
"int",
"(",
"unsafe",
".",
"Sizeof",
"(",
"reparseDataBuffer",
"{",
"}",
")",
")",
"-",
"8",
"\n",
"size",
"+=",
"len",
"(",
"ntTarget16",
")",
"*",
"2",
"+",
"len",
"(",
"target16",
")",
"*",
"2",
"\n\n",
"tag",
":=",
"uint32",
"(",
"reparseTagMountPoint",
")",
"\n",
"if",
"!",
"rp",
".",
"IsMountPoint",
"{",
"tag",
"=",
"reparseTagSymlink",
"\n",
"size",
"+=",
"4",
"// Add room for symlink flags",
"\n",
"}",
"\n\n",
"data",
":=",
"reparseDataBuffer",
"{",
"ReparseTag",
":",
"tag",
",",
"ReparseDataLength",
":",
"uint16",
"(",
"size",
")",
",",
"SubstituteNameOffset",
":",
"0",
",",
"SubstituteNameLength",
":",
"uint16",
"(",
"(",
"len",
"(",
"ntTarget16",
")",
"-",
"1",
")",
"*",
"2",
")",
",",
"PrintNameOffset",
":",
"uint16",
"(",
"len",
"(",
"ntTarget16",
")",
"*",
"2",
")",
",",
"PrintNameLength",
":",
"uint16",
"(",
"(",
"len",
"(",
"target16",
")",
"-",
"1",
")",
"*",
"2",
")",
",",
"}",
"\n\n",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"data",
")",
"\n",
"if",
"!",
"rp",
".",
"IsMountPoint",
"{",
"flags",
":=",
"uint32",
"(",
"0",
")",
"\n",
"if",
"relative",
"{",
"flags",
"|=",
"1",
"\n",
"}",
"\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"flags",
")",
"\n",
"}",
"\n\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"ntTarget16",
")",
"\n",
"binary",
".",
"Write",
"(",
"&",
"b",
",",
"binary",
".",
"LittleEndian",
",",
"target16",
")",
"\n",
"return",
"b",
".",
"Bytes",
"(",
")",
"\n",
"}"
] |
// EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink or
// mount point.
|
[
"EncodeReparsePoint",
"encodes",
"a",
"Win32",
"REPARSE_DATA_BUFFER",
"structure",
"describing",
"a",
"symlink",
"or",
"mount",
"point",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/reparse.go#L78-L128
|
150,641 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
BoolField
|
func BoolField(name string, value bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeBoolean, 0)
bool8 := uint8(0)
if value {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
|
go
|
func BoolField(name string, value bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeBoolean, 0)
bool8 := uint8(0)
if value {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
|
[
"func",
"BoolField",
"(",
"name",
"string",
",",
"value",
"bool",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeBoolean",
",",
"0",
")",
"\n",
"bool8",
":=",
"uint8",
"(",
"0",
")",
"\n",
"if",
"value",
"{",
"bool8",
"=",
"uint8",
"(",
"1",
")",
"\n",
"}",
"\n",
"ed",
".",
"writeUint8",
"(",
"bool8",
")",
"\n",
"}",
"\n",
"}"
] |
// BoolField adds a single bool field to the event.
|
[
"BoolField",
"adds",
"a",
"single",
"bool",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L20-L29
|
150,642 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
BoolArray
|
func BoolArray(name string, values []bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeBoolean, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
bool8 := uint8(0)
if v {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
}
|
go
|
func BoolArray(name string, values []bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeBoolean, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
bool8 := uint8(0)
if v {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
}
|
[
"func",
"BoolArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"bool",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeBoolean",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"bool8",
":=",
"uint8",
"(",
"0",
")",
"\n",
"if",
"v",
"{",
"bool8",
"=",
"uint8",
"(",
"1",
")",
"\n",
"}",
"\n",
"ed",
".",
"writeUint8",
"(",
"bool8",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// BoolArray adds an array of bool to the event.
|
[
"BoolArray",
"adds",
"an",
"array",
"of",
"bool",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L32-L44
|
150,643 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
StringField
|
func StringField(name string, value string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeString(value)
}
}
|
go
|
func StringField(name string, value string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeString(value)
}
}
|
[
"func",
"StringField",
"(",
"name",
"string",
",",
"value",
"string",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeANSIString",
",",
"outTypeUTF8",
",",
"0",
")",
"\n",
"ed",
".",
"writeString",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// StringField adds a single string field to the event.
|
[
"StringField",
"adds",
"a",
"single",
"string",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L47-L52
|
150,644 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
StringArray
|
func StringArray(name string, values []string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeString(v)
}
}
}
|
go
|
func StringArray(name string, values []string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeString(v)
}
}
}
|
[
"func",
"StringArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"string",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeANSIString",
",",
"outTypeUTF8",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeString",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// StringArray adds an array of string to the event.
|
[
"StringArray",
"adds",
"an",
"array",
"of",
"string",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L55-L63
|
150,645 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
IntField
|
func IntField(name string, value int) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Int32Field(name, int32(value))
case 8:
return Int64Field(name, int64(value))
default:
panic("Unsupported int size")
}
}
|
go
|
func IntField(name string, value int) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Int32Field(name, int32(value))
case 8:
return Int64Field(name, int64(value))
default:
panic("Unsupported int size")
}
}
|
[
"func",
"IntField",
"(",
"name",
"string",
",",
"value",
"int",
")",
"FieldOpt",
"{",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"return",
"Int32Field",
"(",
"name",
",",
"int32",
"(",
"value",
")",
")",
"\n",
"case",
"8",
":",
"return",
"Int64Field",
"(",
"name",
",",
"int64",
"(",
"value",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// IntField adds a single int field to the event.
|
[
"IntField",
"adds",
"a",
"single",
"int",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L66-L75
|
150,646 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
IntArray
|
func IntArray(name string, values []int) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, int)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeInt32
writeItem = func(ed *eventData, item int) { ed.writeInt32(int32(item)) }
case 8:
inType = inTypeInt64
writeItem = func(ed *eventData, item int) { ed.writeInt64(int64(item)) }
default:
panic("Unsupported int size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
}
|
go
|
func IntArray(name string, values []int) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, int)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeInt32
writeItem = func(ed *eventData, item int) { ed.writeInt32(int32(item)) }
case 8:
inType = inTypeInt64
writeItem = func(ed *eventData, item int) { ed.writeInt64(int64(item)) }
default:
panic("Unsupported int size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
}
|
[
"func",
"IntArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"int",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"values",
"[",
"0",
"]",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeInt32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"int",
")",
"{",
"ed",
".",
"writeInt32",
"(",
"int32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeInt64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"int",
")",
"{",
"ed",
".",
"writeInt64",
"(",
"int64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"writeItem",
"(",
"ed",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// IntArray adds an array of int to the event.
|
[
"IntArray",
"adds",
"an",
"array",
"of",
"int",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L78-L99
|
150,647 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int8Field
|
func Int8Field(name string, value int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt8, outTypeDefault, 0)
ed.writeInt8(value)
}
}
|
go
|
func Int8Field(name string, value int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt8, outTypeDefault, 0)
ed.writeInt8(value)
}
}
|
[
"func",
"Int8Field",
"(",
"name",
"string",
",",
"value",
"int8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt8",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Int8Field adds a single int8 field to the event.
|
[
"Int8Field",
"adds",
"a",
"single",
"int8",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L102-L107
|
150,648 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int8Array
|
func Int8Array(name string, values []int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt8(v)
}
}
}
|
go
|
func Int8Array(name string, values []int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt8(v)
}
}
}
|
[
"func",
"Int8Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt8",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Int8Array adds an array of int8 to the event.
|
[
"Int8Array",
"adds",
"an",
"array",
"of",
"int8",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L110-L118
|
150,649 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int16Field
|
func Int16Field(name string, value int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt16, outTypeDefault, 0)
ed.writeInt16(value)
}
}
|
go
|
func Int16Field(name string, value int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt16, outTypeDefault, 0)
ed.writeInt16(value)
}
}
|
[
"func",
"Int16Field",
"(",
"name",
"string",
",",
"value",
"int16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt16",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Int16Field adds a single int16 field to the event.
|
[
"Int16Field",
"adds",
"a",
"single",
"int16",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L121-L126
|
150,650 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int16Array
|
func Int16Array(name string, values []int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt16(v)
}
}
}
|
go
|
func Int16Array(name string, values []int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt16(v)
}
}
}
|
[
"func",
"Int16Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt16",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Int16Array adds an array of int16 to the event.
|
[
"Int16Array",
"adds",
"an",
"array",
"of",
"int16",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L129-L137
|
150,651 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int32Field
|
func Int32Field(name string, value int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt32, outTypeDefault, 0)
ed.writeInt32(value)
}
}
|
go
|
func Int32Field(name string, value int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt32, outTypeDefault, 0)
ed.writeInt32(value)
}
}
|
[
"func",
"Int32Field",
"(",
"name",
"string",
",",
"value",
"int32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt32",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Int32Field adds a single int32 field to the event.
|
[
"Int32Field",
"adds",
"a",
"single",
"int32",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L140-L145
|
150,652 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int32Array
|
func Int32Array(name string, values []int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt32(v)
}
}
}
|
go
|
func Int32Array(name string, values []int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt32(v)
}
}
}
|
[
"func",
"Int32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt32",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Int32Array adds an array of int32 to the event.
|
[
"Int32Array",
"adds",
"an",
"array",
"of",
"int32",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L148-L156
|
150,653 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int64Field
|
func Int64Field(name string, value int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt64, outTypeDefault, 0)
ed.writeInt64(value)
}
}
|
go
|
func Int64Field(name string, value int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt64, outTypeDefault, 0)
ed.writeInt64(value)
}
}
|
[
"func",
"Int64Field",
"(",
"name",
"string",
",",
"value",
"int64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeInt64",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Int64Field adds a single int64 field to the event.
|
[
"Int64Field",
"adds",
"a",
"single",
"int64",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L159-L164
|
150,654 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Int64Array
|
func Int64Array(name string, values []int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt64(v)
}
}
}
|
go
|
func Int64Array(name string, values []int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt64(v)
}
}
}
|
[
"func",
"Int64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeInt64",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Int64Array adds an array of int64 to the event.
|
[
"Int64Array",
"adds",
"an",
"array",
"of",
"int64",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L167-L175
|
150,655 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
UintField
|
func UintField(name string, value uint) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Uint32Field(name, uint32(value))
case 8:
return Uint64Field(name, uint64(value))
default:
panic("Unsupported uint size")
}
}
|
go
|
func UintField(name string, value uint) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Uint32Field(name, uint32(value))
case 8:
return Uint64Field(name, uint64(value))
default:
panic("Unsupported uint size")
}
}
|
[
"func",
"UintField",
"(",
"name",
"string",
",",
"value",
"uint",
")",
"FieldOpt",
"{",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"return",
"Uint32Field",
"(",
"name",
",",
"uint32",
"(",
"value",
")",
")",
"\n",
"case",
"8",
":",
"return",
"Uint64Field",
"(",
"name",
",",
"uint64",
"(",
"value",
")",
")",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// UintField adds a single uint field to the event.
|
[
"UintField",
"adds",
"a",
"single",
"uint",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L178-L187
|
150,656 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
UintArray
|
func UintArray(name string, values []uint) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uint)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeUint32
writeItem = func(ed *eventData, item uint) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeUint64
writeItem = func(ed *eventData, item uint) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uint size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
}
|
go
|
func UintArray(name string, values []uint) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uint)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeUint32
writeItem = func(ed *eventData, item uint) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeUint64
writeItem = func(ed *eventData, item uint) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uint size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
}
|
[
"func",
"UintArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uint",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"values",
"[",
"0",
"]",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeUint32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uint",
")",
"{",
"ed",
".",
"writeUint32",
"(",
"uint32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeUint64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uint",
")",
"{",
"ed",
".",
"writeUint64",
"(",
"uint64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"writeItem",
"(",
"ed",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// UintArray adds an array of uint to the event.
|
[
"UintArray",
"adds",
"an",
"array",
"of",
"uint",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L190-L211
|
150,657 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint8Field
|
func Uint8Field(name string, value uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint8(value)
}
}
|
go
|
func Uint8Field(name string, value uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint8(value)
}
}
|
[
"func",
"Uint8Field",
"(",
"name",
"string",
",",
"value",
"uint8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint8",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Uint8Field adds a single uint8 field to the event.
|
[
"Uint8Field",
"adds",
"a",
"single",
"uint8",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L214-L219
|
150,658 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint8Array
|
func Uint8Array(name string, values []uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint8(v)
}
}
}
|
go
|
func Uint8Array(name string, values []uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint8(v)
}
}
}
|
[
"func",
"Uint8Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint8",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Uint8Array adds an array of uint8 to the event.
|
[
"Uint8Array",
"adds",
"an",
"array",
"of",
"uint8",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L222-L230
|
150,659 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint16Field
|
func Uint16Field(name string, value uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(value)
}
}
|
go
|
func Uint16Field(name string, value uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(value)
}
}
|
[
"func",
"Uint16Field",
"(",
"name",
"string",
",",
"value",
"uint16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Uint16Field adds a single uint16 field to the event.
|
[
"Uint16Field",
"adds",
"a",
"single",
"uint16",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L233-L238
|
150,660 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint16Array
|
func Uint16Array(name string, values []uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint16(v)
}
}
}
|
go
|
func Uint16Array(name string, values []uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint16(v)
}
}
}
|
[
"func",
"Uint16Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint16",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint16",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Uint16Array adds an array of uint16 to the event.
|
[
"Uint16Array",
"adds",
"an",
"array",
"of",
"uint16",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L241-L249
|
150,661 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint32Field
|
func Uint32Field(name string, value uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint32(value)
}
}
|
go
|
func Uint32Field(name string, value uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint32(value)
}
}
|
[
"func",
"Uint32Field",
"(",
"name",
"string",
",",
"value",
"uint32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint32",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Uint32Field adds a single uint32 field to the event.
|
[
"Uint32Field",
"adds",
"a",
"single",
"uint32",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L252-L257
|
150,662 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint32Array
|
func Uint32Array(name string, values []uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(v)
}
}
}
|
go
|
func Uint32Array(name string, values []uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(v)
}
}
}
|
[
"func",
"Uint32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint32",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint32",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Uint32Array adds an array of uint32 to the event.
|
[
"Uint32Array",
"adds",
"an",
"array",
"of",
"uint32",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L260-L268
|
150,663 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint64Field
|
func Uint64Field(name string, value uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint64(value)
}
}
|
go
|
func Uint64Field(name string, value uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint64(value)
}
}
|
[
"func",
"Uint64Field",
"(",
"name",
"string",
",",
"value",
"uint64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint64",
"(",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// Uint64Field adds a single uint64 field to the event.
|
[
"Uint64Field",
"adds",
"a",
"single",
"uint64",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L271-L276
|
150,664 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Uint64Array
|
func Uint64Array(name string, values []uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(v)
}
}
}
|
go
|
func Uint64Array(name string, values []uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(v)
}
}
}
|
[
"func",
"Uint64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint64",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint64",
"(",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Uint64Array adds an array of uint64 to the event.
|
[
"Uint64Array",
"adds",
"an",
"array",
"of",
"uint64",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L279-L287
|
150,665 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
UintptrField
|
func UintptrField(name string, value uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(value) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inType, outTypeDefault, 0)
writeItem(ed, value)
}
}
|
go
|
func UintptrField(name string, value uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(value) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inType, outTypeDefault, 0)
writeItem(ed, value)
}
}
|
[
"func",
"UintptrField",
"(",
"name",
"string",
",",
"value",
"uintptr",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uintptr",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeHexInt32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint32",
"(",
"uint32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeHexInt64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint64",
"(",
"uint64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"writeItem",
"(",
"ed",
",",
"value",
")",
"\n",
"}",
"\n",
"}"
] |
// UintptrField adds a single uintptr field to the event.
|
[
"UintptrField",
"adds",
"a",
"single",
"uintptr",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L290-L308
|
150,666 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
UintptrArray
|
func UintptrArray(name string, values []uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
}
|
go
|
func UintptrArray(name string, values []uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
}
|
[
"func",
"UintptrArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uintptr",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uintptr",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"values",
"[",
"0",
"]",
")",
"{",
"case",
"4",
":",
"inType",
"=",
"inTypeHexInt32",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint32",
"(",
"uint32",
"(",
"item",
")",
")",
"}",
"\n",
"case",
"8",
":",
"inType",
"=",
"inTypeHexInt64",
"\n",
"writeItem",
"=",
"func",
"(",
"ed",
"*",
"eventData",
",",
"item",
"uintptr",
")",
"{",
"ed",
".",
"writeUint64",
"(",
"uint64",
"(",
"item",
")",
")",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inType",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"writeItem",
"(",
"ed",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// UintptrArray adds an array of uintptr to the event.
|
[
"UintptrArray",
"adds",
"an",
"array",
"of",
"uintptr",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L311-L332
|
150,667 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Float32Field
|
func Float32Field(name string, value float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint32(math.Float32bits(value))
}
}
|
go
|
func Float32Field(name string, value float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint32(math.Float32bits(value))
}
}
|
[
"func",
"Float32Field",
"(",
"name",
"string",
",",
"value",
"float32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeFloat",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint32",
"(",
"math",
".",
"Float32bits",
"(",
"value",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// Float32Field adds a single float32 field to the event.
|
[
"Float32Field",
"adds",
"a",
"single",
"float32",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L335-L340
|
150,668 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Float32Array
|
func Float32Array(name string, values []float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(math.Float32bits(v))
}
}
}
|
go
|
func Float32Array(name string, values []float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(math.Float32bits(v))
}
}
}
|
[
"func",
"Float32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"float32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeFloat",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint32",
"(",
"math",
".",
"Float32bits",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Float32Array adds an array of float32 to the event.
|
[
"Float32Array",
"adds",
"an",
"array",
"of",
"float32",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L343-L351
|
150,669 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Float64Field
|
func Float64Field(name string, value float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint64(math.Float64bits(value))
}
}
|
go
|
func Float64Field(name string, value float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint64(math.Float64bits(value))
}
}
|
[
"func",
"Float64Field",
"(",
"name",
"string",
",",
"value",
"float64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeDouble",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint64",
"(",
"math",
".",
"Float64bits",
"(",
"value",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// Float64Field adds a single float64 field to the event.
|
[
"Float64Field",
"adds",
"a",
"single",
"float64",
"field",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L354-L359
|
150,670 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Float64Array
|
func Float64Array(name string, values []float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(math.Float64bits(v))
}
}
}
|
go
|
func Float64Array(name string, values []float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(math.Float64bits(v))
}
}
}
|
[
"func",
"Float64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"float64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeDouble",
",",
"outTypeDefault",
",",
"0",
")",
"\n",
"ed",
".",
"writeUint16",
"(",
"uint16",
"(",
"len",
"(",
"values",
")",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"ed",
".",
"writeUint64",
"(",
"math",
".",
"Float64bits",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Float64Array adds an array of float64 to the event.
|
[
"Float64Array",
"adds",
"an",
"array",
"of",
"float64",
"to",
"the",
"event",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L362-L370
|
150,671 |
Microsoft/go-winio
|
pkg/etw/fieldopt.go
|
Struct
|
func Struct(name string, opts ...FieldOpt) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeStruct(name, uint8(len(opts)), 0)
for _, opt := range opts {
opt(em, ed)
}
}
}
|
go
|
func Struct(name string, opts ...FieldOpt) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeStruct(name, uint8(len(opts)), 0)
for _, opt := range opts {
opt(em, ed)
}
}
}
|
[
"func",
"Struct",
"(",
"name",
"string",
",",
"opts",
"...",
"FieldOpt",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeStruct",
"(",
"name",
",",
"uint8",
"(",
"len",
"(",
"opts",
")",
")",
",",
"0",
")",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"em",
",",
"ed",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Struct adds a nested struct to the event, the FieldOpts in the opts argument
// are used to specify the fields of the struct.
|
[
"Struct",
"adds",
"a",
"nested",
"struct",
"to",
"the",
"event",
"the",
"FieldOpts",
"in",
"the",
"opts",
"argument",
"are",
"used",
"to",
"specify",
"the",
"fields",
"of",
"the",
"struct",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L374-L381
|
150,672 |
Microsoft/go-winio
|
backuptar/tar.go
|
BasicInfoHeader
|
func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
hdr := &tar.Header{
Name: filepath.ToSlash(name),
Size: size,
Typeflag: tar.TypeReg,
ModTime: time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
ChangeTime: time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
AccessTime: time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
Winheaders: make(map[string]string),
}
hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
hdr.Mode |= c_ISDIR
hdr.Size = 0
hdr.Typeflag = tar.TypeDir
}
return hdr
}
|
go
|
func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
hdr := &tar.Header{
Name: filepath.ToSlash(name),
Size: size,
Typeflag: tar.TypeReg,
ModTime: time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
ChangeTime: time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
AccessTime: time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
Winheaders: make(map[string]string),
}
hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
hdr.Mode |= c_ISDIR
hdr.Size = 0
hdr.Typeflag = tar.TypeDir
}
return hdr
}
|
[
"func",
"BasicInfoHeader",
"(",
"name",
"string",
",",
"size",
"int64",
",",
"fileInfo",
"*",
"winio",
".",
"FileBasicInfo",
")",
"*",
"tar",
".",
"Header",
"{",
"hdr",
":=",
"&",
"tar",
".",
"Header",
"{",
"Name",
":",
"filepath",
".",
"ToSlash",
"(",
"name",
")",
",",
"Size",
":",
"size",
",",
"Typeflag",
":",
"tar",
".",
"TypeReg",
",",
"ModTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"LastWriteTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"ChangeTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"ChangeTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"AccessTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"LastAccessTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"CreationTime",
":",
"time",
".",
"Unix",
"(",
"0",
",",
"fileInfo",
".",
"CreationTime",
".",
"Nanoseconds",
"(",
")",
")",
",",
"Winheaders",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
"\n",
"hdr",
".",
"Winheaders",
"[",
"hdrFileAttributes",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"fileInfo",
".",
"FileAttributes",
")",
"\n\n",
"if",
"(",
"fileInfo",
".",
"FileAttributes",
"&",
"syscall",
".",
"FILE_ATTRIBUTE_DIRECTORY",
")",
"!=",
"0",
"{",
"hdr",
".",
"Mode",
"|=",
"c_ISDIR",
"\n",
"hdr",
".",
"Size",
"=",
"0",
"\n",
"hdr",
".",
"Typeflag",
"=",
"tar",
".",
"TypeDir",
"\n",
"}",
"\n",
"return",
"hdr",
"\n",
"}"
] |
// BasicInfoHeader creates a tar header from basic file information.
|
[
"BasicInfoHeader",
"creates",
"a",
"tar",
"header",
"from",
"basic",
"file",
"information",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backuptar/tar.go#L87-L106
|
150,673 |
Microsoft/go-winio
|
pipe.go
|
CloseWrite
|
func (f *win32MessageBytePipe) CloseWrite() error {
if f.writeClosed {
return errPipeWriteClosed
}
err := f.win32File.Flush()
if err != nil {
return err
}
_, err = f.win32File.Write(nil)
if err != nil {
return err
}
f.writeClosed = true
return nil
}
|
go
|
func (f *win32MessageBytePipe) CloseWrite() error {
if f.writeClosed {
return errPipeWriteClosed
}
err := f.win32File.Flush()
if err != nil {
return err
}
_, err = f.win32File.Write(nil)
if err != nil {
return err
}
f.writeClosed = true
return nil
}
|
[
"func",
"(",
"f",
"*",
"win32MessageBytePipe",
")",
"CloseWrite",
"(",
")",
"error",
"{",
"if",
"f",
".",
"writeClosed",
"{",
"return",
"errPipeWriteClosed",
"\n",
"}",
"\n",
"err",
":=",
"f",
".",
"win32File",
".",
"Flush",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"f",
".",
"win32File",
".",
"Write",
"(",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"f",
".",
"writeClosed",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CloseWrite closes the write side of a message pipe in byte mode.
|
[
"CloseWrite",
"closes",
"the",
"write",
"side",
"of",
"a",
"message",
"pipe",
"in",
"byte",
"mode",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L125-L139
|
150,674 |
Microsoft/go-winio
|
pipe.go
|
Read
|
func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
if f.readEOF {
return 0, io.EOF
}
n, err := f.win32File.Read(b)
if err == io.EOF {
// If this was the result of a zero-byte read, then
// it is possible that the read was due to a zero-size
// message. Since we are simulating CloseWrite with a
// zero-byte message, ensure that all future Read() calls
// also return EOF.
f.readEOF = true
} else if err == syscall.ERROR_MORE_DATA {
// ERROR_MORE_DATA indicates that the pipe's read mode is message mode
// and the message still has more bytes. Treat this as a success, since
// this package presents all named pipes as byte streams.
err = nil
}
return n, err
}
|
go
|
func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
if f.readEOF {
return 0, io.EOF
}
n, err := f.win32File.Read(b)
if err == io.EOF {
// If this was the result of a zero-byte read, then
// it is possible that the read was due to a zero-size
// message. Since we are simulating CloseWrite with a
// zero-byte message, ensure that all future Read() calls
// also return EOF.
f.readEOF = true
} else if err == syscall.ERROR_MORE_DATA {
// ERROR_MORE_DATA indicates that the pipe's read mode is message mode
// and the message still has more bytes. Treat this as a success, since
// this package presents all named pipes as byte streams.
err = nil
}
return n, err
}
|
[
"func",
"(",
"f",
"*",
"win32MessageBytePipe",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"f",
".",
"readEOF",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"f",
".",
"win32File",
".",
"Read",
"(",
"b",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"// If this was the result of a zero-byte read, then",
"// it is possible that the read was due to a zero-size",
"// message. Since we are simulating CloseWrite with a",
"// zero-byte message, ensure that all future Read() calls",
"// also return EOF.",
"f",
".",
"readEOF",
"=",
"true",
"\n",
"}",
"else",
"if",
"err",
"==",
"syscall",
".",
"ERROR_MORE_DATA",
"{",
"// ERROR_MORE_DATA indicates that the pipe's read mode is message mode",
"// and the message still has more bytes. Treat this as a success, since",
"// this package presents all named pipes as byte streams.",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// Read reads bytes from a message pipe in byte mode. A read of a zero-byte message on a message
// mode pipe will return io.EOF, as will all subsequent reads.
|
[
"Read",
"reads",
"bytes",
"from",
"a",
"message",
"pipe",
"in",
"byte",
"mode",
".",
"A",
"read",
"of",
"a",
"zero",
"-",
"byte",
"message",
"on",
"a",
"message",
"mode",
"pipe",
"will",
"return",
"io",
".",
"EOF",
"as",
"will",
"all",
"subsequent",
"reads",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L155-L174
|
150,675 |
Microsoft/go-winio
|
pipe.go
|
tryDialPipe
|
func tryDialPipe(ctx context.Context, path *string) (syscall.Handle, error) {
for {
select {
case <-ctx.Done():
return syscall.Handle(0), ctx.Err()
default:
h, err := createFile(*path, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_OVERLAPPED|cSECURITY_SQOS_PRESENT|cSECURITY_ANONYMOUS, 0)
if err == nil {
return h, nil
}
if err != cERROR_PIPE_BUSY {
return h, &os.PathError{Err: err, Op: "open", Path: *path}
}
// Wait 10 msec and try again. This is a rather simplistic
// view, as we always try each 10 milliseconds.
time.Sleep(time.Millisecond * 10)
}
}
}
|
go
|
func tryDialPipe(ctx context.Context, path *string) (syscall.Handle, error) {
for {
select {
case <-ctx.Done():
return syscall.Handle(0), ctx.Err()
default:
h, err := createFile(*path, syscall.GENERIC_READ|syscall.GENERIC_WRITE, 0, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_OVERLAPPED|cSECURITY_SQOS_PRESENT|cSECURITY_ANONYMOUS, 0)
if err == nil {
return h, nil
}
if err != cERROR_PIPE_BUSY {
return h, &os.PathError{Err: err, Op: "open", Path: *path}
}
// Wait 10 msec and try again. This is a rather simplistic
// view, as we always try each 10 milliseconds.
time.Sleep(time.Millisecond * 10)
}
}
}
|
[
"func",
"tryDialPipe",
"(",
"ctx",
"context",
".",
"Context",
",",
"path",
"*",
"string",
")",
"(",
"syscall",
".",
"Handle",
",",
"error",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"syscall",
".",
"Handle",
"(",
"0",
")",
",",
"ctx",
".",
"Err",
"(",
")",
"\n",
"default",
":",
"h",
",",
"err",
":=",
"createFile",
"(",
"*",
"path",
",",
"syscall",
".",
"GENERIC_READ",
"|",
"syscall",
".",
"GENERIC_WRITE",
",",
"0",
",",
"nil",
",",
"syscall",
".",
"OPEN_EXISTING",
",",
"syscall",
".",
"FILE_FLAG_OVERLAPPED",
"|",
"cSECURITY_SQOS_PRESENT",
"|",
"cSECURITY_ANONYMOUS",
",",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"h",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"cERROR_PIPE_BUSY",
"{",
"return",
"h",
",",
"&",
"os",
".",
"PathError",
"{",
"Err",
":",
"err",
",",
"Op",
":",
"\"",
"\"",
",",
"Path",
":",
"*",
"path",
"}",
"\n",
"}",
"\n",
"// Wait 10 msec and try again. This is a rather simplistic",
"// view, as we always try each 10 milliseconds.",
"time",
".",
"Sleep",
"(",
"time",
".",
"Millisecond",
"*",
"10",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// tryDialPipe attempts to dial the pipe at `path` until `ctx` cancellation or timeout.
|
[
"tryDialPipe",
"attempts",
"to",
"dial",
"the",
"pipe",
"at",
"path",
"until",
"ctx",
"cancellation",
"or",
"timeout",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L185-L203
|
150,676 |
Microsoft/go-winio
|
pipe.go
|
DialPipeContext
|
func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
var err error
var h syscall.Handle
h, err = tryDialPipe(ctx, &path)
if err != nil {
return nil, err
}
var flags uint32
err = getNamedPipeInfo(h, &flags, nil, nil, nil)
if err != nil {
return nil, err
}
f, err := makeWin32File(h)
if err != nil {
syscall.Close(h)
return nil, err
}
// If the pipe is in message mode, return a message byte pipe, which
// supports CloseWrite().
if flags&cPIPE_TYPE_MESSAGE != 0 {
return &win32MessageBytePipe{
win32Pipe: win32Pipe{win32File: f, path: path},
}, nil
}
return &win32Pipe{win32File: f, path: path}, nil
}
|
go
|
func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
var err error
var h syscall.Handle
h, err = tryDialPipe(ctx, &path)
if err != nil {
return nil, err
}
var flags uint32
err = getNamedPipeInfo(h, &flags, nil, nil, nil)
if err != nil {
return nil, err
}
f, err := makeWin32File(h)
if err != nil {
syscall.Close(h)
return nil, err
}
// If the pipe is in message mode, return a message byte pipe, which
// supports CloseWrite().
if flags&cPIPE_TYPE_MESSAGE != 0 {
return &win32MessageBytePipe{
win32Pipe: win32Pipe{win32File: f, path: path},
}, nil
}
return &win32Pipe{win32File: f, path: path}, nil
}
|
[
"func",
"DialPipeContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"path",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"h",
"syscall",
".",
"Handle",
"\n",
"h",
",",
"err",
"=",
"tryDialPipe",
"(",
"ctx",
",",
"&",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"flags",
"uint32",
"\n",
"err",
"=",
"getNamedPipeInfo",
"(",
"h",
",",
"&",
"flags",
",",
"nil",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"makeWin32File",
"(",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"syscall",
".",
"Close",
"(",
"h",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// If the pipe is in message mode, return a message byte pipe, which",
"// supports CloseWrite().",
"if",
"flags",
"&",
"cPIPE_TYPE_MESSAGE",
"!=",
"0",
"{",
"return",
"&",
"win32MessageBytePipe",
"{",
"win32Pipe",
":",
"win32Pipe",
"{",
"win32File",
":",
"f",
",",
"path",
":",
"path",
"}",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"win32Pipe",
"{",
"win32File",
":",
"f",
",",
"path",
":",
"path",
"}",
",",
"nil",
"\n",
"}"
] |
// DialPipeContext attempts to connect to a named pipe by `path` until `ctx`
// cancellation or timeout.
|
[
"DialPipeContext",
"attempts",
"to",
"connect",
"to",
"a",
"named",
"pipe",
"by",
"path",
"until",
"ctx",
"cancellation",
"or",
"timeout",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pipe.go#L225-L253
|
150,677 |
Microsoft/go-winio
|
backup.go
|
Read
|
func (r *BackupStreamReader) Read(b []byte) (int, error) {
if r.bytesLeft == 0 {
return 0, io.EOF
}
if int64(len(b)) > r.bytesLeft {
b = b[:r.bytesLeft]
}
n, err := r.r.Read(b)
r.bytesLeft -= int64(n)
if err == io.EOF {
err = io.ErrUnexpectedEOF
} else if r.bytesLeft == 0 && err == nil {
err = io.EOF
}
return n, err
}
|
go
|
func (r *BackupStreamReader) Read(b []byte) (int, error) {
if r.bytesLeft == 0 {
return 0, io.EOF
}
if int64(len(b)) > r.bytesLeft {
b = b[:r.bytesLeft]
}
n, err := r.r.Read(b)
r.bytesLeft -= int64(n)
if err == io.EOF {
err = io.ErrUnexpectedEOF
} else if r.bytesLeft == 0 && err == nil {
err = io.EOF
}
return n, err
}
|
[
"func",
"(",
"r",
"*",
"BackupStreamReader",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"r",
".",
"bytesLeft",
"==",
"0",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"if",
"int64",
"(",
"len",
"(",
"b",
")",
")",
">",
"r",
".",
"bytesLeft",
"{",
"b",
"=",
"b",
"[",
":",
"r",
".",
"bytesLeft",
"]",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"r",
".",
"r",
".",
"Read",
"(",
"b",
")",
"\n",
"r",
".",
"bytesLeft",
"-=",
"int64",
"(",
"n",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"err",
"=",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"else",
"if",
"r",
".",
"bytesLeft",
"==",
"0",
"&&",
"err",
"==",
"nil",
"{",
"err",
"=",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// Read reads from the current backup stream.
|
[
"Read",
"reads",
"from",
"the",
"current",
"backup",
"stream",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L116-L131
|
150,678 |
Microsoft/go-winio
|
backup.go
|
Write
|
func (w *BackupStreamWriter) Write(b []byte) (int, error) {
if w.bytesLeft < int64(len(b)) {
return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
}
n, err := w.w.Write(b)
w.bytesLeft -= int64(n)
return n, err
}
|
go
|
func (w *BackupStreamWriter) Write(b []byte) (int, error) {
if w.bytesLeft < int64(len(b)) {
return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
}
n, err := w.w.Write(b)
w.bytesLeft -= int64(n)
return n, err
}
|
[
"func",
"(",
"w",
"*",
"BackupStreamWriter",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"w",
".",
"bytesLeft",
"<",
"int64",
"(",
"len",
"(",
"b",
")",
")",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"int64",
"(",
"len",
"(",
"b",
")",
")",
"-",
"w",
".",
"bytesLeft",
")",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"w",
".",
"w",
".",
"Write",
"(",
"b",
")",
"\n",
"w",
".",
"bytesLeft",
"-=",
"int64",
"(",
"n",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] |
// Write writes to the current backup stream.
|
[
"Write",
"writes",
"to",
"the",
"current",
"backup",
"stream",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L178-L185
|
150,679 |
Microsoft/go-winio
|
backup.go
|
NewBackupFileReader
|
func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
r := &BackupFileReader{f, includeSecurity, 0}
return r
}
|
go
|
func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
r := &BackupFileReader{f, includeSecurity, 0}
return r
}
|
[
"func",
"NewBackupFileReader",
"(",
"f",
"*",
"os",
".",
"File",
",",
"includeSecurity",
"bool",
")",
"*",
"BackupFileReader",
"{",
"r",
":=",
"&",
"BackupFileReader",
"{",
"f",
",",
"includeSecurity",
",",
"0",
"}",
"\n",
"return",
"r",
"\n",
"}"
] |
// NewBackupFileReader returns a new BackupFileReader from a file handle. If includeSecurity is true,
// Read will attempt to read the security descriptor of the file.
|
[
"NewBackupFileReader",
"returns",
"a",
"new",
"BackupFileReader",
"from",
"a",
"file",
"handle",
".",
"If",
"includeSecurity",
"is",
"true",
"Read",
"will",
"attempt",
"to",
"read",
"the",
"security",
"descriptor",
"of",
"the",
"file",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L196-L199
|
150,680 |
Microsoft/go-winio
|
backup.go
|
Close
|
func (r *BackupFileReader) Close() error {
if r.ctx != 0 {
backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
runtime.KeepAlive(r.f)
r.ctx = 0
}
return nil
}
|
go
|
func (r *BackupFileReader) Close() error {
if r.ctx != 0 {
backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
runtime.KeepAlive(r.f)
r.ctx = 0
}
return nil
}
|
[
"func",
"(",
"r",
"*",
"BackupFileReader",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"r",
".",
"ctx",
"!=",
"0",
"{",
"backupRead",
"(",
"syscall",
".",
"Handle",
"(",
"r",
".",
"f",
".",
"Fd",
"(",
")",
")",
",",
"nil",
",",
"nil",
",",
"true",
",",
"false",
",",
"&",
"r",
".",
"ctx",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"r",
".",
"f",
")",
"\n",
"r",
".",
"ctx",
"=",
"0",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close frees Win32 resources associated with the BackupFileReader. It does not close
// the underlying file.
|
[
"Close",
"frees",
"Win32",
"resources",
"associated",
"with",
"the",
"BackupFileReader",
".",
"It",
"does",
"not",
"close",
"the",
"underlying",
"file",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L217-L224
|
150,681 |
Microsoft/go-winio
|
backup.go
|
Write
|
func (w *BackupFileWriter) Write(b []byte) (int, error) {
var bytesWritten uint32
err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
if err != nil {
return 0, &os.PathError{"BackupWrite", w.f.Name(), err}
}
runtime.KeepAlive(w.f)
if int(bytesWritten) != len(b) {
return int(bytesWritten), errors.New("not all bytes could be written")
}
return len(b), nil
}
|
go
|
func (w *BackupFileWriter) Write(b []byte) (int, error) {
var bytesWritten uint32
err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
if err != nil {
return 0, &os.PathError{"BackupWrite", w.f.Name(), err}
}
runtime.KeepAlive(w.f)
if int(bytesWritten) != len(b) {
return int(bytesWritten), errors.New("not all bytes could be written")
}
return len(b), nil
}
|
[
"func",
"(",
"w",
"*",
"BackupFileWriter",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"bytesWritten",
"uint32",
"\n",
"err",
":=",
"backupWrite",
"(",
"syscall",
".",
"Handle",
"(",
"w",
".",
"f",
".",
"Fd",
"(",
")",
")",
",",
"b",
",",
"&",
"bytesWritten",
",",
"false",
",",
"w",
".",
"includeSecurity",
",",
"&",
"w",
".",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"&",
"os",
".",
"PathError",
"{",
"\"",
"\"",
",",
"w",
".",
"f",
".",
"Name",
"(",
")",
",",
"err",
"}",
"\n",
"}",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"w",
".",
"f",
")",
"\n",
"if",
"int",
"(",
"bytesWritten",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"int",
"(",
"bytesWritten",
")",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"len",
"(",
"b",
")",
",",
"nil",
"\n",
"}"
] |
// Write restores a portion of the file using the provided backup stream.
|
[
"Write",
"restores",
"a",
"portion",
"of",
"the",
"file",
"using",
"the",
"provided",
"backup",
"stream",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L241-L252
|
150,682 |
Microsoft/go-winio
|
backup.go
|
Close
|
func (w *BackupFileWriter) Close() error {
if w.ctx != 0 {
backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
runtime.KeepAlive(w.f)
w.ctx = 0
}
return nil
}
|
go
|
func (w *BackupFileWriter) Close() error {
if w.ctx != 0 {
backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
runtime.KeepAlive(w.f)
w.ctx = 0
}
return nil
}
|
[
"func",
"(",
"w",
"*",
"BackupFileWriter",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"w",
".",
"ctx",
"!=",
"0",
"{",
"backupWrite",
"(",
"syscall",
".",
"Handle",
"(",
"w",
".",
"f",
".",
"Fd",
"(",
")",
")",
",",
"nil",
",",
"nil",
",",
"true",
",",
"false",
",",
"&",
"w",
".",
"ctx",
")",
"\n",
"runtime",
".",
"KeepAlive",
"(",
"w",
".",
"f",
")",
"\n",
"w",
".",
"ctx",
"=",
"0",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close frees Win32 resources associated with the BackupFileWriter. It does not
// close the underlying file.
|
[
"Close",
"frees",
"Win32",
"resources",
"associated",
"with",
"the",
"BackupFileWriter",
".",
"It",
"does",
"not",
"close",
"the",
"underlying",
"file",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backup.go#L256-L263
|
150,683 |
Microsoft/go-winio
|
vhd/vhd.go
|
CreateVhdx
|
func CreateVhdx(path string, maxSizeInGb, blockSizeInMb uint32) error {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := createVirtualDiskParameters{
Version: 2,
Version2: createVersion2{
MaximumSize: uint64(maxSizeInGb) * 1024 * 1024 * 1024,
BlockSizeInBytes: blockSizeInMb * 1024 * 1024,
},
}
if err := createVirtualDisk(
&defaultType,
path,
uint32(VirtualDiskAccessNone),
nil,
uint32(createVirtualDiskFlagNone),
0,
¶meters,
nil,
&handle); err != nil {
return err
}
if err := syscall.CloseHandle(handle); err != nil {
return err
}
return nil
}
|
go
|
func CreateVhdx(path string, maxSizeInGb, blockSizeInMb uint32) error {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := createVirtualDiskParameters{
Version: 2,
Version2: createVersion2{
MaximumSize: uint64(maxSizeInGb) * 1024 * 1024 * 1024,
BlockSizeInBytes: blockSizeInMb * 1024 * 1024,
},
}
if err := createVirtualDisk(
&defaultType,
path,
uint32(VirtualDiskAccessNone),
nil,
uint32(createVirtualDiskFlagNone),
0,
¶meters,
nil,
&handle); err != nil {
return err
}
if err := syscall.CloseHandle(handle); err != nil {
return err
}
return nil
}
|
[
"func",
"CreateVhdx",
"(",
"path",
"string",
",",
"maxSizeInGb",
",",
"blockSizeInMb",
"uint32",
")",
"error",
"{",
"var",
"(",
"defaultType",
"virtualStorageType",
"\n",
"handle",
"syscall",
".",
"Handle",
"\n",
")",
"\n\n",
"parameters",
":=",
"createVirtualDiskParameters",
"{",
"Version",
":",
"2",
",",
"Version2",
":",
"createVersion2",
"{",
"MaximumSize",
":",
"uint64",
"(",
"maxSizeInGb",
")",
"*",
"1024",
"*",
"1024",
"*",
"1024",
",",
"BlockSizeInBytes",
":",
"blockSizeInMb",
"*",
"1024",
"*",
"1024",
",",
"}",
",",
"}",
"\n\n",
"if",
"err",
":=",
"createVirtualDisk",
"(",
"&",
"defaultType",
",",
"path",
",",
"uint32",
"(",
"VirtualDiskAccessNone",
")",
",",
"nil",
",",
"uint32",
"(",
"createVirtualDiskFlagNone",
")",
",",
"0",
",",
"&",
"parameters",
",",
"nil",
",",
"&",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"syscall",
".",
"CloseHandle",
"(",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// CreateVhdx will create a simple vhdx file at the given path using default values.
|
[
"CreateVhdx",
"will",
"create",
"a",
"simple",
"vhdx",
"file",
"at",
"the",
"given",
"path",
"using",
"default",
"values",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/vhd/vhd.go#L86-L118
|
150,684 |
Microsoft/go-winio
|
vhd/vhd.go
|
DetachVhd
|
func DetachVhd(path string) error {
handle, err := OpenVirtualDisk(path, VirtualDiskAccessDetach, OpenVirtualDiskFlagNone)
if err != nil {
return err
}
defer syscall.CloseHandle(handle)
return detachVirtualDisk(handle, 0, 0)
}
|
go
|
func DetachVhd(path string) error {
handle, err := OpenVirtualDisk(path, VirtualDiskAccessDetach, OpenVirtualDiskFlagNone)
if err != nil {
return err
}
defer syscall.CloseHandle(handle)
return detachVirtualDisk(handle, 0, 0)
}
|
[
"func",
"DetachVhd",
"(",
"path",
"string",
")",
"error",
"{",
"handle",
",",
"err",
":=",
"OpenVirtualDisk",
"(",
"path",
",",
"VirtualDiskAccessDetach",
",",
"OpenVirtualDiskFlagNone",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"syscall",
".",
"CloseHandle",
"(",
"handle",
")",
"\n",
"return",
"detachVirtualDisk",
"(",
"handle",
",",
"0",
",",
"0",
")",
"\n",
"}"
] |
// DetachVhd detaches a VHD attached at the given path.
|
[
"DetachVhd",
"detaches",
"a",
"VHD",
"attached",
"at",
"the",
"given",
"path",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/vhd/vhd.go#L121-L128
|
150,685 |
Microsoft/go-winio
|
vhd/vhd.go
|
OpenVirtualDisk
|
func OpenVirtualDisk(path string, accessMask VirtualDiskAccessMask, flag VirtualDiskFlag) (syscall.Handle, error) {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := openVirtualDiskParameters{Version: 2}
if err := openVirtualDisk(
&defaultType,
path,
uint32(accessMask),
uint32(flag),
¶meters,
&handle); err != nil {
return 0, err
}
return handle, nil
}
|
go
|
func OpenVirtualDisk(path string, accessMask VirtualDiskAccessMask, flag VirtualDiskFlag) (syscall.Handle, error) {
var (
defaultType virtualStorageType
handle syscall.Handle
)
parameters := openVirtualDiskParameters{Version: 2}
if err := openVirtualDisk(
&defaultType,
path,
uint32(accessMask),
uint32(flag),
¶meters,
&handle); err != nil {
return 0, err
}
return handle, nil
}
|
[
"func",
"OpenVirtualDisk",
"(",
"path",
"string",
",",
"accessMask",
"VirtualDiskAccessMask",
",",
"flag",
"VirtualDiskFlag",
")",
"(",
"syscall",
".",
"Handle",
",",
"error",
")",
"{",
"var",
"(",
"defaultType",
"virtualStorageType",
"\n",
"handle",
"syscall",
".",
"Handle",
"\n",
")",
"\n",
"parameters",
":=",
"openVirtualDiskParameters",
"{",
"Version",
":",
"2",
"}",
"\n",
"if",
"err",
":=",
"openVirtualDisk",
"(",
"&",
"defaultType",
",",
"path",
",",
"uint32",
"(",
"accessMask",
")",
",",
"uint32",
"(",
"flag",
")",
",",
"&",
"parameters",
",",
"&",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"handle",
",",
"nil",
"\n",
"}"
] |
// OpenVirtuaDisk obtains a handle to a VHD opened with supplied access mask and flags.
|
[
"OpenVirtuaDisk",
"obtains",
"a",
"handle",
"to",
"a",
"VHD",
"opened",
"with",
"supplied",
"access",
"mask",
"and",
"flags",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/vhd/vhd.go#L131-L147
|
150,686 |
Microsoft/go-winio
|
pkg/etwlogrus/hook.go
|
NewHook
|
func NewHook(providerName string) (*Hook, error) {
provider, err := etw.NewProvider(providerName, nil)
if err != nil {
return nil, err
}
return &Hook{provider, true}, nil
}
|
go
|
func NewHook(providerName string) (*Hook, error) {
provider, err := etw.NewProvider(providerName, nil)
if err != nil {
return nil, err
}
return &Hook{provider, true}, nil
}
|
[
"func",
"NewHook",
"(",
"providerName",
"string",
")",
"(",
"*",
"Hook",
",",
"error",
")",
"{",
"provider",
",",
"err",
":=",
"etw",
".",
"NewProvider",
"(",
"providerName",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"Hook",
"{",
"provider",
",",
"true",
"}",
",",
"nil",
"\n",
"}"
] |
// NewHook registers a new ETW provider and returns a hook to log from it. The
// provider will be closed when the hook is closed.
|
[
"NewHook",
"registers",
"a",
"new",
"ETW",
"provider",
"and",
"returns",
"a",
"hook",
"to",
"log",
"from",
"it",
".",
"The",
"provider",
"will",
"be",
"closed",
"when",
"the",
"hook",
"is",
"closed",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L16-L23
|
150,687 |
Microsoft/go-winio
|
pkg/etwlogrus/hook.go
|
NewHookFromProvider
|
func NewHookFromProvider(provider *etw.Provider) (*Hook, error) {
return &Hook{provider, false}, nil
}
|
go
|
func NewHookFromProvider(provider *etw.Provider) (*Hook, error) {
return &Hook{provider, false}, nil
}
|
[
"func",
"NewHookFromProvider",
"(",
"provider",
"*",
"etw",
".",
"Provider",
")",
"(",
"*",
"Hook",
",",
"error",
")",
"{",
"return",
"&",
"Hook",
"{",
"provider",
",",
"false",
"}",
",",
"nil",
"\n",
"}"
] |
// NewHookFromProvider creates a new hook based on an existing ETW provider. The
// provider will not be closed when the hook is closed.
|
[
"NewHookFromProvider",
"creates",
"a",
"new",
"hook",
"based",
"on",
"an",
"existing",
"ETW",
"provider",
".",
"The",
"provider",
"will",
"not",
"be",
"closed",
"when",
"the",
"hook",
"is",
"closed",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L27-L29
|
150,688 |
Microsoft/go-winio
|
pkg/etwlogrus/hook.go
|
Levels
|
func (h *Hook) Levels() []logrus.Level {
return []logrus.Level{
logrus.TraceLevel,
logrus.DebugLevel,
logrus.InfoLevel,
logrus.WarnLevel,
logrus.ErrorLevel,
logrus.FatalLevel,
logrus.PanicLevel,
}
}
|
go
|
func (h *Hook) Levels() []logrus.Level {
return []logrus.Level{
logrus.TraceLevel,
logrus.DebugLevel,
logrus.InfoLevel,
logrus.WarnLevel,
logrus.ErrorLevel,
logrus.FatalLevel,
logrus.PanicLevel,
}
}
|
[
"func",
"(",
"h",
"*",
"Hook",
")",
"Levels",
"(",
")",
"[",
"]",
"logrus",
".",
"Level",
"{",
"return",
"[",
"]",
"logrus",
".",
"Level",
"{",
"logrus",
".",
"TraceLevel",
",",
"logrus",
".",
"DebugLevel",
",",
"logrus",
".",
"InfoLevel",
",",
"logrus",
".",
"WarnLevel",
",",
"logrus",
".",
"ErrorLevel",
",",
"logrus",
".",
"FatalLevel",
",",
"logrus",
".",
"PanicLevel",
",",
"}",
"\n",
"}"
] |
// Levels returns the set of levels that this hook wants to receive log entries
// for.
|
[
"Levels",
"returns",
"the",
"set",
"of",
"levels",
"that",
"this",
"hook",
"wants",
"to",
"receive",
"log",
"entries",
"for",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L33-L43
|
150,689 |
Microsoft/go-winio
|
pkg/etwlogrus/hook.go
|
Fire
|
func (h *Hook) Fire(e *logrus.Entry) error {
// Logrus defines more levels than ETW typically uses, but analysis is
// easiest when using a consistent set of levels across ETW providers, so we
// map the Logrus levels to ETW levels.
level := logrusToETWLevelMap[e.Level]
if !h.provider.IsEnabledForLevel(level) {
return nil
}
// Reserve extra space for the message field.
fields := make([]etw.FieldOpt, 0, len(e.Data)+1)
fields = append(fields, etw.StringField("Message", e.Message))
for k, v := range e.Data {
fields = append(fields, etw.SmartField(k, v))
}
return h.provider.WriteEvent(
"LogrusEntry",
etw.WithEventOpts(etw.WithLevel(level)),
fields)
}
|
go
|
func (h *Hook) Fire(e *logrus.Entry) error {
// Logrus defines more levels than ETW typically uses, but analysis is
// easiest when using a consistent set of levels across ETW providers, so we
// map the Logrus levels to ETW levels.
level := logrusToETWLevelMap[e.Level]
if !h.provider.IsEnabledForLevel(level) {
return nil
}
// Reserve extra space for the message field.
fields := make([]etw.FieldOpt, 0, len(e.Data)+1)
fields = append(fields, etw.StringField("Message", e.Message))
for k, v := range e.Data {
fields = append(fields, etw.SmartField(k, v))
}
return h.provider.WriteEvent(
"LogrusEntry",
etw.WithEventOpts(etw.WithLevel(level)),
fields)
}
|
[
"func",
"(",
"h",
"*",
"Hook",
")",
"Fire",
"(",
"e",
"*",
"logrus",
".",
"Entry",
")",
"error",
"{",
"// Logrus defines more levels than ETW typically uses, but analysis is",
"// easiest when using a consistent set of levels across ETW providers, so we",
"// map the Logrus levels to ETW levels.",
"level",
":=",
"logrusToETWLevelMap",
"[",
"e",
".",
"Level",
"]",
"\n",
"if",
"!",
"h",
".",
"provider",
".",
"IsEnabledForLevel",
"(",
"level",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Reserve extra space for the message field.",
"fields",
":=",
"make",
"(",
"[",
"]",
"etw",
".",
"FieldOpt",
",",
"0",
",",
"len",
"(",
"e",
".",
"Data",
")",
"+",
"1",
")",
"\n\n",
"fields",
"=",
"append",
"(",
"fields",
",",
"etw",
".",
"StringField",
"(",
"\"",
"\"",
",",
"e",
".",
"Message",
")",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"e",
".",
"Data",
"{",
"fields",
"=",
"append",
"(",
"fields",
",",
"etw",
".",
"SmartField",
"(",
"k",
",",
"v",
")",
")",
"\n",
"}",
"\n\n",
"return",
"h",
".",
"provider",
".",
"WriteEvent",
"(",
"\"",
"\"",
",",
"etw",
".",
"WithEventOpts",
"(",
"etw",
".",
"WithLevel",
"(",
"level",
")",
")",
",",
"fields",
")",
"\n",
"}"
] |
// Fire receives each Logrus entry as it is logged, and logs it to ETW.
|
[
"Fire",
"receives",
"each",
"Logrus",
"entry",
"as",
"it",
"is",
"logged",
"and",
"logs",
"it",
"to",
"ETW",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L56-L78
|
150,690 |
Microsoft/go-winio
|
pkg/etwlogrus/hook.go
|
Close
|
func (h *Hook) Close() error {
if h.closeProvider {
return h.provider.Close()
}
return nil
}
|
go
|
func (h *Hook) Close() error {
if h.closeProvider {
return h.provider.Close()
}
return nil
}
|
[
"func",
"(",
"h",
"*",
"Hook",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"h",
".",
"closeProvider",
"{",
"return",
"h",
".",
"provider",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close cleans up the hook and closes the ETW provider. If the provder was
// registered by etwlogrus, it will be closed as part of `Close`. If the
// provider was passed in, it will not be closed.
|
[
"Close",
"cleans",
"up",
"the",
"hook",
"and",
"closes",
"the",
"ETW",
"provider",
".",
"If",
"the",
"provder",
"was",
"registered",
"by",
"etwlogrus",
"it",
"will",
"be",
"closed",
"as",
"part",
"of",
"Close",
".",
"If",
"the",
"provider",
"was",
"passed",
"in",
"it",
"will",
"not",
"be",
"closed",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etwlogrus/hook.go#L83-L88
|
150,691 |
Microsoft/go-winio
|
privilege.go
|
RunWithPrivilege
|
func RunWithPrivilege(name string, fn func() error) error {
return RunWithPrivileges([]string{name}, fn)
}
|
go
|
func RunWithPrivilege(name string, fn func() error) error {
return RunWithPrivileges([]string{name}, fn)
}
|
[
"func",
"RunWithPrivilege",
"(",
"name",
"string",
",",
"fn",
"func",
"(",
")",
"error",
")",
"error",
"{",
"return",
"RunWithPrivileges",
"(",
"[",
"]",
"string",
"{",
"name",
"}",
",",
"fn",
")",
"\n",
"}"
] |
// RunWithPrivilege enables a single privilege for a function call.
|
[
"RunWithPrivilege",
"enables",
"a",
"single",
"privilege",
"for",
"a",
"function",
"call",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/privilege.go#L71-L73
|
150,692 |
Microsoft/go-winio
|
privilege.go
|
RunWithPrivileges
|
func RunWithPrivileges(names []string, fn func() error) error {
privileges, err := mapPrivileges(names)
if err != nil {
return err
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
token, err := newThreadToken()
if err != nil {
return err
}
defer releaseThreadToken(token)
err = adjustPrivileges(token, privileges, SE_PRIVILEGE_ENABLED)
if err != nil {
return err
}
return fn()
}
|
go
|
func RunWithPrivileges(names []string, fn func() error) error {
privileges, err := mapPrivileges(names)
if err != nil {
return err
}
runtime.LockOSThread()
defer runtime.UnlockOSThread()
token, err := newThreadToken()
if err != nil {
return err
}
defer releaseThreadToken(token)
err = adjustPrivileges(token, privileges, SE_PRIVILEGE_ENABLED)
if err != nil {
return err
}
return fn()
}
|
[
"func",
"RunWithPrivileges",
"(",
"names",
"[",
"]",
"string",
",",
"fn",
"func",
"(",
")",
"error",
")",
"error",
"{",
"privileges",
",",
"err",
":=",
"mapPrivileges",
"(",
"names",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"runtime",
".",
"LockOSThread",
"(",
")",
"\n",
"defer",
"runtime",
".",
"UnlockOSThread",
"(",
")",
"\n",
"token",
",",
"err",
":=",
"newThreadToken",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"releaseThreadToken",
"(",
"token",
")",
"\n",
"err",
"=",
"adjustPrivileges",
"(",
"token",
",",
"privileges",
",",
"SE_PRIVILEGE_ENABLED",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"fn",
"(",
")",
"\n",
"}"
] |
// RunWithPrivileges enables privileges for a function call.
|
[
"RunWithPrivileges",
"enables",
"privileges",
"for",
"a",
"function",
"call",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/privilege.go#L76-L93
|
150,693 |
Microsoft/go-winio
|
wim/wim.go
|
Time
|
func (ft *Filetime) Time() time.Time {
// 100-nanosecond intervals since January 1, 1601
nsec := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime)
// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)
nsec -= 116444736000000000
// convert into nanoseconds
nsec *= 100
return time.Unix(0, nsec)
}
|
go
|
func (ft *Filetime) Time() time.Time {
// 100-nanosecond intervals since January 1, 1601
nsec := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime)
// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)
nsec -= 116444736000000000
// convert into nanoseconds
nsec *= 100
return time.Unix(0, nsec)
}
|
[
"func",
"(",
"ft",
"*",
"Filetime",
")",
"Time",
"(",
")",
"time",
".",
"Time",
"{",
"// 100-nanosecond intervals since January 1, 1601",
"nsec",
":=",
"int64",
"(",
"ft",
".",
"HighDateTime",
")",
"<<",
"32",
"+",
"int64",
"(",
"ft",
".",
"LowDateTime",
")",
"\n",
"// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)",
"nsec",
"-=",
"116444736000000000",
"\n",
"// convert into nanoseconds",
"nsec",
"*=",
"100",
"\n",
"return",
"time",
".",
"Unix",
"(",
"0",
",",
"nsec",
")",
"\n",
"}"
] |
// Time returns the time as time.Time.
|
[
"Time",
"returns",
"the",
"time",
"as",
"time",
".",
"Time",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L199-L207
|
150,694 |
Microsoft/go-winio
|
wim/wim.go
|
UnmarshalXML
|
func (ft *Filetime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
type time struct {
Low string `xml:"LOWPART"`
High string `xml:"HIGHPART"`
}
var t time
err := d.DecodeElement(&t, &start)
if err != nil {
return err
}
low, err := strconv.ParseUint(t.Low, 0, 32)
if err != nil {
return err
}
high, err := strconv.ParseUint(t.High, 0, 32)
if err != nil {
return err
}
ft.LowDateTime = uint32(low)
ft.HighDateTime = uint32(high)
return nil
}
|
go
|
func (ft *Filetime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
type time struct {
Low string `xml:"LOWPART"`
High string `xml:"HIGHPART"`
}
var t time
err := d.DecodeElement(&t, &start)
if err != nil {
return err
}
low, err := strconv.ParseUint(t.Low, 0, 32)
if err != nil {
return err
}
high, err := strconv.ParseUint(t.High, 0, 32)
if err != nil {
return err
}
ft.LowDateTime = uint32(low)
ft.HighDateTime = uint32(high)
return nil
}
|
[
"func",
"(",
"ft",
"*",
"Filetime",
")",
"UnmarshalXML",
"(",
"d",
"*",
"xml",
".",
"Decoder",
",",
"start",
"xml",
".",
"StartElement",
")",
"error",
"{",
"type",
"time",
"struct",
"{",
"Low",
"string",
"`xml:\"LOWPART\"`",
"\n",
"High",
"string",
"`xml:\"HIGHPART\"`",
"\n",
"}",
"\n",
"var",
"t",
"time",
"\n",
"err",
":=",
"d",
".",
"DecodeElement",
"(",
"&",
"t",
",",
"&",
"start",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"low",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"t",
".",
"Low",
",",
"0",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"high",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"t",
".",
"High",
",",
"0",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"ft",
".",
"LowDateTime",
"=",
"uint32",
"(",
"low",
")",
"\n",
"ft",
".",
"HighDateTime",
"=",
"uint32",
"(",
"high",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UnmarshalXML unmarshals the time from a WIM XML blob.
|
[
"UnmarshalXML",
"unmarshals",
"the",
"time",
"from",
"a",
"WIM",
"XML",
"blob",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L210-L233
|
150,695 |
Microsoft/go-winio
|
wim/wim.go
|
NewReader
|
func NewReader(f io.ReaderAt) (*Reader, error) {
r := &Reader{r: f}
section := io.NewSectionReader(f, 0, 0xffff)
err := binary.Read(section, binary.LittleEndian, &r.hdr)
if err != nil {
return nil, err
}
if r.hdr.ImageTag != wimImageTag {
return nil, &ParseError{Oper: "image tag", Err: errors.New("not a WIM file")}
}
if r.hdr.Flags&^supportedHdrFlags != 0 {
return nil, fmt.Errorf("unsupported WIM flags %x", r.hdr.Flags&^supportedHdrFlags)
}
if r.hdr.CompressionSize != 0x8000 {
return nil, fmt.Errorf("unsupported compression size %d", r.hdr.CompressionSize)
}
if r.hdr.TotalParts != 1 {
return nil, errors.New("multi-part WIM not supported")
}
fileData, images, err := r.readOffsetTable(&r.hdr.OffsetTable)
if err != nil {
return nil, err
}
xmlinfo, err := r.readXML()
if err != nil {
return nil, err
}
var info info
err = xml.Unmarshal([]byte(xmlinfo), &info)
if err != nil {
return nil, &ParseError{Oper: "XML info", Err: err}
}
for i, img := range images {
for _, imgInfo := range info.Image {
if imgInfo.Index == i+1 {
img.ImageInfo = imgInfo
break
}
}
}
r.fileData = fileData
r.Image = images
r.XMLInfo = xmlinfo
return r, nil
}
|
go
|
func NewReader(f io.ReaderAt) (*Reader, error) {
r := &Reader{r: f}
section := io.NewSectionReader(f, 0, 0xffff)
err := binary.Read(section, binary.LittleEndian, &r.hdr)
if err != nil {
return nil, err
}
if r.hdr.ImageTag != wimImageTag {
return nil, &ParseError{Oper: "image tag", Err: errors.New("not a WIM file")}
}
if r.hdr.Flags&^supportedHdrFlags != 0 {
return nil, fmt.Errorf("unsupported WIM flags %x", r.hdr.Flags&^supportedHdrFlags)
}
if r.hdr.CompressionSize != 0x8000 {
return nil, fmt.Errorf("unsupported compression size %d", r.hdr.CompressionSize)
}
if r.hdr.TotalParts != 1 {
return nil, errors.New("multi-part WIM not supported")
}
fileData, images, err := r.readOffsetTable(&r.hdr.OffsetTable)
if err != nil {
return nil, err
}
xmlinfo, err := r.readXML()
if err != nil {
return nil, err
}
var info info
err = xml.Unmarshal([]byte(xmlinfo), &info)
if err != nil {
return nil, &ParseError{Oper: "XML info", Err: err}
}
for i, img := range images {
for _, imgInfo := range info.Image {
if imgInfo.Index == i+1 {
img.ImageInfo = imgInfo
break
}
}
}
r.fileData = fileData
r.Image = images
r.XMLInfo = xmlinfo
return r, nil
}
|
[
"func",
"NewReader",
"(",
"f",
"io",
".",
"ReaderAt",
")",
"(",
"*",
"Reader",
",",
"error",
")",
"{",
"r",
":=",
"&",
"Reader",
"{",
"r",
":",
"f",
"}",
"\n",
"section",
":=",
"io",
".",
"NewSectionReader",
"(",
"f",
",",
"0",
",",
"0xffff",
")",
"\n",
"err",
":=",
"binary",
".",
"Read",
"(",
"section",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"r",
".",
"hdr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"ImageTag",
"!=",
"wimImageTag",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Oper",
":",
"\"",
"\"",
",",
"Err",
":",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"}",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"Flags",
"&^",
"supportedHdrFlags",
"!=",
"0",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"hdr",
".",
"Flags",
"&^",
"supportedHdrFlags",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"CompressionSize",
"!=",
"0x8000",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
".",
"hdr",
".",
"CompressionSize",
")",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"hdr",
".",
"TotalParts",
"!=",
"1",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"fileData",
",",
"images",
",",
"err",
":=",
"r",
".",
"readOffsetTable",
"(",
"&",
"r",
".",
"hdr",
".",
"OffsetTable",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"xmlinfo",
",",
"err",
":=",
"r",
".",
"readXML",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"info",
"info",
"\n",
"err",
"=",
"xml",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"xmlinfo",
")",
",",
"&",
"info",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Oper",
":",
"\"",
"\"",
",",
"Err",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"img",
":=",
"range",
"images",
"{",
"for",
"_",
",",
"imgInfo",
":=",
"range",
"info",
".",
"Image",
"{",
"if",
"imgInfo",
".",
"Index",
"==",
"i",
"+",
"1",
"{",
"img",
".",
"ImageInfo",
"=",
"imgInfo",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"r",
".",
"fileData",
"=",
"fileData",
"\n",
"r",
".",
"Image",
"=",
"images",
"\n",
"r",
".",
"XMLInfo",
"=",
"xmlinfo",
"\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] |
// NewReader returns a Reader that can be used to read WIM file data.
|
[
"NewReader",
"returns",
"a",
"Reader",
"that",
"can",
"be",
"used",
"to",
"read",
"WIM",
"file",
"data",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L347-L400
|
150,696 |
Microsoft/go-winio
|
wim/wim.go
|
Close
|
func (r *Reader) Close() error {
for _, img := range r.Image {
img.reset()
}
return nil
}
|
go
|
func (r *Reader) Close() error {
for _, img := range r.Image {
img.reset()
}
return nil
}
|
[
"func",
"(",
"r",
"*",
"Reader",
")",
"Close",
"(",
")",
"error",
"{",
"for",
"_",
",",
"img",
":=",
"range",
"r",
".",
"Image",
"{",
"img",
".",
"reset",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close releases resources associated with the Reader.
|
[
"Close",
"releases",
"resources",
"associated",
"with",
"the",
"Reader",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L403-L408
|
150,697 |
Microsoft/go-winio
|
wim/wim.go
|
Open
|
func (img *Image) Open() (*File, error) {
if img.sds == nil {
rsrc, err := img.wim.resourceReaderWithOffset(&img.offset, img.rootOffset)
if err != nil {
return nil, err
}
sds, n, err := img.wim.readSecurityDescriptors(rsrc)
if err != nil {
rsrc.Close()
return nil, err
}
img.sds = sds
img.r = rsrc
img.rootOffset = n
img.curOffset = n
}
f, err := img.readdir(img.rootOffset)
if err != nil {
return nil, err
}
if len(f) != 1 {
return nil, &ParseError{Oper: "root directory", Err: errors.New("expected exactly 1 root directory entry")}
}
return f[0], err
}
|
go
|
func (img *Image) Open() (*File, error) {
if img.sds == nil {
rsrc, err := img.wim.resourceReaderWithOffset(&img.offset, img.rootOffset)
if err != nil {
return nil, err
}
sds, n, err := img.wim.readSecurityDescriptors(rsrc)
if err != nil {
rsrc.Close()
return nil, err
}
img.sds = sds
img.r = rsrc
img.rootOffset = n
img.curOffset = n
}
f, err := img.readdir(img.rootOffset)
if err != nil {
return nil, err
}
if len(f) != 1 {
return nil, &ParseError{Oper: "root directory", Err: errors.New("expected exactly 1 root directory entry")}
}
return f[0], err
}
|
[
"func",
"(",
"img",
"*",
"Image",
")",
"Open",
"(",
")",
"(",
"*",
"File",
",",
"error",
")",
"{",
"if",
"img",
".",
"sds",
"==",
"nil",
"{",
"rsrc",
",",
"err",
":=",
"img",
".",
"wim",
".",
"resourceReaderWithOffset",
"(",
"&",
"img",
".",
"offset",
",",
"img",
".",
"rootOffset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"sds",
",",
"n",
",",
"err",
":=",
"img",
".",
"wim",
".",
"readSecurityDescriptors",
"(",
"rsrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"rsrc",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"img",
".",
"sds",
"=",
"sds",
"\n",
"img",
".",
"r",
"=",
"rsrc",
"\n",
"img",
".",
"rootOffset",
"=",
"n",
"\n",
"img",
".",
"curOffset",
"=",
"n",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"img",
".",
"readdir",
"(",
"img",
".",
"rootOffset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"f",
")",
"!=",
"1",
"{",
"return",
"nil",
",",
"&",
"ParseError",
"{",
"Oper",
":",
"\"",
"\"",
",",
"Err",
":",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"}",
"\n",
"}",
"\n",
"return",
"f",
"[",
"0",
"]",
",",
"err",
"\n",
"}"
] |
// Open parses the image and returns the root directory.
|
[
"Open",
"parses",
"the",
"image",
"and",
"returns",
"the",
"root",
"directory",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L570-L595
|
150,698 |
Microsoft/go-winio
|
wim/wim.go
|
Open
|
func (s *Stream) Open() (io.ReadCloser, error) {
return s.wim.resourceReader(&s.offset)
}
|
go
|
func (s *Stream) Open() (io.ReadCloser, error) {
return s.wim.resourceReader(&s.offset)
}
|
[
"func",
"(",
"s",
"*",
"Stream",
")",
"Open",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"return",
"s",
".",
"wim",
".",
"resourceReader",
"(",
"&",
"s",
".",
"offset",
")",
"\n",
"}"
] |
// Open returns an io.ReadCloser that can be used to read the stream's contents.
|
[
"Open",
"returns",
"an",
"io",
".",
"ReadCloser",
"that",
"can",
"be",
"used",
"to",
"read",
"the",
"stream",
"s",
"contents",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L845-L847
|
150,699 |
Microsoft/go-winio
|
wim/wim.go
|
Open
|
func (f *File) Open() (io.ReadCloser, error) {
return f.img.wim.resourceReader(&f.offset)
}
|
go
|
func (f *File) Open() (io.ReadCloser, error) {
return f.img.wim.resourceReader(&f.offset)
}
|
[
"func",
"(",
"f",
"*",
"File",
")",
"Open",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"return",
"f",
".",
"img",
".",
"wim",
".",
"resourceReader",
"(",
"&",
"f",
".",
"offset",
")",
"\n",
"}"
] |
// Open returns an io.ReadCloser that can be used to read the file's contents.
|
[
"Open",
"returns",
"an",
"io",
".",
"ReadCloser",
"that",
"can",
"be",
"used",
"to",
"read",
"the",
"file",
"s",
"contents",
"."
] |
3fe4fa31662f6ede2353d913e93907b8e096e0b6
|
https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/wim/wim.go#L850-L852
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.