nm_tactics.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2006-2026 (see AUTHORS file)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
 
#ifndef NM_TACTICS_H
#define NM_TACTICS_H
 
nm_len_t nm_tactic_get_iov_threshold(void);
 
static inline int nm_tactic_req_is_short(const struct nm_req_chunk_s*p_req_chunk)
{
  return ( (p_req_chunk->chunk_offset == 0) &&
           (p_req_chunk->chunk_len < 255) &&
           (p_req_chunk->chunk_len == p_req_chunk->p_req->pack.len) &&
           (p_req_chunk->proto_flags == NM_PROTO_FLAG_LASTCHUNK) );
}
 
static inline nm_len_t nm_tactic_req_short_size(const struct nm_req_chunk_s*p_req_chunk)
{
  assert(nm_tactic_req_is_short(p_req_chunk));
  return (NM_HEADER_SHORT_DATA_SIZE + p_req_chunk->chunk_len);
}
 
static inline nm_len_t nm_tactic_req_data_max_size(const struct nm_req_chunk_s*p_req_chunk)
{
  const nm_len_t chunk_len = p_req_chunk->chunk_len;
  /* compute maximum number of headers for this chunk;
   * only blocks larger than NM_DATA_IOV_THRESHOLD have their own header */
  const nm_len_t max_headers = p_req_chunk->chunk_props.size / nm_tactic_get_iov_threshold();
  const nm_len_t max_header_blocks = (max_headers > p_req_chunk->chunk_props.blocks) ? p_req_chunk->chunk_props.blocks : max_headers;
  const nm_len_t max_header_len = NM_HEADER_DATA_SIZE + max_header_blocks * sizeof(struct nm_header_pkt_data_chunk_s) + NM_ALIGN_FRONTIER;
  return (max_header_len + chunk_len);
}
 
static inline nm_len_t nm_tactic_req_data_density(const struct nm_req_chunk_s*p_req_chunk)
{
  const struct nm_req_s*p_pack = p_req_chunk->p_req;
  const struct nm_data_properties_s*p_props = nm_data_properties_get(&p_pack->data);
  const nm_len_t density = (p_props->blocks > 0) ? p_props->size / p_props->blocks : 0;
  return density;
}
 
static inline int nm_tactic_pack_ctrl(nm_gate_t p_gate, nm_drv_t p_drv  __attribute__((unused)),
                                      struct nm_ctrl_chunk_s*p_ctrl_chunk,
                                      struct nm_pkt_wrap_s*p_pw)
{
  struct nm_core*p_core = p_gate->p_core;
  nm_core_lock_assert(p_core);
  if(NM_HEADER_CTRL_SIZE(&p_ctrl_chunk->ctrl) + p_ctrl_chunk->size < nm_pw_remaining_buf(p_pw))
    {
      nm_pw_add_control(p_pw, &p_ctrl_chunk->ctrl, p_ctrl_chunk->p_payload);
      nm_ctrl_chunk_list_remove(&p_gate->ctrl_chunk_list, p_ctrl_chunk);
      nm_ctrl_chunk_free(&p_gate->p_core->ctrl_chunk_allocator, p_ctrl_chunk);
      return NM_ESUCCESS;
    }
  else
    {
      return -NM_EBUSY;
    }
}
 
int nm_tactic_pack_rdv(nm_gate_t p_gate, nm_drv_t p_drv,
                       struct nm_req_chunk_list_s*p_req_chunk_list,
                       struct nm_req_chunk_s*p_req_chunk,
                       struct nm_pkt_wrap_s*p_pw);
 
struct nm_rdv_chunk_s
{
  nm_trk_id_t trk_id; 
  nm_len_t len;       
};
 
void nm_tactic_rtr_pack(struct nm_core*p_core, struct nm_pkt_wrap_s*p_pw, int nb_chunks, const struct nm_rdv_chunk_s*p_chunks);
 
void nm_tactic_rdv_accept(struct nm_core*p_core, struct nm_pkt_wrap_s*p_pw);
 
#endif /* NM_TACTICS_H */