1/*
  2 * Copyright(c) 2017 Intel Corporation. All rights reserved.
  3 *
  4 * This program is free software; you can redistribute it and/or modify
  5 * it under the terms of version 2 of the GNU General Public License as
  6 * published by the Free Software Foundation.
  7 *
  8 * This program is distributed in the hope that it will be useful, but
  9 * WITHOUT ANY WARRANTY; without even the implied warranty of
 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 11 * General Public License for more details.
 12 */
 13#include <linux/libnvdimm.h>
 14#include <linux/badblocks.h>
 15#include <linux/export.h>
 16#include <linux/module.h>
 17#include <linux/blkdev.h>
 18#include <linux/device.h>
 19#include <linux/ctype.h>
 20#include <linux/ndctl.h>
 21#include <linux/mutex.h>
 22#include <linux/slab.h>
 23#include <linux/io.h>
 24#include "nd-core.h"
 25#include "nd.h"
 26
 27void badrange_init(struct badrange *badrange)
 28{
 29	INIT_LIST_HEAD(&badrange->list);
 30	spin_lock_init(&badrange->lock);
 31}
 32EXPORT_SYMBOL_GPL(badrange_init);
 33
 34static void append_badrange_entry(struct badrange *badrange,
 35		struct badrange_entry *bre, u64 addr, u64 length)
 36{
 37	lockdep_assert_held(&badrange->lock);
 38	bre->start = addr;
 39	bre->length = length;
 40	list_add_tail(&bre->list, &badrange->list);
 41}
 42
 43static int alloc_and_append_badrange_entry(struct badrange *badrange,
 44		u64 addr, u64 length, gfp_t flags)
 45{
 46	struct badrange_entry *bre;
 47
 48	bre = kzalloc(sizeof(*bre), flags);
 49	if (!bre)
 50		return -ENOMEM;
 51
 52	append_badrange_entry(badrange, bre, addr, length);
 53	return 0;
 54}
 55
 56static int add_badrange(struct badrange *badrange, u64 addr, u64 length)
 57{
 58	struct badrange_entry *bre, *bre_new;
 59
 60	spin_unlock(&badrange->lock);
 61	bre_new = kzalloc(sizeof(*bre_new), GFP_KERNEL);
 62	spin_lock(&badrange->lock);
 63
 64	if (list_empty(&badrange->list)) {
 65		if (!bre_new)
 66			return -ENOMEM;
 67		append_badrange_entry(badrange, bre_new, addr, length);
 68		return 0;
 69	}
 70
 71	/*
 72	 * There is a chance this is a duplicate, check for those first.
 73	 * This will be the common case as ARS_STATUS returns all known
 74	 * errors in the SPA space, and we can't query it per region
 75	 */
 76	list_for_each_entry(bre, &badrange->list, list)
 77		if (bre->start == addr) {
 78			/* If length has changed, update this list entry */
 79			if (bre->length != length)
 80				bre->length = length;
 81			kfree(bre_new);
 82			return 0;
 83		}
 84
 85	/*
 86	 * If not a duplicate or a simple length update, add the entry as is,
 87	 * as any overlapping ranges will get resolved when the list is consumed
 88	 * and converted to badblocks
 89	 */
 90	if (!bre_new)
 91		return -ENOMEM;
 92	append_badrange_entry(badrange, bre_new, addr, length);
 93
 94	return 0;
 95}
 96
 97int badrange_add(struct badrange *badrange, u64 addr, u64 length)
 98{
 99	int rc;
100
101	spin_lock(&badrange->lock);
102	rc = add_badrange(badrange, addr, length);
103	spin_unlock(&badrange->lock);
104
105	return rc;
106}
107EXPORT_SYMBOL_GPL(badrange_add);
108
109void badrange_forget(struct badrange *badrange, phys_addr_t start,
110		unsigned int len)
111{
112	struct list_head *badrange_list = &badrange->list;
113	u64 clr_end = start + len - 1;
114	struct badrange_entry *bre, *next;
115
116	spin_lock(&badrange->lock);
117
118	/*
119	 * [start, clr_end] is the badrange interval being cleared.
120	 * [bre->start, bre_end] is the badrange_list entry we're comparing
121	 * the above interval against. The badrange list entry may need
122	 * to be modified (update either start or length), deleted, or
123	 * split into two based on the overlap characteristics
124	 */
125
126	list_for_each_entry_safe(bre, next, badrange_list, list) {
127		u64 bre_end = bre->start + bre->length - 1;
128
129		/* Skip intervals with no intersection */
130		if (bre_end < start)
131			continue;
132		if (bre->start >  clr_end)
133			continue;
134		/* Delete completely overlapped badrange entries */
135		if ((bre->start >= start) && (bre_end <= clr_end)) {
136			list_del(&bre->list);
137			kfree(bre);
138			continue;
139		}
140		/* Adjust start point of partially cleared entries */
141		if ((start <= bre->start) && (clr_end > bre->start)) {
142			bre->length -= clr_end - bre->start + 1;
143			bre->start = clr_end + 1;
144			continue;
145		}
146		/* Adjust bre->length for partial clearing at the tail end */
147		if ((bre->start < start) && (bre_end <= clr_end)) {
148			/* bre->start remains the same */
149			bre->length = start - bre->start;
150			continue;
151		}
152		/*
153		 * If clearing in the middle of an entry, we split it into
154		 * two by modifying the current entry to represent one half of
155		 * the split, and adding a new entry for the second half.
156		 */
157		if ((bre->start < start) && (bre_end > clr_end)) {
158			u64 new_start = clr_end + 1;
159			u64 new_len = bre_end - new_start + 1;
160
161			/* Add new entry covering the right half */
162			alloc_and_append_badrange_entry(badrange, new_start,
163					new_len, GFP_NOWAIT);
164			/* Adjust this entry to cover the left half */
165			bre->length = start - bre->start;
166			continue;
167		}
168	}
169	spin_unlock(&badrange->lock);
170}
171EXPORT_SYMBOL_GPL(badrange_forget);
172
173static void set_badblock(struct badblocks *bb, sector_t s, int num)
174{
175	dev_dbg(bb->dev, "Found a bad range (0x%llx, 0x%llx)\n",
176			(u64) s * 512, (u64) num * 512);
177	/* this isn't an error as the hardware will still throw an exception */
178	if (badblocks_set(bb, s, num, 1))
179		dev_info_once(bb->dev, "%s: failed for sector %llx\n",
180				__func__, (u64) s);
181}
182
183/**
184 * __add_badblock_range() - Convert a physical address range to bad sectors
185 * @bb:		badblocks instance to populate
186 * @ns_offset:	namespace offset where the error range begins (in bytes)
187 * @len:	number of bytes of badrange to be added
188 *
189 * This assumes that the range provided with (ns_offset, len) is within
190 * the bounds of physical addresses for this namespace, i.e. lies in the
191 * interval [ns_start, ns_start + ns_size)
192 */
193static void __add_badblock_range(struct badblocks *bb, u64 ns_offset, u64 len)
194{
195	const unsigned int sector_size = 512;
196	sector_t start_sector, end_sector;
197	u64 num_sectors;
198	u32 rem;
199
200	start_sector = div_u64(ns_offset, sector_size);
201	end_sector = div_u64_rem(ns_offset + len, sector_size, &rem);
202	if (rem)
203		end_sector++;
204	num_sectors = end_sector - start_sector;
205
206	if (unlikely(num_sectors > (u64)INT_MAX)) {
207		u64 remaining = num_sectors;
208		sector_t s = start_sector;
209
210		while (remaining) {
211			int done = min_t(u64, remaining, INT_MAX);
212
213			set_badblock(bb, s, done);
214			remaining -= done;
215			s += done;
216		}
217	} else
218		set_badblock(bb, start_sector, num_sectors);
219}
220
221static void badblocks_populate(struct badrange *badrange,
222		struct badblocks *bb, const struct resource *res)
223{
224	struct badrange_entry *bre;
225
226	if (list_empty(&badrange->list))
227		return;
228
229	list_for_each_entry(bre, &badrange->list, list) {
230		u64 bre_end = bre->start + bre->length - 1;
231
232		/* Discard intervals with no intersection */
233		if (bre_end < res->start)
234			continue;
235		if (bre->start >  res->end)
236			continue;
237		/* Deal with any overlap after start of the namespace */
238		if (bre->start >= res->start) {
239			u64 start = bre->start;
240			u64 len;
241
242			if (bre_end <= res->end)
243				len = bre->length;
244			else
245				len = res->start + resource_size(res)
246					- bre->start;
247			__add_badblock_range(bb, start - res->start, len);
248			continue;
249		}
250		/*
251		 * Deal with overlap for badrange starting before
252		 * the namespace.
253		 */
254		if (bre->start < res->start) {
255			u64 len;
256
257			if (bre_end < res->end)
258				len = bre->start + bre->length - res->start;
259			else
260				len = resource_size(res);
261			__add_badblock_range(bb, 0, len);
262		}
263	}
264}
265
266/**
267 * nvdimm_badblocks_populate() - Convert a list of badranges to badblocks
268 * @region: parent region of the range to interrogate
269 * @bb: badblocks instance to populate
270 * @res: resource range to consider
271 *
272 * The badrange list generated during bus initialization may contain
273 * multiple, possibly overlapping physical address ranges.  Compare each
274 * of these ranges to the resource range currently being initialized,
275 * and add badblocks entries for all matching sub-ranges
276 */
277void nvdimm_badblocks_populate(struct nd_region *nd_region,
278		struct badblocks *bb, const struct resource *res)
279{
280	struct nvdimm_bus *nvdimm_bus;
281
282	if (!is_memory(&nd_region->dev)) {
283		dev_WARN_ONCE(&nd_region->dev, 1,
284				"%s only valid for pmem regions\n", __func__);
285		return;
286	}
287	nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
288
289	nvdimm_bus_lock(&nvdimm_bus->dev);
290	badblocks_populate(&nvdimm_bus->badrange, bb, res);
291	nvdimm_bus_unlock(&nvdimm_bus->dev);
292}
293EXPORT_SYMBOL_GPL(nvdimm_badblocks_populate);