ajustando o Kernel Service

Editar online

Propósito

Fornece acesso às variáveis ajustáveis do kernel através de uma interface facilmente acessível.

Sintaxe

typedef enum {
    TH_MORE,
    TH_EOF
} tmode_t;

#define TH_ABORT TH_EOF

typedef int (*tuning_read_t)(tmode_t mode, long *size, char **buf, void *context);
typedef int (*tuning_write_t)(tmode_t mode, long *size, char *buf, void *context);
tinode_t *tuning_register_handler (path,  mode, readfunc, writefunc, context)
const char *path;
mode_t mode;
tuning_read_t readfunc;
tuning_write_t writefunc;
void * context;
tinode *tuning_register_bint32 (path, mode, variable, low,  high)
const char *path;
mode_t mode;
int32 *variable;
int32 low;
int32 high;
tinode *tuning_register_bint32x (path, rfunc, wfunc, mode, low, high)
const char *path;
mode_t mode;
int32 (*rfunc)(void *);
int (*wfunc)(int32, void *);
void *context;
int32 low;
int32 high;
tinode *tuning_register_buint32 (path, mode,variable, low, high)
const char *path;
mode_t mode;
uint32 *variable;
uint32 low;
uint32 high;
tinode *tuning_register_buint32x (path, rfunc, wfunc, mode, low, high)
const char *path;
mode_t mode;
uint32 (*rfunc)(void *);
int (*wfunc)(uint32, void *);
void *context;
uint32 low;
uint32 high;
tinode *tuning_register_bint64 (path, mode, variable, low, high)
const char *path;
mode_t mode;
int64 *variable;
int64 low;
int64 high;
tinode *tuning_register_bint64x (path, rfunc, wfunc, mode, low, high)
const char *path;
mode_t mode;
int64 (*rfunc)(void *);
int (*wfunc)(int64, void *);
void *context;
in64 low;
in64 high;
tinode *tuning_register_buint64 (path, mode, variable, low, high)
const char *path;
mode_t mode;
uint64 *variable;
uint64 low;
uint64 high;
tinode *tuning_register_buint64x (path, rfunc, wfunc, mode, low, high)
const char *path;
mode_t mode;
uint64 (*rfunc)(void *);
int (*wfunc)(uint64, void *);
void *context;
uint64 low;
uint64 high;
void tuning_deregister (t)
tinode_t * t;

Descrição

O serviço kernel tuning_register_handler é usado para adicionar um arquivo no local especificado pelo parâmetro caminho . Quando este arquivo é lido de ou escrito para, um dos dois callbacks transmitidos como parâmetros para a função é invocado.

Os acessos ao arquivo são visualizados em termos de streams. Um único fluxo é criado por uma sequência de uma aberta, uma ou mais leituras, e uma próxima no arquivo. Enquanto o arquivo é aberto por um processo, as tentativas de abrir o mesmo arquivo por outros processos serão bloqueadas a menos que O_NONBLOCK seja passada nas bandeiras para a sub-rotina aberto .

O callback readfunc se comporta como uma função de produtor. A função é chamada quando o usuário tenta ler a partir do arquivo. O parâmetro modo é igual a TH_MAIS , a menos que o usuário feche o arquivo prematuramente. Na entrada, o parâmetro tamanho é um inteiro contendo o tamanho do buffer. O parâmetro contexto é o ponteiro de contexto passado para a função de registro. Ao retornar, tamanho deverá conter ou a quantidade real de dados retornados, ou um zero se uma condição de fim de arquivo deve ser devolvida ao usuário. O valor de retorno da função também pode ser usado para sinalizar fim-de-arquivo, conforme descrito a seguir.
Nota: espera-se que o callback readfunc já tenha feito qualquer limpeza necessária de fim de arquivo quando ele retornar o sinal de fim de arquivo.

Se a quantidade de dados retornados for nonzero, o parâmetro buf pode ser modificado para apontar para um novo buffer. Se isso for feito, o callback é responsável por libertar o novo buffer.

Se o buffer fornecido pelo caller for muito pequeno, o caller pode, em vez disso, configurar buf para NULL. Nesse caso, o parâmetro tamanho deve ser modificado para indicar o tamanho do buffer necessário. O caller irá então re-invocar o callback com um buffer de pelo menos o tamanho solicitado.

Se o usuário fechar o arquivo antes que o callback indique fim-de-arquivo, o callback será invocado uma última vez com modo igual a TH_ABORT. Nesse caso, o parâmetro tamanho é igual a 0 na entrada, e qualquer dado retornado é descartado. O callback deve redefinir seu estado porque não serão feitos novos callbacks para este fluxo.

