static int snd_ctl_hw_async(snd_ctl_t *ctl, int sig, pid_t pid)
{
long flags;
snd_ctl_hw_t *hw = ctl->private_data;
int fd = hw->fd;
if ((flags = fcntl(fd, F_GETFL)) < 0) {
SYSERR("F_GETFL failed");
return -errno;
}
if (sig >= 0)
flags |= O_ASYNC;
else
flags &= ~O_ASYNC;
if (fcntl(fd, F_SETFL, flags) < 0) {
SYSERR("F_SETFL for O_ASYNC failed");
return -errno;
}
if (sig < 0)
return 0;
if (fcntl(fd, F_SETSIG, (long)sig) < 0) {
SYSERR("F_SETSIG failed");
return -errno;
}
if (fcntl(fd, F_SETOWN, (long)pid) < 0) {
SYSERR("F_SETOWN failed");
return -errno;
}
return 0;
}
int createsock(int port) {
int sockfd;
struct sockaddr_in saddr;
int backlog;
int reuse = 1;
char *p;
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
SYSERR("socket");
}
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
SYSERR("setsockopt");
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
saddr.sin_port = htons(port);
if (bind(sockfd, (struct sockaddr*) &saddr, sizeof(saddr)) < 0) {
SYSERR("bind");
}
backlog = DEFAULT_BACKLOG;
if ((p = getenv(GRACE_BACKLOG)) != NULL) {
backlog = atoi(p);
}
if (listen(sockfd, backlog) < 0) {
SYSERR("listen");
}
return sockfd;
}
DSO_PUBLIC int64_t
lfp_parse_memsize(const char *s, enum lfp_memsize_measure_unit default_unit)
{
int64_t default_multiplier, multiplier, amount;
SYSCHECK(EINVAL, s == NULL || *s == '\0');
SYSGUARD(default_multiplier = compute_multiplier(default_unit));
char *endptr = NULL;
lfp_set_errno(0);
SYSGUARD(amount = strtoll(s, &endptr, 10));
SYSCHECK(ERANGE, amount < 0);
if (amount == 0) {
return 0;
} else if (*endptr) {
if (strcasecmp(endptr, "KB") == 0) {
multiplier = 1000LL;
} else if (strcasecmp(endptr, "K") == 0 ||
strcasecmp(endptr, "KiB") == 0) {
multiplier = 1024LL;
} else if (strcasecmp(endptr, "MB") == 0) {
multiplier = 1000LL*1000LL;
} else if (strcasecmp(endptr, "M") == 0 ||
strcasecmp(endptr, "MiB") == 0) {
multiplier = 1024LL*1024LL;
} else if (strcasecmp(endptr, "GB") == 0) {
multiplier = 1000LL*1000LL*1000LL;
} else if (strcasecmp(endptr, "G") == 0 ||
strcasecmp(endptr, "GiB") == 0) {
multiplier = 1024LL*1024LL*1024LL;
} else if (strcasecmp(endptr, "TB") == 0) {
multiplier = 1000LL*1000LL*1000LL*1000LL;
} else if (strcasecmp(endptr, "T") == 0 ||
strcasecmp(endptr, "TiB") == 0) {
multiplier = 1024LL*1024LL*1024LL*1024LL;
} else if (strcasecmp(endptr, "PB") == 0) {
multiplier = 1000LL*1000LL*1000LL*1000LL*1000LL;
} else if (strcasecmp(endptr, "P") == 0 ||
strcasecmp(endptr, "PiB") == 0) {
multiplier = 1024LL*1024LL*1024LL*1024LL*1024LL;
} else if (strcasecmp(endptr, "EB") == 0) {
multiplier = 1000LL*1000LL*1000LL*1000LL*1000LL*1000LL;
} else if (strcasecmp(endptr, "E") == 0 ||
strcasecmp(endptr, "EiB") == 0) {
multiplier = 1024LL*1024LL*1024LL*1024LL*1024LL*1024LL;
} else {
SYSERR(EINVAL);
}
} else {
multiplier = default_multiplier;
}
// Check for overflow
if (amount > (INT64_MAX / multiplier)) {
SYSERR(ERANGE);
} else {
return amount * multiplier;
}
}
static int snd_timer_hw_async(snd_timer_t *timer, int sig, pid_t pid)
{
long flags;
int fd;
assert(timer);
fd = timer->poll_fd;
if ((flags = fcntl(fd, F_GETFL)) < 0) {
SYSERR("F_GETFL failed");
return -errno;
}
if (sig >= 0)
flags |= O_ASYNC;
else
flags &= ~O_ASYNC;
if (fcntl(fd, F_SETFL, flags) < 0) {
SYSERR("F_SETFL for O_ASYNC failed");
return -errno;
}
if (sig < 0)
return 0;
if (fcntl(fd, F_SETSIG, (long)sig) < 0) {
SYSERR("F_SETSIG failed");
return -errno;
}
if (fcntl(fd, F_SETOWN, (long)pid) < 0) {
SYSERR("F_SETOWN failed");
return -errno;
}
return 0;
}
static int make_local_socket(const char *filename, int server, mode_t ipc_perm, int ipc_gid)
{
size_t l = strlen(filename);
size_t size = offsetof(struct sockaddr_un, sun_path) + l;
struct sockaddr_un *addr = alloca(size);
int sock;
sock = socket(PF_LOCAL, SOCK_STREAM, 0);
if (sock < 0) {
int result = -errno;
SYSERR("socket failed");
return result;
}
if (server)
unlink(filename);
memset(addr, 0, size); /* make valgrind happy */
addr->sun_family = AF_LOCAL;
memcpy(addr->sun_path, filename, l);
if (server) {
if (bind(sock, (struct sockaddr *) addr, size) < 0) {
int result = -errno;
SYSERR("bind failed: %s", filename);
close(sock);
return result;
} else {
if (chmod(filename, ipc_perm) < 0) {
int result = -errno;
SYSERR("chmod failed: %s", filename);
close(sock);
unlink(filename);
return result;
}
if (chown(filename, -1, ipc_gid) < 0) {
#if 0 /* it's not fatal */
int result = -errno;
SYSERR("chown failed: %s", filename);
close(sock);
unlink(filename);
return result;
#endif
}
}
} else {
if (connect(sock, (struct sockaddr *) addr, size) < 0) {
int result = -errno;
SYSERR("connect failed: %s", filename);
close(sock);
return result;
}
}
return sock;
}
void setup_signals() {
struct sigaction sachld;
struct sigaction sahup;
struct sigaction saterm;
sigset_t sigset;
int spipe[2];
// int flag;
// setup pipe for signal handling
if (pipe(spipe) < 0) {
SYSERR("pipe");
}
srd = spipe[0];
swr = spipe[1];
// non blocking
// flag = fcntl(srd, F_GETFL);
if (fcntl(srd, F_SETFL, O_NONBLOCK) == -1) {
SYSERR("fcntl O_NONBLOCK");
}
// flag = fcntl(swr, F_GETFL);
if (fcntl(swr, F_SETFL, O_NONBLOCK) == -1) {
SYSERR("fcntl O_NONBLOCK");
}
// only SIGHUP, SIGCHLD or SIGTERM are allowed
sigfillset(&sigset);
sigdelset(&sigset, SIGHUP);
sigdelset(&sigset, SIGCHLD);
sigdelset(&sigset, SIGTERM);
sigdelset(&sigset, SIGINT);
sigprocmask(SIG_SETMASK, &sigset, &osigset);
sachld.sa_handler = sigchld_handler;
sigfillset(&sachld.sa_mask);
sachld.sa_flags = 0;
sigaction(SIGCHLD, &sachld, NULL);
sahup.sa_handler = sighup_handler;
sigfillset(&sahup.sa_mask);
sahup.sa_flags = 0;
sigaction(SIGHUP, &sahup, NULL);
saterm.sa_handler = sigterm_handler;
sigfillset(&saterm.sa_mask);
saterm.sa_flags = 0;
sigaction(SIGTERM, &saterm, NULL);
}
static int
_meta2_filter_check_ns_name(struct gridd_filter_ctx_s *ctx,
struct gridd_reply_ctx_s *reply, int optional)
{
(void) reply;
TRACE_FILTER();
const struct meta2_backend_s *backend = meta2_filter_ctx_get_backend(ctx);
const char *req_ns = oio_url_get(meta2_filter_ctx_get_url(ctx), OIOURL_NS);
if (!backend || !backend->ns_name[0]) {
GRID_DEBUG("Missing information for namespace checking");
meta2_filter_ctx_set_error(ctx, SYSERR("backend not ready"));
return FILTER_KO;
}
if (!req_ns) {
if (optional)
return FILTER_OK;
GRID_DEBUG("Missing namespace name in request");
meta2_filter_ctx_set_error(ctx, BADREQ("No namespace"));
return FILTER_KO;
}
if (0 != g_ascii_strcasecmp(backend->ns_name, req_ns)) {
meta2_filter_ctx_set_error(ctx, BADNS());
return FILTER_KO;
}
return FILTER_OK;
}
void wait_child(int pid, int rd) {
int nfd;
int nb;
char ph[1];
fd_set rset;
SELECT:
FD_ZERO(&rset);
FD_SET(rd, &rset);
nfd = select(rd + 1, &rset, NULL, NULL, &timeout);
if (nfd == -1 && errno == EINTR) {
goto SELECT;
}
if (!FD_ISSET(rd, &rset)) {
kill(pid, SIGTERM);
USRERR("timeout; child does not finish yet\n");
}
READ:
nb = read(rd, ph, 1);
if (nb == -1 && errno == EINTR) {
goto READ;
}
if (nb == -1) {
SYSERR("read from pipe");
}
if (nb == 0) {
USRERR("EOF detected; child failed to start\n");
}
}
static int snd_pcm_shm_new_rbptr(snd_pcm_t *pcm, snd_pcm_shm_t *shm,
snd_pcm_rbptr_t *rbptr, volatile snd_pcm_shm_rbptr_t *shm_rbptr)
{
if (!shm_rbptr->use_mmap) {
if (&pcm->hw == rbptr)
snd_pcm_set_hw_ptr(pcm, &shm_rbptr->ptr, -1, 0);
else
snd_pcm_set_appl_ptr(pcm, &shm_rbptr->ptr, -1, 0);
} else {
void *ptr;
size_t mmap_size, mmap_offset, offset;
int fd;
long result;
shm->ctrl->cmd = &pcm->hw == rbptr ? SND_PCM_IOCTL_HW_PTR_FD : SND_PCM_IOCTL_APPL_PTR_FD;
result = snd_pcm_shm_action_fd0(pcm, &fd);
if (result < 0)
return result;
mmap_size = page_ptr(shm_rbptr->offset, sizeof(snd_pcm_uframes_t), &offset, &mmap_offset);
ptr = mmap(NULL, mmap_size, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED, fd, mmap_offset);
if (ptr == MAP_FAILED || ptr == NULL) {
SYSERR("shm rbptr mmap failed");
return -errno;
}
if (&pcm->hw == rbptr)
snd_pcm_set_hw_ptr(pcm, (snd_pcm_uframes_t *)((char *)ptr + offset), fd, shm_rbptr->offset);
else
snd_pcm_set_appl_ptr(pcm, (snd_pcm_uframes_t *)((char *)ptr + offset), fd, shm_rbptr->offset);
}
return 0;
}
static int write_wav_header(snd_pcm_t *pcm)
{
snd_pcm_file_t *file = pcm->private_data;
static char header[] = {
'R', 'I', 'F', 'F',
0x24, 0, 0, 0,
'W', 'A', 'V', 'E',
'f', 'm', 't', ' ',
0x10, 0, 0, 0,
};
static char header2[] = {
'd', 'a', 't', 'a',
0, 0, 0, 0
};
setup_wav_header(pcm, &file->wav_header);
if (write(file->fd, header, sizeof(header)) != sizeof(header) ||
write(file->fd, &file->wav_header, sizeof(file->wav_header)) !=
sizeof(file->wav_header) ||
write(file->fd, header2, sizeof(header2)) != sizeof(header2)) {
int err = errno;
SYSERR("Write error.\n");
return -err;
}
return 0;
}
static void snd_pcm_file_write_bytes(snd_pcm_t *pcm, size_t bytes)
{
snd_pcm_file_t *file = pcm->private_data;
assert(bytes <= file->wbuf_used_bytes);
if (file->format == SND_PCM_FILE_FORMAT_WAV &&
!file->wav_header.fmt) {
if (write_wav_header(pcm) < 0)
return;
}
while (bytes > 0) {
snd_pcm_sframes_t err;
size_t n = bytes;
size_t cont = file->wbuf_size_bytes - file->file_ptr_bytes;
if (n > cont)
n = cont;
err = write(file->fd, file->wbuf + file->file_ptr_bytes, n);
if (err < 0) {
SYSERR("write failed");
break;
}
bytes -= err;
file->wbuf_used_bytes -= err;
file->file_ptr_bytes += err;
if (file->file_ptr_bytes == file->wbuf_size_bytes)
file->file_ptr_bytes = 0;
file->filelen += err;
if ((snd_pcm_uframes_t)err != n)
break;
}
}
static int snd_ctl_hw_card_info(snd_ctl_t *handle, snd_ctl_card_info_t *info)
{
snd_ctl_hw_t *hw = handle->private_data;
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_CARD_INFO, info) < 0) {
SYSERR("SNDRV_CTL_IOCTL_CARD_INFO failed");
return -errno;
}
return 0;
}
static int snd_ctl_hw_subscribe_events(snd_ctl_t *handle, int subscribe)
{
snd_ctl_hw_t *hw = handle->private_data;
if (ioctl(hw->fd, SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS, &subscribe) < 0) {
SYSERR("SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS failed");
return -errno;
}
return subscribe;
}
DSO_PUBLIC int
lfp_sigrtmin (void)
{
#if defined(SIGRTMIN)
return SIGRTMIN;
#else
SYSERR(ENOSYS);
#endif // SIGRTMIN
}
static int snd_seq_hw_system_info(snd_seq_t *seq, snd_seq_system_info_t * info)
{
snd_seq_hw_t *hw = seq->private_data;
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_SYSTEM_INFO, info) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_SYSTEM_INFO failed");
return -errno;
}
return 0;
}
DSO_PUBLIC int
lfp_sigrtmax (void)
{
#if defined(SIGRTMAX)
return SIGRTMAX;
#else
SYSERR(ENOSYS);
#endif // SIGRTMAX
}
static int snd_seq_hw_nonblock(snd_seq_t *seq, int nonblock)
{
snd_seq_hw_t *hw = seq->private_data;
long flags;
if ((flags = fcntl(hw->fd, F_GETFL)) < 0) {
SYSERR("F_GETFL failed");
return -errno;
}
if (nonblock)
flags |= O_NONBLOCK;
else
flags &= ~O_NONBLOCK;
if (fcntl(hw->fd, F_SETFL, flags) < 0) {
SYSERR("F_SETFL for O_NONBLOCK failed");
return -errno;
}
return 0;
}
static int snd_seq_hw_close(snd_seq_t *seq)
{
snd_seq_hw_t *hw = seq->private_data;
if (close(hw->fd)) {
SYSERR("close failed\n");
return -errno;
}
free(hw);
return 0;
}
static int snd_rawmidi_hw_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
{
snd_rawmidi_hw_t *hw = rmidi->private_data;
params->stream = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_PARAMS, params) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_PARAMS failed");
return -errno;
}
return 0;
}
static int snd_rawmidi_hw_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
{
snd_rawmidi_hw_t *hw = rmidi->private_data;
info->stream = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_INFO, info) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_INFO failed");
return -errno;
}
return 0;
}
static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
{
snd_rawmidi_hw_t *hw = rmidi->private_data;
status->stream = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_STATUS, status) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_STATUS failed");
return -errno;
}
return 0;
}
static int snd_seq_hw_client_id(snd_seq_t *seq)
{
snd_seq_hw_t *hw = seq->private_data;
int client;
if (ioctl(hw->fd, SNDRV_SEQ_IOCTL_CLIENT_ID, &client) < 0) {
SYSERR("SNDRV_SEQ_IOCTL_CLIENT_ID failed");
return -errno;
}
return client;
}
static int snd_rawmidi_hw_drain(snd_rawmidi_t *rmidi)
{
snd_rawmidi_hw_t *hw = rmidi->private_data;
int str = rmidi->stream;
if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DRAIN, &str) < 0) {
SYSERR("SNDRV_RAWMIDI_IOCTL_DRAIN failed");
return -errno;
}
return 0;
}
int
meta2_filter_check_backend(struct gridd_filter_ctx_s *ctx,
struct gridd_reply_ctx_s *reply)
{
(void) reply;
TRACE_FILTER();
struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);
if (meta2_backend_initiated(m2b))
return FILTER_OK;
meta2_filter_ctx_set_error(ctx, SYSERR("Backend not ready"));
return FILTER_KO;
}
static int sco_ctl_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value)
{
snd_ctl_sco_t *bt_headset = ext->private_data;
long curvalue;
sco_ctl_read_integer(ext, key, &curvalue);
if(*value == curvalue) {
return 0;
}
else {
ctl_packet_t pkt = {.type = PKT_TYPE_CTL_CMD_SET, .volvalue = (unsigned char)*value};
if(key == HS_SPEAKER) {
pkt.voltype = SPEAKER;
}
else if(key == HS_MICROPHONE) {
pkt.voltype = MICROPHONE;
}
else {
return -EINVAL;
}
if(send(bt_headset->serverfd, &pkt, sizeof(pkt), MSG_NOSIGNAL) != sizeof(pkt)) {
SYSERR("Unable to send new volume value to server");
}
return 1;
}
}
static int sco_ctl_read_event(snd_ctl_ext_t *ext, snd_ctl_elem_id_t *id,
unsigned int *event_mask)
{
snd_ctl_sco_t *bt_headset = ext->private_data;
ctl_packet_t pkt;
DBG("");
if(recv(bt_headset->serverfd, &pkt, sizeof(pkt), MSG_DONTWAIT) == sizeof(pkt)) {
if(pkt.type == PKT_TYPE_CTL_NTFY) {
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
snd_ctl_elem_id_set_name(id, pkt.voltype == SPEAKER ? vol_devices[HS_SPEAKER] : vol_devices[HS_MICROPHONE]);
*event_mask = SND_CTL_EVENT_MASK_VALUE;
return 1;
}
else {
SNDERR("Unexpected packet type %d received!", pkt.type);
return -EAGAIN;
}
}
else {
return -errno;
}
}
int snd_hwdep_hw_open(snd_hwdep_t **handle, const char *name, int card, int device, int mode)
{
int fd, ver, ret;
char filename[sizeof(SNDRV_FILE_HWDEP) + 20];
snd_hwdep_t *hwdep;
assert(handle);
*handle = NULL;
if (card < 0 || card >= 32)
return -EINVAL;
sprintf(filename, SNDRV_FILE_HWDEP, card, device);
fd = snd_open_device(filename, mode);
if (fd < 0) {
snd_card_load(card);
fd = snd_open_device(filename, mode);
if (fd < 0)
return -errno;
}
#if 0
/*
* this is bogus, an application have to care about open filedescriptors
*/
if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {
SYSERR("fcntl FD_CLOEXEC failed");
ret = -errno;
close(fd);
return ret;
}
#endif
if (ioctl(fd, SNDRV_HWDEP_IOCTL_PVERSION, &ver) < 0) {
ret = -errno;
close(fd);
return ret;
}
if (SNDRV_PROTOCOL_INCOMPATIBLE(ver, SNDRV_HWDEP_VERSION_MAX)) {
close(fd);
return -SND_ERROR_INCOMPATIBLE_VERSION;
}
hwdep = (snd_hwdep_t *) calloc(1, sizeof(snd_hwdep_t));
if (hwdep == NULL) {
close(fd);
return -ENOMEM;
}
hwdep->name = strdup(name);
hwdep->poll_fd = fd;
hwdep->mode = mode;
hwdep->type = SND_HWDEP_TYPE_HW;
hwdep->ops = &snd_hwdep_hw_ops;
*handle = hwdep;
return 0;
}
static int make_local_socket(const char *filename, int server, mode_t ipc_perm)
{
size_t l = strlen(filename);
size_t size = offsetof(struct sockaddr_un, sun_path) + l;
struct sockaddr_un *addr = alloca(size);
int sock;
sock = socket(PF_LOCAL, SOCK_STREAM, 0);
if (sock < 0) {
int result = -errno;
SYSERR("socket failed");
return result;
}
if (server)
unlink(filename);
addr->sun_family = AF_LOCAL;
memcpy(addr->sun_path, filename, l);
if (server) {
if (bind(sock, (struct sockaddr *) addr, size) < 0) {
int result = -errno;
SYSERR("bind failed: %s", filename);
return result;
} else {
if (chmod(filename, ipc_perm) < 0) {
int result = -errno;
SYSERR("chmod failed: %s", filename);
return result;
}
}
} else {
if (connect(sock, (struct sockaddr *) addr, size) < 0) {
SYSERR("connect failed: %s", filename);
return -errno;
}
}
return sock;
}
static int sco_ctl_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, long *value)
{
snd_ctl_sco_t *bt_headset = ext->private_data;
ctl_packet_t pkt = {.type = PKT_TYPE_CTL_CMD_GET};
DBG("");
*value = 0;
if(key == HS_SPEAKER) {
pkt.voltype = SPEAKER;
}
else if(key == HS_MICROPHONE) {
pkt.voltype = MICROPHONE;
}
else {
return -EINVAL;
}
if(send(bt_headset->serverfd, &pkt, sizeof(pkt), MSG_NOSIGNAL) == sizeof(pkt)) {
if(recv(bt_headset->serverfd, &pkt, sizeof(pkt), 0) == sizeof(pkt)) {
if(pkt.type == PKT_TYPE_CTL_GET_RSP) {
*value = pkt.volvalue;
}
else {
SNDERR("Unexpected packet type %d received", pkt.type);
}
}
else {
SYSERR("Unable to receive new volume value from server");
}
}
else {
SYSERR("Unable to request new volume value to server");
}
return 0;
}
static int snd_rawmidi_hw_close(snd_rawmidi_t *rmidi)
{
snd_rawmidi_hw_t *hw = rmidi->private_data;
int err = 0;
hw->open--;
if (hw->open)
return 0;
if (close(hw->fd)) {
err = -errno;
SYSERR("close failed\n");
}
free(hw);
return err;
}
static inline int64_t
compute_multiplier(enum lfp_memsize_measure_unit unit)
{
switch(unit) {
case LFP_OCTETS: return 1;
case LFP_KB: return 1000LL;
case LFP_KIB: return 1024LL;
case LFP_MB: return 1000LL*1000LL;
case LFP_MIB: return 1024LL*1024LL;
case LFP_GB: return 1000LL*1000LL*1000LL;
case LFP_GIB: return 1024LL*1024LL*1024LL;
case LFP_TB: return 1000LL*1000LL*1000LL*1000LL;
case LFP_TIB: return 1024LL*1024LL*1024LL*1024LL;
case LFP_PB: return 1000LL*1000LL*1000LL*1000LL*1000LL;
case LFP_PIB: return 1024LL*1024LL*1024LL*1024LL*1024LL;
case LFP_EB: return 1000LL*1000LL*1000LL*1000LL*1000LL*1000LL;
case LFP_EIB: return 1024LL*1024LL*1024LL*1024LL*1024LL*1024LL;
default: SYSERR(EINVAL);
}
}
