X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fptlrpc%2Fnrs_orr.c;h=8b5428c1a456fb9ffc73280f7f40d48779d67b86;hp=9af1564dc139e7d9e7de330e4e1fa08379fdbc8b;hb=46487b52695829f7befc1c382517ca2b4076453d;hpb=378cb9355e3d8e90f3da96e535eb343c7ab1b26b diff --git a/lustre/ptlrpc/nrs_orr.c b/lustre/ptlrpc/nrs_orr.c index 9af1564..8b5428c 100644 --- a/lustre/ptlrpc/nrs_orr.c +++ b/lustre/ptlrpc/nrs_orr.c @@ -20,7 +20,7 @@ * GPL HEADER END */ /* - * Copyright (c) 2011 Intel Corporation + * Copyright (c) 2013, Intel Corporation. * * Copyright 2012 Xyratex Technology Limited */ @@ -196,9 +196,9 @@ static void nrs_orr_range_fill_logical(struct niobuf_remote *nb, int niocount, struct nrs_orr_req_range *range) { /* Should we do this at page boundaries ? */ - range->or_start = nb[0].offset & CFS_PAGE_MASK; - range->or_end = (nb[niocount - 1].offset + - nb[niocount - 1].len - 1) | ~CFS_PAGE_MASK; + range->or_start = nb[0].rnb_offset & CFS_PAGE_MASK; + range->or_end = (nb[niocount - 1].rnb_offset + + nb[niocount - 1].rnb_len - 1) | ~CFS_PAGE_MASK; } /** @@ -378,28 +378,28 @@ static void nrs_orr_genobjname(struct ptlrpc_nrs_policy *policy, char *name) */ #define NRS_ORR_BITS 24 #define NRS_ORR_BKT_BITS 12 -#define NRS_ORR_HASH_FLAGS (CFS_HASH_RW_BKTLOCK | CFS_HASH_ASSERT_EMPTY) +#define NRS_ORR_HASH_FLAGS (CFS_HASH_SPIN_BKTLOCK | CFS_HASH_ASSERT_EMPTY) #define NRS_TRR_BITS 4 #define NRS_TRR_BKT_BITS 2 -#define NRS_TRR_HASH_FLAGS CFS_HASH_RW_BKTLOCK +#define NRS_TRR_HASH_FLAGS CFS_HASH_SPIN_BKTLOCK static unsigned nrs_orr_hop_hash(cfs_hash_t *hs, const void *key, unsigned mask) { return cfs_hash_djb2_hash(key, sizeof(struct nrs_orr_key), mask); } -static void *nrs_orr_hop_key(cfs_hlist_node_t *hnode) +static void *nrs_orr_hop_key(struct hlist_node *hnode) { - struct nrs_orr_object *orro = cfs_hlist_entry(hnode, + struct nrs_orr_object *orro = hlist_entry(hnode, struct nrs_orr_object, oo_hnode); return &orro->oo_key; } -static int nrs_orr_hop_keycmp(const void *key, cfs_hlist_node_t *hnode) +static int nrs_orr_hop_keycmp(const void *key, struct hlist_node *hnode) { - struct nrs_orr_object *orro = cfs_hlist_entry(hnode, + struct nrs_orr_object *orro = hlist_entry(hnode, struct nrs_orr_object, oo_hnode); @@ -407,88 +407,75 @@ static int nrs_orr_hop_keycmp(const void *key, cfs_hlist_node_t *hnode) &((struct nrs_orr_key *)key)->ok_fid); } -static void *nrs_orr_hop_object(cfs_hlist_node_t *hnode) +static void *nrs_orr_hop_object(struct hlist_node *hnode) { - return cfs_hlist_entry(hnode, struct nrs_orr_object, oo_hnode); + return hlist_entry(hnode, struct nrs_orr_object, oo_hnode); } -static void nrs_orr_hop_get(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +static void nrs_orr_hop_get(cfs_hash_t *hs, struct hlist_node *hnode) { - struct nrs_orr_object *orro = cfs_hlist_entry(hnode, + struct nrs_orr_object *orro = hlist_entry(hnode, struct nrs_orr_object, oo_hnode); - cfs_atomic_inc(&orro->oo_ref); + orro->oo_ref++; } /** * Removes an nrs_orr_object the hash and frees its memory, if the object has * no active users. */ -static void nrs_orr_hop_put_free(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +static void nrs_orr_hop_put_free(cfs_hash_t *hs, struct hlist_node *hnode) { - struct nrs_orr_object *orro = cfs_hlist_entry(hnode, + struct nrs_orr_object *orro = hlist_entry(hnode, struct nrs_orr_object, oo_hnode); struct nrs_orr_data *orrd = container_of(orro->oo_res.res_parent, struct nrs_orr_data, od_res); - cfs_hash_bd_t bds[2]; + cfs_hash_bd_t bd; - if (cfs_atomic_dec_return(&orro->oo_ref) > 1) - return; + cfs_hash_bd_get_and_lock(hs, &orro->oo_key, &bd, 1); - cfs_hash_lock(hs, 0); - cfs_hash_dual_bd_get_and_lock(hs, &orro->oo_key, bds, 1); + if (--orro->oo_ref > 1) { + cfs_hash_bd_unlock(hs, &bd, 1); - /** - * Another thread may have won the race and taken a reference on the - * nrs_orr_object. - */ - if (cfs_atomic_read(&orro->oo_ref) > 1) - goto lost_race; + return; + } + LASSERT(orro->oo_ref == 1); - if (bds[1].bd_bucket == NULL) - cfs_hash_bd_del_locked(hs, &bds[0], hnode); - else - hnode = cfs_hash_dual_bd_finddel_locked(hs, bds, &orro->oo_key, - hnode); - LASSERT(hnode != NULL); + cfs_hash_bd_del_locked(hs, &bd, hnode); + cfs_hash_bd_unlock(hs, &bd, 1); OBD_SLAB_FREE_PTR(orro, orrd->od_cache); - -lost_race: - - cfs_hash_dual_bd_unlock(hs, bds, 1); - cfs_hash_unlock(hs, 0); } -static void nrs_orr_hop_put(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +static void nrs_orr_hop_put(cfs_hash_t *hs, struct hlist_node *hnode) { - struct nrs_orr_object *orro = cfs_hlist_entry(hnode, + struct nrs_orr_object *orro = hlist_entry(hnode, struct nrs_orr_object, oo_hnode); - cfs_atomic_dec(&orro->oo_ref); + orro->oo_ref--; } -static int nrs_trr_hop_keycmp(const void *key, cfs_hlist_node_t *hnode) +static int nrs_trr_hop_keycmp(const void *key, struct hlist_node *hnode) { - struct nrs_orr_object *orro = cfs_hlist_entry(hnode, + struct nrs_orr_object *orro = hlist_entry(hnode, struct nrs_orr_object, oo_hnode); return orro->oo_key.ok_idx == ((struct nrs_orr_key *)key)->ok_idx; } -static void nrs_trr_hop_exit(cfs_hash_t *hs, cfs_hlist_node_t *hnode) +static void nrs_trr_hop_exit(cfs_hash_t *hs, struct hlist_node *hnode) { - struct nrs_orr_object *orro = cfs_hlist_entry(hnode, + struct nrs_orr_object *orro = hlist_entry(hnode, struct nrs_orr_object, oo_hnode); struct nrs_orr_data *orrd = container_of(orro->oo_res.res_parent, struct nrs_orr_data, od_res); - LASSERTF(cfs_atomic_read(&orro->oo_ref) == 0, - "Busy NRS TRR policy object for OST with index %u, with %d " - "refs\n", orro->oo_key.ok_idx, cfs_atomic_read(&orro->oo_ref)); + LASSERTF(orro->oo_ref == 0, + "Busy NRS TRR policy object for OST with index %u, with %ld " + "refs\n", orro->oo_key.ok_idx, orro->oo_ref); OBD_SLAB_FREE_PTR(orro, orrd->od_cache); } @@ -554,9 +541,9 @@ static int orr_req_compare(cfs_binheap_node_t *e1, cfs_binheap_node_t *e2) * backend-fs object (for ORR policy instances) or OST (for TRR policy * instances). */ - if (nrq1->nr_u.orr.or_sequence < nrq2->nr_u.crr.cr_sequence) + if (nrq1->nr_u.orr.or_sequence < nrq2->nr_u.orr.or_sequence) return 1; - else if (nrq1->nr_u.orr.or_sequence > nrq2->nr_u.crr.cr_sequence) + else if (nrq1->nr_u.orr.or_sequence > nrq2->nr_u.orr.or_sequence) return 0; /** @@ -595,7 +582,8 @@ static cfs_binheap_ops_t nrs_orr_heap_ops = { /** * Prints a warning message if an ORR/TRR policy is started on a service with - * more than one CPT. + * more than one CPT. Not printed on the console for now, since we don't + * have any performance metrics in the first place, and it is annoying. * * \param[in] policy the policy instance * @@ -603,16 +591,13 @@ static cfs_binheap_ops_t nrs_orr_heap_ops = { */ static int nrs_orr_init(struct ptlrpc_nrs_policy *policy) { - if (policy->pol_nrs->nrs_svcpt->scp_service->srv_ncpts > 1) { - bool is_orr = strncmp(policy->pol_desc->pd_name, - NRS_POL_NAME_ORR, NRS_POL_NAME_MAX) == 0; - - CWARN("A%s %s NRS policy has been registered on a PTLRPC " - "service which has more than one service partition. " - "Please be advised that this policy may perform better " - "on services with only one partition.\n", - is_orr ? "n" : "", policy->pol_desc->pd_name); - } + if (policy->pol_nrs->nrs_svcpt->scp_service->srv_ncpts > 1) + CDEBUG(D_CONFIG, "%s: The %s NRS policy was registered on a " + "service with multiple service partitions. This policy " + "may perform better with a single partition.\n", + policy->pol_nrs->nrs_svcpt->scp_service->srv_name, + policy->pol_desc->pd_name); + return 0; } @@ -624,7 +609,7 @@ static int nrs_orr_init(struct ptlrpc_nrs_policy *policy) * \retval -ENOMEM OOM error * \retval 0 success */ -static int nrs_orr_start(struct ptlrpc_nrs_policy *policy) +static int nrs_orr_start(struct ptlrpc_nrs_policy *policy, char *arg) { struct nrs_orr_data *orrd; cfs_hash_ops_t *ops; @@ -654,9 +639,9 @@ static int nrs_orr_start(struct ptlrpc_nrs_policy *policy) /** * Slab cache for NRS ORR/TRR objects. */ - orrd->od_cache = cfs_mem_cache_create(orrd->od_objname, - sizeof(struct nrs_orr_object), - 0, 0); + orrd->od_cache = kmem_cache_create(orrd->od_objname, + sizeof(struct nrs_orr_object), + 0, 0, NULL); if (orrd->od_cache == NULL) GOTO(failed, rc = -ENOMEM); @@ -704,7 +689,7 @@ static int nrs_orr_start(struct ptlrpc_nrs_policy *policy) failed: if (orrd->od_cache) { - rc = cfs_mem_cache_destroy(orrd->od_cache); + kmem_cache_destroy(orrd->od_cache); LASSERTF(rc == 0, "Could not destroy od_cache slab\n"); } if (orrd->od_binheap != NULL) @@ -737,7 +722,7 @@ static void nrs_orr_stop(struct ptlrpc_nrs_policy *policy) cfs_binheap_destroy(orrd->od_binheap); cfs_hash_putref(orrd->od_obj_hash); - cfs_mem_cache_destroy(orrd->od_cache); + kmem_cache_destroy(orrd->od_cache); OBD_FREE_PTR(orrd); } @@ -750,8 +735,8 @@ static void nrs_orr_stop(struct ptlrpc_nrs_policy *policy) * \param[in] opc the opcode * \param[in,out] arg used for passing parameters and information * - * \pre spin_is_locked(&policy->pol_nrs->->nrs_lock) - * \post spin_is_locked(&policy->pol_nrs->->nrs_lock) + * \pre assert_spin_locked(&policy->pol_nrs->->nrs_lock) + * \post assert_spin_locked(&policy->pol_nrs->->nrs_lock) * * \retval 0 operation carried successfully * \retval -ve error @@ -759,9 +744,9 @@ static void nrs_orr_stop(struct ptlrpc_nrs_policy *policy) int nrs_orr_ctl(struct ptlrpc_nrs_policy *policy, enum ptlrpc_nrs_ctl opc, void *arg) { - LASSERT(spin_is_locked(&policy->pol_nrs->nrs_lock)); + assert_spin_locked(&policy->pol_nrs->nrs_lock); - switch(opc) { + switch((enum nrs_ctl_orr)opc) { default: RETURN(-EINVAL); @@ -884,13 +869,12 @@ int nrs_orr_res_get(struct ptlrpc_nrs_policy *policy, OBD_SLAB_CPT_ALLOC_PTR_GFP(orro, orrd->od_cache, nrs_pol2cptab(policy), nrs_pol2cptid(policy), - (moving_req ? CFS_ALLOC_ATOMIC : - CFS_ALLOC_IO)); + moving_req ? GFP_ATOMIC : GFP_NOFS); if (orro == NULL) RETURN(-ENOMEM); orro->oo_key = key; - cfs_atomic_set(&orro->oo_ref, 1); + orro->oo_ref = 1; tmp = cfs_hash_findadd_unique(orrd->od_obj_hash, &orro->oo_key, &orro->oo_hnode); @@ -1088,8 +1072,8 @@ static int nrs_orr_req_add(struct ptlrpc_nrs_policy *policy, orro->oo_quantum = orrd->od_quantum; } - nrq->nr_u.crr.cr_round = orro->oo_round; - nrq->nr_u.crr.cr_sequence = orro->oo_sequence; + nrq->nr_u.orr.or_round = orro->oo_round; + nrq->nr_u.orr.or_sequence = orro->oo_sequence; rc = cfs_binheap_insert(orrd->od_binheap, &nrq->nr_node); if (rc == 0) { @@ -1210,15 +1194,13 @@ struct nrs_lprocfs_orr_data { * XXX: the CRR-N version of this, ptlrpc_lprocfs_rd_nrs_crrn_quantum() is * almost identical; it can be reworked and then reused for ORR/TRR. */ -static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, - off_t off, int count, int *eof, - void *data) +static int +ptlrpc_lprocfs_nrs_orr_quantum_seq_show(struct seq_file *m, void *data) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; __u16 quantum; int rc; - int rc2 = 0; /** * Perform two separate calls to this as only one of the NRS heads' @@ -1230,9 +1212,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, NRS_CTL_ORR_RD_QUANTUM, true, &quantum); if (rc == 0) { - *eof = 1; - rc2 = snprintf(page, count, NRS_LPROCFS_QUANTUM_NAME_REG - "%-5d\n", quantum); + seq_printf(m, NRS_LPROCFS_QUANTUM_NAME_REG "%-5d\n", quantum); /** * Ignore -ENODEV as the regular NRS head's policy may be in the * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1253,9 +1233,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, orr_data->name, NRS_CTL_ORR_RD_QUANTUM, true, &quantum); if (rc == 0) { - *eof = 1; - rc2 += snprintf(page + rc2, count - rc2, - NRS_LPROCFS_QUANTUM_NAME_HP"%-5d\n", quantum); + seq_printf(m, NRS_LPROCFS_QUANTUM_NAME_HP"%-5d\n", quantum); /** * Ignore -ENODEV as the high priority NRS head's policy may be * in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1266,7 +1244,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_quantum(char *page, char **start, no_hp: - return rc2 ? : rc; + return rc; } /** @@ -1295,11 +1273,12 @@ no_hp: * XXX: the CRR-N version of this, ptlrpc_lprocfs_wr_nrs_crrn_quantum() is * almost identical; it can be reworked and then reused for ORR/TRR. */ -static int ptlrpc_lprocfs_wr_nrs_orr_quantum(struct file *file, - const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_nrs_orr_quantum_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct seq_file *m = file->private_data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum ptlrpc_nrs_queue_type queue = 0; char kernbuf[LPROCFS_NRS_WR_QUANTUM_MAX_CMD]; @@ -1307,14 +1286,14 @@ static int ptlrpc_lprocfs_wr_nrs_orr_quantum(struct file *file, long quantum_reg; long quantum_hp; /** lprocfs_find_named_value() modifies its argument, so keep a copy */ - unsigned long count_copy; + size_t count_copy; int rc = 0; int rc2 = 0; if (count > (sizeof(kernbuf) - 1)) return -EINVAL; - if (cfs_copy_from_user(kernbuf, buffer, count)) + if (copy_from_user(kernbuf, buffer, count)) return -EFAULT; kernbuf[count] = '\0'; @@ -1404,6 +1383,7 @@ static int ptlrpc_lprocfs_wr_nrs_orr_quantum(struct file *file, return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_quantum); #define LPROCFS_NRS_OFF_NAME_REG "reg_offset_type:" #define LPROCFS_NRS_OFF_NAME_HP "hp_offset_type:" @@ -1425,15 +1405,13 @@ static int ptlrpc_lprocfs_wr_nrs_orr_quantum(struct file *file, * reg_offset_type:physical * hp_offset_type:logical */ -static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, - off_t off, int count, int *eof, - void *data) +static int +ptlrpc_lprocfs_nrs_orr_offset_type_seq_show(struct seq_file *m, void *data) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; bool physical; int rc; - int rc2 = 0; /** * Perform two separate calls to this as only one of the NRS heads' @@ -1444,11 +1422,9 @@ static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, orr_data->name, NRS_CTL_ORR_RD_OFF_TYPE, true, &physical); if (rc == 0) { - *eof = 1; - rc2 = snprintf(page, count, - LPROCFS_NRS_OFF_NAME_REG"%s\n", - physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : - LPROCFS_NRS_OFF_NAME_LOGICAL); + seq_printf(m, LPROCFS_NRS_OFF_NAME_REG"%s\n", + physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : + LPROCFS_NRS_OFF_NAME_LOGICAL); /** * Ignore -ENODEV as the regular NRS head's policy may be in the * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1469,11 +1445,9 @@ static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, orr_data->name, NRS_CTL_ORR_RD_OFF_TYPE, true, &physical); if (rc == 0) { - *eof = 1; - rc2 += snprintf(page + rc2, count - rc2, - LPROCFS_NRS_OFF_NAME_HP"%s\n", - physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : - LPROCFS_NRS_OFF_NAME_LOGICAL); + seq_printf(m, LPROCFS_NRS_OFF_NAME_HP"%s\n", + physical ? LPROCFS_NRS_OFF_NAME_PHYSICAL : + LPROCFS_NRS_OFF_NAME_LOGICAL); /** * Ignore -ENODEV as the high priority NRS head's policy may be * in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1483,8 +1457,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_offset_type(char *page, char **start, } no_hp: - - return rc2 ? : rc; + return rc; } /** @@ -1513,12 +1486,13 @@ no_hp: * policy instances in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state are * are skipped later by nrs_orr_ctl(). */ -static int ptlrpc_lprocfs_wr_nrs_orr_offset_type(struct file *file, - const char *buffer, - unsigned long count, - void *data) +static ssize_t +ptlrpc_lprocfs_nrs_orr_offset_type_seq_write(struct file *file, + const char *buffer, size_t count, + loff_t *off) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct seq_file *m = file->private_data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum ptlrpc_nrs_queue_type queue = 0; char kernbuf[LPROCFS_NRS_WR_OFF_TYPE_MAX_CMD]; @@ -1526,14 +1500,14 @@ static int ptlrpc_lprocfs_wr_nrs_orr_offset_type(struct file *file, char *val_hp; bool physical_reg; bool physical_hp; - unsigned long count_copy; + size_t count_copy; int rc = 0; int rc2 = 0; if (count > (sizeof(kernbuf) - 1)) return -EINVAL; - if (cfs_copy_from_user(kernbuf, buffer, count)) + if (copy_from_user(kernbuf, buffer, count)) return -EFAULT; kernbuf[count] = '\0'; @@ -1628,6 +1602,7 @@ static int ptlrpc_lprocfs_wr_nrs_orr_offset_type(struct file *file, return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_offset_type); #define NRS_LPROCFS_REQ_SUPP_NAME_REG "reg_supported:" #define NRS_LPROCFS_REQ_SUPP_NAME_HP "hp_supported:" @@ -1686,15 +1661,13 @@ static enum nrs_orr_supp nrs_orr_str2supp(const char *val) * reg_supported:reads * hp_supported:reads_and_writes */ -static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, - off_t off, int count, int *eof, - void *data) +static int +ptlrpc_lprocfs_nrs_orr_supported_seq_show(struct seq_file *m, void *data) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum nrs_orr_supp supported; int rc; - int rc2 = 0; /** * Perform two separate calls to this as only one of the NRS heads' @@ -1707,10 +1680,8 @@ static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, &supported); if (rc == 0) { - *eof = 1; - rc2 = snprintf(page, count, - NRS_LPROCFS_REQ_SUPP_NAME_REG"%s\n", - nrs_orr_supp2str(supported)); + seq_printf(m, NRS_LPROCFS_REQ_SUPP_NAME_REG"%s\n", + nrs_orr_supp2str(supported)); /** * Ignore -ENODEV as the regular NRS head's policy may be in the * ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1732,10 +1703,8 @@ static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, NRS_CTL_ORR_RD_SUPP_REQ, true, &supported); if (rc == 0) { - *eof = 1; - rc2 += snprintf(page + rc2, count - rc2, - NRS_LPROCFS_REQ_SUPP_NAME_HP"%s\n", - nrs_orr_supp2str(supported)); + seq_printf(m, NRS_LPROCFS_REQ_SUPP_NAME_HP"%s\n", + nrs_orr_supp2str(supported)); /** * Ignore -ENODEV as the high priority NRS head's policy may be * in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state. @@ -1746,7 +1715,7 @@ static int ptlrpc_lprocfs_rd_nrs_orr_supported(char *page, char **start, no_hp: - return rc2 ? : rc; + return rc; } /** @@ -1776,11 +1745,13 @@ no_hp: * policy instances in the ptlrpc_nrs_pol_state::NRS_POL_STATE_STOPPED state are * are skipped later by nrs_orr_ctl(). */ -static int ptlrpc_lprocfs_wr_nrs_orr_supported(struct file *file, - const char *buffer, - unsigned long count, void *data) +static ssize_t +ptlrpc_lprocfs_nrs_orr_supported_seq_write(struct file *file, + const char *buffer, size_t count, + loff_t *off) { - struct nrs_lprocfs_orr_data *orr_data = data; + struct seq_file *m = file->private_data; + struct nrs_lprocfs_orr_data *orr_data = m->private; struct ptlrpc_service *svc = orr_data->svc; enum ptlrpc_nrs_queue_type queue = 0; char kernbuf[LPROCFS_NRS_WR_REQ_SUPP_MAX_CMD]; @@ -1788,14 +1759,14 @@ static int ptlrpc_lprocfs_wr_nrs_orr_supported(struct file *file, char *val_hp; enum nrs_orr_supp supp_reg; enum nrs_orr_supp supp_hp; - unsigned long count_copy; + size_t count_copy; int rc = 0; int rc2 = 0; if (count > (sizeof(kernbuf) - 1)) return -EINVAL; - if (cfs_copy_from_user(kernbuf, buffer, count)) + if (copy_from_user(kernbuf, buffer, count)) return -EFAULT; kernbuf[count] = '\0'; @@ -1881,22 +1852,19 @@ static int ptlrpc_lprocfs_wr_nrs_orr_supported(struct file *file, return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count; } +LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_orr_supported); int nrs_orr_lprocfs_init(struct ptlrpc_service *svc) { - int rc; int i; - struct lprocfs_vars nrs_orr_lprocfs_vars[] = { + struct lprocfs_seq_vars nrs_orr_lprocfs_vars[] = { { .name = "nrs_orr_quantum", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_quantum, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_quantum }, + .fops = &ptlrpc_lprocfs_nrs_orr_quantum_fops }, { .name = "nrs_orr_offset_type", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_offset_type, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_offset_type }, + .fops = &ptlrpc_lprocfs_nrs_orr_offset_type_fops }, { .name = "nrs_orr_supported", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_supported, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_supported }, + .fops = &ptlrpc_lprocfs_nrs_orr_supported_fops }, { NULL } }; @@ -1908,9 +1876,7 @@ int nrs_orr_lprocfs_init(struct ptlrpc_service *svc) for (i = 0; i < ARRAY_SIZE(nrs_orr_lprocfs_vars); i++) nrs_orr_lprocfs_vars[i].data = &lprocfs_orr_data; - rc = lprocfs_add_vars(svc->srv_procroot, nrs_orr_lprocfs_vars, NULL); - - return rc; + return lprocfs_seq_add_vars(svc->srv_procroot, nrs_orr_lprocfs_vars, NULL); } void nrs_orr_lprocfs_fini(struct ptlrpc_service *svc) @@ -1962,16 +1928,13 @@ int nrs_trr_lprocfs_init(struct ptlrpc_service *svc) int rc; int i; - struct lprocfs_vars nrs_trr_lprocfs_vars[] = { + struct lprocfs_seq_vars nrs_trr_lprocfs_vars[] = { { .name = "nrs_trr_quantum", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_quantum, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_quantum }, + .fops = &ptlrpc_lprocfs_nrs_orr_quantum_fops }, { .name = "nrs_trr_offset_type", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_offset_type, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_offset_type }, + .fops = &ptlrpc_lprocfs_nrs_orr_offset_type_fops }, { .name = "nrs_trr_supported", - .read_fptr = ptlrpc_lprocfs_rd_nrs_orr_supported, - .write_fptr = ptlrpc_lprocfs_wr_nrs_orr_supported }, + .fops = &ptlrpc_lprocfs_nrs_orr_supported_fops }, { NULL } }; @@ -1983,7 +1946,7 @@ int nrs_trr_lprocfs_init(struct ptlrpc_service *svc) for (i = 0; i < ARRAY_SIZE(nrs_trr_lprocfs_vars); i++) nrs_trr_lprocfs_vars[i].data = &lprocfs_trr_data; - rc = lprocfs_add_vars(svc->srv_procroot, nrs_trr_lprocfs_vars, NULL); + rc = lprocfs_seq_add_vars(svc->srv_procroot, nrs_trr_lprocfs_vars, NULL); return rc; }