O callback writefunc se comporta como uma função de consumidor e é usado quando o usuário tenta escrever para o arquivo. O parâmetro modo é configurado como TH_EOF se não podem ser esperados mais dados neste fluxo (por exemplo, o usuário chamou a subroutine fechar no arquivo). Caso contrário, modo é configurado como TH_MAIS. O parâmetro tamanho contém o tamanho dos dados transmitidos no buffer. O parâmetro buf é o ponteiro para o buffer.
Nota: Haverá zero ou mais chamadas com o parâmetro modo configurado para TH_MAIS e uma chamada com o parâmetro modo configurado para TH_EOF para cada fluxo.
O parâmetro buf pode mudar entre invocações. Ao retornar do callback, o parâmetro tamanho deve ser modificado para refletir a quantidade de dados consumidos do buffer, e o buffer não deve ser liberado mesmo se todos os dados forem consumidos. Espera-se que a função consuma dados em uma moda linear (primeira em, primeiro fora). Os dados não consumidos estão presentes no início do buffer na próxima chamada do callback. O parâmetro tamanho incluirá o tamanho dos dados não consumidos.

Ambos os valores de retorno de callbacks devem ser zero. Se não for bem sucedido, um valor positivo será colocado na variável global errno (com a indicação de acompanhamento de um retorno de erro do serviço kernel). Se o valor de retorno de um retorno de chamada for menor que 0, o fim do arquivo será sinalizado ao usuário e o valor de retorno será tratado como sua negação unária (por exemplo,-1 será tratado como 0). Neste caso, não serão feitos novos callbacks para este fluxo.

Os serviços de kernel tuning_register_bint32, tuning_register_buint32, tuning_register_bint64e tuning_register_buint64 são usados para adicionar um arquivo no local especificado pelo parâmetro caminho que, ao ler a partir, retornará o valor ASCII da variável inteira apontada pelo parâmetro variável . Quando escrito para, este arquivo configurará a variável inteira para o valor cujo valor ASCII foi escrito, a menos que esse valor não satisfaça a relação baixo < = valor < alto. Nesse caso, a variável inteira não é modificada, e um erro é retornado ao usuário por meio de um retorno de erro do serviço kernel durante o qual a tentativa inválida é detectada (provavelmente escrever ou fechar).

As funções tuning_register_b*x operam de forma semelhante às suas variantes nãox , mas eles usam um par de callbacks para recuperar (rfunc) e configurar (wfunc) a variável. O callback é passado o valor (se configurando) e o parâmetro de contexto. Isso permite operações mais complexas em leitura / gravação, como serialização e alocação de memória e desalocação.

O serviço kernel tuning_get_context retorna o contexto da função de registro usada para criar a estrutura tinode_t referida pelo parâmetro argumento .

O serviço kernel tuning_register é a interface básica pela qual um arquivo pode ser incluído na hierarquia de diretórios /proc/sys . Essa função não é exportada para extensões do kernel, e seu uso direto no kernel é fortemente desmotivado. O parâmetro caminho contém o caminho relativo à raiz /proc/sys na qual o arquivo deve aparecer. Os componentes de caminho intermediário são criados automaticamente. O parâmetro modo contém as permissões UNIX e o tipo do arquivo a ser criado (conforme o campo st_mode da struct stat ). Se o tipo de arquivo não for especificado, ele será assumido como S_IFREG. Na maioria dos casos este parâmetro será 0644 ou 0600. O parâmetro vnops é usado para despachar todas as operações no arquivo.

O serviço kernel tuning_deregister é usado para remover um arquivo da hierarquia de diretórios /proc/sys . Ele é exportado para extensões do kernel. Ele só deve ser usado quando uma implementação de arquivo específico não estiver mais disponível. O parâmetro t é uma estrutura tinode_t como retornado por tuning_register. Se o arquivo estiver atualmente aberto, qualquer outro acesso a ele após esta chamada retorna ESTALE.

Parâmetros

Item Descrição
Modo É configurado como TH_EOF se não são esperados dados adicionais do usuário para esta alteração, ou TH_MAIS se novos dados são esperados.
tamanho Contém o tamanho dos dados passados no buffer.
buf Pontos para o buffer.
contexto Aponta para o contexto passado para a função de registro.
caminho Especifica a localização do arquivo a ser adicionado.
readfunc Comporta-se como uma função de produtor.
rfunc Recupera a variável.
wfunc Configura a variável.
writefunc Comporta-se como uma função de consumidor.
variável Especifica a variável.
alto Especifica o valor máximo que o parâmetro variável pode conter.
baixo Especifica o valor mínimo que o parâmetro variável pode conter.
T Uma estrutura tinode_t como retornado por tuning_register.

Valores De Retorno

Após a conclusão bem-sucedida, o serviço kernel tuning_register retorna a estrutura tinode_t recém-criada. Se malsucedido, um valor NULL é retornado.

Exemplos

Um usuário dessa interface pode incluir a seguinte linha em sua rotina de inicialização:
tuning_var = tuning_register_buint64 
("fs/jfs2/max_readahead", 0644 &j2_max_read_ahead, 0, 1024);

Neste exemplo tuning_var é uma variável global do tipo tinode_t *. Isso faz com que os diretórios fs e fs/jfs2 sejam criados, e um arquivo (pipe) a ser criado como fs/jfs2/max_readahead. O arquivo retorna o valor de j2_max_readahead em ASCII quando lido. A variável é lida no momento da primeira leitura. Uma escrita configuraria o valor da variável, mas apenas no momento da primeira nova linha ser escrita ou de uma função fechar sendo executada. Para escrever a variável após a leitura ela, deve-se fechar o arquivo e reabri-lo para gravação. Este arquivo não é seekable.