* Re: [PATCH v2] Bluetooth: bcm203x: Fix race condition on disconnect
From: Gustavo Padovan @ 2011-10-31 19:54 UTC (permalink / raw)
To: David Herrmann; +Cc: linux-bluetooth, marcel
In-Reply-To: <1319620393-11127-1-git-send-email-dh.herrmann@googlemail.com>
Hi David,
* David Herrmann <dh.herrmann@googlemail.com> [2011-10-26 11:13:13 +0200]:
> When disconnecting a bcm203x device we kill and destroy the usb-urb, however,
> there might still be a pending work-structure which resubmits the now invalid
> urb. To avoid this race condition, we simply set a shutdown-flag and
> synchronously kill the worker first.
>
> This also adds a comment to all schedule_work()s, as it is really not clear
> that they are used as replacement for short timers (which can be seen in the git
> history).
>
> Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
> ---
> V2: Remove memory barriers
>
> drivers/bluetooth/bcm203x.c | 10 ++++++++++
> 1 files changed, 10 insertions(+), 0 deletions(-)
Applied, thanks.
Gustavo
^ permalink raw reply
* [patch 1/1] drivers/net/ethernet/i825xx/3c505.c: fix build with dynamic debug
From: akpm @ 2011-10-31 19:54 UTC (permalink / raw)
To: davem; +Cc: netdev, akpm, akpm, jbaron, philb
From: Andrew Morton <akpm@google.com>
Subject: drivers/net/ethernet/i825xx/3c505.c: fix build with dynamic debug
The `#define filename' screws up the expansion of
DEFINE_DYNAMIC_DEBUG_METADATA:
drivers/net/ethernet/i825xx/3c505.c: In function 'send_pcb':
drivers/net/ethernet/i825xx/3c505.c:390: error: expected identifier before string constant
drivers/net/ethernet/i825xx/3c505.c:390: error: expected '}' before '.' token
drivers/net/ethernet/i825xx/3c505.c:436: error: expected identifier before string constant
drivers/net/ethernet/i825xx/3c505.c:435: error: expected '}' before '.' token
drivers/net/ethernet/i825xx/3c505.c: In function 'start_receive':
drivers/net/ethernet/i825xx/3c505.c:557: error: expected identifier before string constant
drivers/net/ethernet/i825xx/3c505.c:557: error: expected '}' before '.' token
drivers/net/ethernet/i825xx/3c505.c: In function 'receive_packet':
drivers/net/ethernet/i825xx/3c505.c:629: error: expected identifier before string constant
etc
So remove that #define and "open-code" it.
Cc: Philip Blundell <philb@gnu.org>
Cc: David Miller <davem@davemloft.net>
Cc: Jason Baron <jbaron@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
---
drivers/net/ethernet/i825xx/3c505.c | 6 ++----
1 file changed, 2 insertions(+), 4 deletions(-)
diff -puN drivers/net/ethernet/i825xx/3c505.c~drivers-net-ethernet-i825xx-3c505c-fix-build-with-dynamic-debug drivers/net/ethernet/i825xx/3c505.c
--- a/drivers/net/ethernet/i825xx/3c505.c~drivers-net-ethernet-i825xx-3c505c-fix-build-with-dynamic-debug
+++ a/drivers/net/ethernet/i825xx/3c505.c
@@ -126,15 +126,13 @@
*
*********************************************************/
-#define filename __FILE__
-
#define timeout_msg "*** timeout at %s:%s (line %d) ***\n"
#define TIMEOUT_MSG(lineno) \
- pr_notice(timeout_msg, filename, __func__, (lineno))
+ pr_notice(timeout_msg, __FILE__, __func__, (lineno))
#define invalid_pcb_msg "*** invalid pcb length %d at %s:%s (line %d) ***\n"
#define INVALID_PCB_MSG(len) \
- pr_notice(invalid_pcb_msg, (len), filename, __func__, __LINE__)
+ pr_notice(invalid_pcb_msg, (len), __FILE__, __func__, __LINE__)
#define search_msg "%s: Looking for 3c505 adapter at address %#x..."
_
^ permalink raw reply
* [PATCH] fat: Spelling s/obsolate/obsolete/g
From: Geert Uytterhoeven @ 2011-10-31 19:50 UTC (permalink / raw)
To: OGAWA Hirofumi, Jiri Kosina; +Cc: linux-kernel, Geert Uytterhoeven
Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org>
---
fs/fat/inode.c | 26 +++++++++++++-------------
1 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 1726d73..66cec01 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -898,7 +898,7 @@ enum {
Opt_charset, Opt_shortname_lower, Opt_shortname_win95,
Opt_shortname_winnt, Opt_shortname_mixed, Opt_utf8_no, Opt_utf8_yes,
Opt_uni_xl_no, Opt_uni_xl_yes, Opt_nonumtail_no, Opt_nonumtail_yes,
- Opt_obsolate, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
+ Opt_obsolete, Opt_flush, Opt_tz_utc, Opt_rodir, Opt_err_cont,
Opt_err_panic, Opt_err_ro, Opt_discard, Opt_err,
};
@@ -928,17 +928,17 @@ static const match_table_t fat_tokens = {
{Opt_err_panic, "errors=panic"},
{Opt_err_ro, "errors=remount-ro"},
{Opt_discard, "discard"},
- {Opt_obsolate, "conv=binary"},
- {Opt_obsolate, "conv=text"},
- {Opt_obsolate, "conv=auto"},
- {Opt_obsolate, "conv=b"},
- {Opt_obsolate, "conv=t"},
- {Opt_obsolate, "conv=a"},
- {Opt_obsolate, "fat=%u"},
- {Opt_obsolate, "blocksize=%u"},
- {Opt_obsolate, "cvf_format=%20s"},
- {Opt_obsolate, "cvf_options=%100s"},
- {Opt_obsolate, "posix"},
+ {Opt_obsolete, "conv=binary"},
+ {Opt_obsolete, "conv=text"},
+ {Opt_obsolete, "conv=auto"},
+ {Opt_obsolete, "conv=b"},
+ {Opt_obsolete, "conv=t"},
+ {Opt_obsolete, "conv=a"},
+ {Opt_obsolete, "fat=%u"},
+ {Opt_obsolete, "blocksize=%u"},
+ {Opt_obsolete, "cvf_format=%20s"},
+ {Opt_obsolete, "cvf_options=%100s"},
+ {Opt_obsolete, "posix"},
{Opt_err, NULL},
};
static const match_table_t msdos_tokens = {
@@ -1170,7 +1170,7 @@ static int parse_options(struct super_block *sb, char *options, int is_vfat,
break;
/* obsolete mount options */
- case Opt_obsolate:
+ case Opt_obsolete:
fat_msg(sb, KERN_INFO, "\"%s\" option is obsolete, "
"not supported now", p);
break;
--
1.7.0.4
^ permalink raw reply related
* [Bug 31961] [drm:drm_crtc_helper_set_config] *ERROR* failed to set mode on [CRTC:6]
From: bugzilla-daemon-CC+yJ3UmIYqDUpFQwHEjaQ @ 2011-10-31 19:47 UTC (permalink / raw)
To: nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW
In-Reply-To: <bug-31961-8800-V0hAGp6uBxMKqLRl/0Ahz6D7qz1kEfGD2LY78lusg7I@public.gmane.org/>
https://bugs.freedesktop.org/show_bug.cgi?id=31961
--- Comment #10 from Alex <alex.aycinena-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> 2011-10-31 12:47:52 PDT ---
I have an HP Pavilion s7700n with GeForce 6150 LE.
--
Configure bugmail: https://bugs.freedesktop.org/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
You are the assignee for the bug.
^ permalink raw reply
* Re: [PATCH 2/2] Bluetooth: Make hci_unregister_dev return void
From: Gustavo Padovan @ 2011-10-31 19:46 UTC (permalink / raw)
To: David Herrmann; +Cc: linux-bluetooth, marcel
In-Reply-To: <1319618599-10938-2-git-send-email-dh.herrmann@googlemail.com>
Hi David,
* David Herrmann <dh.herrmann@googlemail.com> [2011-10-26 10:43:19 +0200]:
> hci_unregister_dev cannot fail and always returns 0. The drivers already ignore
> the return value so we can safely make it return void.
>
> Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
> ---
> include/net/bluetooth/hci_core.h | 2 +-
> net/bluetooth/hci_core.c | 4 +---
> 2 files changed, 2 insertions(+), 4 deletions(-)
Nice work, both patches have been applied. Thanks.
Gustavo
^ permalink raw reply
* [Bug 31961] [drm:drm_crtc_helper_set_config] *ERROR* failed to set mode on [CRTC:6]
From: bugzilla-daemon-CC+yJ3UmIYqDUpFQwHEjaQ @ 2011-10-31 19:45 UTC (permalink / raw)
To: nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW
In-Reply-To: <bug-31961-8800-V0hAGp6uBxMKqLRl/0Ahz6D7qz1kEfGD2LY78lusg7I@public.gmane.org/>
https://bugs.freedesktop.org/show_bug.cgi?id=31961
--- Comment #9 from Alex <alex.aycinena-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> 2011-10-31 12:45:31 PDT ---
Created attachment 52967
--> https://bugs.freedesktop.org/attachment.cgi?id=52967
dmesg with drm.debug=1 set
--
Configure bugmail: https://bugs.freedesktop.org/userprefs.cgi?tab=email
------- You are receiving this mail because: -------
You are the assignee for the bug.
^ permalink raw reply
* Re: [Intel-gfx] [PATCH 1/2] Give up on edid retries when i2c tells us that bus is not there
From: Chris Wilson @ 2011-10-31 19:45 UTC (permalink / raw)
To: intel-gfx; +Cc: dri-devel, Eugeni Dodonov
In-Reply-To: <1318857150-2117-2-git-send-email-eugeni.dodonov@intel.com>
On Mon, 17 Oct 2011 11:12:29 -0200, Eugeni Dodonov <eugeni.dodonov@intel.com> wrote:
> This allows to avoid talking to a non-existent bus repeatedly until we
> finally timeout. The non-existent bus is signalled by -ENXIO error,
> provided by i2c_algo_bit:bit_doAddress call.
>
> As the advantage of such change, all the other routines which use
> drm_get_edid would benefit for this timeout.
>
> This change should fix
> https://bugs.freedesktop.org/show_bug.cgi?id=41059 and improve overall
> edid detection timing by 10-30% in most cases, and by a much larger margin
> in case of phantom outputs.
>
> Signed-off-by: Eugeni Dodonov <eugeni.dodonov@intel.com>
Looks like we have reached the conclusion that this simple patch is the
least likely to cause problems and easiest to fix if it does. :)
Reviewed-by: Chris Wilson <chris@hchris-wilson.co.uk>
-Chris
--
Chris Wilson, Intel Open Source Technology Centre
^ permalink raw reply
* Re: [Qemu-devel] [PATCH 13/25] vmstate: port ppc cpu
From: Juan Quintela @ 2011-10-31 19:43 UTC (permalink / raw)
To: Alexander Graf; +Cc: aliguori, qemu-devel
In-Reply-To: <BDF4683B-DAF8-4B6A-83B7-5FA2FEE7125E@suse.de>
Alexander Graf <agraf@suse.de> wrote:
> On 25.10.2011, at 16:00, Juan Quintela wrote:
>
>> Added sdr1_vmstate because storing the value requires calling ppc_store_sdr1().
>> The position when the function is called also changes (I think it is save).
>
> Thanks for converting this. I'm fairly sure that vmsave is broken atm anyways and that someone will have to go through all the fields and make sure they're still working properly. However you're definitely not making the situation worse, so here's only a small comment:
>
>>
>> Signed-off-by: Juan Quintela <quintela@redhat.com>
>> CC: Alexander Graf <agraf@suse.de>
>> ---
>> target-ppc/cpu.h | 4 +-
>> target-ppc/machine.c | 245 ++++++++++++++++++--------------------------------
>> 2 files changed, 89 insertions(+), 160 deletions(-)
>>
>> + VMSTATE_UINTTL_ARRAY(spr, CPUState, 1024),
>
> Shouldn't sizeof(((CPUState*)NULL)->spr / sizeof(target_ulong)) work as size field?
vmstate is inconsistent about this.
It "calculates" sizes for "strings" (ar uint8_t * if your preffer), but
not for arrays.
#define VMSTATE_BUFFER_V(_f, _s, _v) \
VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f)))
#define VMSTATE_BUFFER(_f, _s) \
VMSTATE_BUFFER_V(_f, _s, 0)
And I don't know what the "right" solution is:
- Putting explicit size helps detect changes on that size (good)
- But, on lots of places, we are putting there a constant:
VMSTATE_INT32_ARRAY(tx_fifo, smc91c111_state, NUM_PACKETS),
So, we are not going to detect changes either.
Next on my plate is to get someway of unittesting and being able to
detect this kind of changes (then we can actually drop the sizes
always).
Later, Juan.
^ permalink raw reply
* Re: [Qemu-devel] [PATCH v2 2/4] softfloat: Avoid uint16 type conflict on Darwin
From: Peter Maydell @ 2011-10-31 19:42 UTC (permalink / raw)
To: Andreas Färber; +Cc: Juan Pineda, qemu-devel
In-Reply-To: <1320088682-12958-3-git-send-email-andreas.faerber@web.de>
On 31 October 2011 19:18, Andreas Färber <andreas.faerber@web.de> wrote:
> --- a/fpu/softfloat.h
> +++ b/fpu/softfloat.h
> @@ -54,6 +54,9 @@ these four paragraphs for those parts of this code that are retained.
> | to the same as `int'.
> *----------------------------------------------------------------------------*/
> typedef uint8_t flag;
> +#ifdef __APPLE__
> +#define uint16 qemu_uint16
> +#endif
> typedef uint8_t uint8;
> typedef int8_t int8;
> #ifndef _AIX
I hate this, but I don't think I quite hate it enough to leave compilation
on Macs broken in 1.0...
Ideally we should just make a decision about whether we want option
(1) or (2) from
http://permalink.gmane.org/gmane.comp.emulators.qemu/115848
-- PMM
^ permalink raw reply
* Re: bigalloc and max file size
From: Ted Ts'o @ 2011-10-31 19:38 UTC (permalink / raw)
To: Coly Li
Cc: Andreas Dilger, Andreas Dilger, linux-ext4 development,
Alex Zhuravlev, Tao Ma, hao.bigrat@gmail.com
In-Reply-To: <4EAEDD56.6000709@coly.li>
On Tue, Nov 01, 2011 at 01:39:34AM +0800, Coly Li wrote:
> In some application, we allocate a big file which occupies most space of a file system, while the file system built on
> (expensive) SSD. In such configuration, we want less blocks allocated for inode table and bitmap. If the max extent
> length could be much big, there is chance to have much less block groups, which results more blocks for regular file.
> Current bigalloc code does well already, but there is still chance to do better. The sys-admin team believe
> cluster-based-extent can help Ext4 to consume as less meta data memory as raw disk does, and gain as more available data
> blocks as raw disks does, too. This is a small number on one single SSD, but in our cluster environment, this effort can
> help to save a recognized amount of capex.
OK, but you're not running into the 16TB file size limitation, are
you? That would be a lot of SSD's. I assume the issue then is you
want to minimize the number of extents, limited by the 15-bit extent
length field?
What cluster size are you thinking about? And how do you plan to
initialize it? Via fallocate, or by explicitly writing zeros to the
whole file (so all of the blocks are marked as initialzied? Is it
going to be sparse file?
- Ted
^ permalink raw reply
* Re: [PATCH 4/5] ib/core: add support for extended performance counters in sysfs
From: Roland Dreier @ 2011-10-31 19:38 UTC (permalink / raw)
To: Or Gerlitz; +Cc: linux-rdma
In-Reply-To: <alpine.LRH.2.00.1110101055570.11243-VYr5/9ddeaGSIdy2EShu12Xnswh1EIUO@public.gmane.org>
On Mon, Oct 10, 2011 at 1:56 AM, Or Gerlitz <ogerlitz-VPRAkNaXOzVWk0Htik3J/w@public.gmane.org> wrote:
> +static struct attribute_group pma_ext_group = {
> + .name = "counters_ext",
> + .attrs = pma_attrs_ext
> +};
Sorry for the late review here, but does it seem like the best
approach to have a separate "counters_ext" directory for
some subset of performance counters? Instead we could
have two attribute_groups, one the basic counters and one
the basic and extended counters, and basically do
if (is_pma_class_cap_ext_width(device, port_num) == 0)
sysfs_create_group(...basic and extended counters...)
else
sysfs_create_group(...basic counters...)
(by the way, is_pma_class_cap_ext_width() seems backwards
since it returns 0 for true. How about bool pma_has_ext_width()
and have it return true if the extended counters ARE supported?)
Or is there some reason why users would want to make the
distinction between basic and extended counters?
- R.
--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply
* Re: [PATCH v2] Bluetooth: ath3k: Use GFP_KERNEL instead of GFP_ATOMIC
From: Gustavo Padovan @ 2011-10-31 19:38 UTC (permalink / raw)
To: David Herrmann; +Cc: linux-bluetooth
In-Reply-To: <1319537392-4993-1-git-send-email-dh.herrmann@googlemail.com>
Hi David,
* David Herrmann <dh.herrmann@googlemail.com> [2011-10-25 12:09:52 +0200]:
> We are allowed to sleep here so no need to use GFP_ATOMIC. The caller
> (ath3k_probe) calls request_firmware() which definitely sleeps. Hence, we should
> avoid using GFP_ATOMIC.
>
> Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
> ---
> V2: This fixes both occurences of GFP_ATOMIC in one patch.
>
> drivers/bluetooth/ath3k.c | 4 ++--
> 1 files changed, 2 insertions(+), 2 deletions(-)
Applied, thanks.
Gustavo
^ permalink raw reply
* [U-Boot] Pull request for u-boot-marvell.git
From: Albert ARIBAUD @ 2011-10-31 19:35 UTC (permalink / raw)
To: u-boot
In-Reply-To: <F766E4F80769BD478052FB6533FA745D1A14DD88BA@SC-VEXCH4.marvell.com>
Hi Prafulla,
Le 31/10/2011 12:58, Prafulla Wadaskar a ?crit :
> Hi Albert
> Please pull
>
> The following changes since commit b3fee4e17f9f2c136b8fcfc1b7e575b6b3ccd66a:
> Anatolij Gustschin (1):
> ARM: dreamplug: fix compilation
>
> are available in the git repository at:
>
> u-boot-marvell.git ..BRANCH.NOT.VERIFIED..
Seems like you did the 'git request-pull' before updating
u-boot-marvell/master. :)
> Ajay Bhargav (1):
> gplugD: Fix for error:MACH_TYPE_SHEEVAD undeclared
>
> Holger Brunck (2):
> arm/km: add variable waitforne to mgcoge3un
> arm/km/mgcoge3un: enhance "waitforne" feature
>
> Michael Walle (1):
> kirkwood: define CONFIG_SYS_CACHELINE_SIZE
>
> Mike Frysinger (1):
> kirkwood: drop empty asm-offsets.s file
>
> arch/arm/include/asm/arch-kirkwood/config.h | 3 ++-
> board/keymile/km_arm/km_arm.c | 11 ++++++++++-
> include/configs/gplugd.h | 12 +++++++++++-
> include/configs/mgcoge3un.h | 2 ++
> 4 files changed, 25 insertions(+), 3 deletions(-)
> delete mode 100644 arch/arm/cpu/arm926ejs/kirkwood/asm-offsets.s
Applied to u-boot-arm/master, thanks!
> Regards...
> Prafulla . . .
Amicalement,
--
Albert.
^ permalink raw reply
* custom monitor formats
From: William Moss @ 2011-10-31 19:34 UTC (permalink / raw)
To: nouveau-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW
I recently updated from OpenSUSE 11.3 to 11.4.
The proprietary Nvidia driver will no longer work, even the latest
NVIDIA...run.
I removed it and set up nouveau, which works fine except it ignores my
customized
/etc/xorg.conf.d files and sets my monitor to 1024x768.
The monitor, an ACER AL1916W should be run at 1440x900 and this is the
preferred
mode (modeline) in the configuration files. This is how it worked with the
NVIDIA
drivers and should be still true.
Apparently, the nouveau module (driver) is ignoring the settings in the
/etc/xorg.d/50-device.conf and the associated conf files that are bound
in the server conf file.
I tested the setup with
xinit -- :0
which works but at the incorrect resolution.
I even tried a customized and compiled 3.0.4 Kernel, to no avail.
Any help would be appreciated.
I have no problem with compiling and installing or even modifying source.
--
Using Opera's revolutionary e-mail client: http://www.opera.com/mail/
^ permalink raw reply
* Re: [PATCH] Bluetooth: Add support for Broadcom BCM20702A0.
From: Gustavo Padovan @ 2011-10-31 19:33 UTC (permalink / raw)
To: Jesse Sung; +Cc: linux-bluetooth, 854399
In-Reply-To: <4E7840CF.5010805@canonical.com>
Hi Jesse,
* Jesse Sung <jesse.sung@canonical.com> [2011-09-20 15:29:19 +0800]:
> Add a new entry (413c:8197) to device ID table.
Can I get the output of usbdevices in the commit message, please. Then we can
prove that adding it to the device ID table is really necessary.
Gustavo
^ permalink raw reply
* Re: [PATCH 08/11] ttm: Provide DMA aware TTM page pool code.
From: Jerome Glisse @ 2011-10-31 19:37 UTC (permalink / raw)
To: Konrad Rzeszutek Wilk
Cc: linux-kernel, dri-devel, thellstrom, thomas, airlied, xen-devel,
j.glisse, bskeggs
In-Reply-To: <1319062772-2793-9-git-send-email-konrad.wilk@oracle.com>
On Wed, Oct 19, 2011 at 06:19:29PM -0400, Konrad Rzeszutek Wilk wrote:
> In TTM world the pages for the graphic drivers are kept in three different
> pools: write combined, uncached, and cached (write-back). When the pages
> are used by the graphic driver the graphic adapter via its built in MMU
> (or AGP) programs these pages in. The programming requires the virtual address
> (from the graphic adapter perspective) and the physical address (either System RAM
> or the memory on the card) which is obtained using the pci_map_* calls (which does the
> virtual to physical - or bus address translation). During the graphic application's
> "life" those pages can be shuffled around, swapped out to disk, moved from the
> VRAM to System RAM or vice-versa. This all works with the existing TTM pool code
> - except when we want to use the software IOTLB (SWIOTLB) code to "map" the physical
> addresses to the graphic adapter MMU. We end up programming the bounce buffer's
> physical address instead of the TTM pool memory's and get a non-worky driver.
> There are two solutions:
> 1) using the DMA API to allocate pages that are screened by the DMA API, or
> 2) using the pci_sync_* calls to copy the pages from the bounce-buffer and back.
>
> This patch fixes the issue by allocating pages using the DMA API. The second
> is a viable option - but it has performance drawbacks and potential correctness
> issues - think of the write cache page being bounced (SWIOTLB->TTM), the
> WC is set on the TTM page and the copy from SWIOTLB not making it to the TTM
> page until the page has been recycled in the pool (and used by another application).
>
> The bounce buffer does not get activated often - only in cases where we have
> a 32-bit capable card and we want to use a page that is allocated above the
> 4GB limit. The bounce buffer offers the solution of copying the contents
> of that 4GB page to an location below 4GB and then back when the operation has been
> completed (or vice-versa). This is done by using the 'pci_sync_*' calls.
> Note: If you look carefully enough in the existing TTM page pool code you will
> notice the GFP_DMA32 flag is used - which should guarantee that the provided page
> is under 4GB. It certainly is the case, except this gets ignored in two cases:
> - If user specifies 'swiotlb=force' which bounces _every_ page.
> - If user is using a Xen's PV Linux guest (which uses the SWIOTLB and the
> underlaying PFN's aren't necessarily under 4GB).
>
> To not have this extra copying done the other option is to allocate the pages
> using the DMA API so that there is not need to map the page and perform the
> expensive 'pci_sync_*' calls.
>
> This DMA API capable TTM pool requires for this the 'struct device' to
> properly call the DMA API. It also has to track the virtual and bus address of
> the page being handed out in case it ends up being swapped out or de-allocated -
> to make sure it is de-allocated using the proper's 'struct device'.
>
> Implementation wise the code keeps two lists: one that is attached to the
> 'struct device' (via the dev->dma_pools list) and a global one to be used when
> the 'struct device' is unavailable (think shrinker code). The global list can
> iterate over all of the 'struct device' and its associated dma_pool. The list
> in dev->dma_pools can only iterate the device's dma_pool.
> /[struct device_pool]\
> /---------------------------------------------------| dev |
> / +-------| dma_pool |
> /-----+------\ / \--------------------/
> |struct device| /-->[struct dma_pool for WC]</ /[struct device_pool]\
> | dma_pools +----+ /-| dev |
> | ... | \--->[struct dma_pool for uncached]<-/--| dma_pool |
> \-----+------/ / \--------------------/
> \----------------------------------------------/
> [Two pools associated with the device (WC and UC), and the parallel list
> containing the 'struct dev' and 'struct dma_pool' entries]
>
> The maximum amount of dma pools a device can have is six: write-combined,
> uncached, and cached; then there are the DMA32 variants which are:
> write-combined dma32, uncached dma32, and cached dma32.
>
> Currently this code only gets activated when any variant of the SWIOTLB IOMMU
> code is running (Intel without VT-d, AMD without GART, IBM Calgary and Xen PV
> with PCI devices).
>
> Tested-by: Michel Dänzer <michel@daenzer.net>
> [v1: Using swiotlb_nr_tbl instead of swiotlb_enabled]
> [v2: Major overhaul - added 'inuse_list' to seperate used from inuse and reorder
> the order of lists to get better performance.]
> Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> ---
> drivers/gpu/drm/ttm/Makefile | 3 +
> drivers/gpu/drm/ttm/ttm_memory.c | 2 +
> drivers/gpu/drm/ttm/ttm_page_alloc_dma.c | 1394 ++++++++++++++++++++++++++++++
> include/drm/ttm/ttm_page_alloc.h | 31 +
> 4 files changed, 1430 insertions(+), 0 deletions(-)
> create mode 100644 drivers/gpu/drm/ttm/ttm_page_alloc_dma.c
>
> diff --git a/drivers/gpu/drm/ttm/Makefile b/drivers/gpu/drm/ttm/Makefile
> index f3cf6f0..8300bc0 100644
> --- a/drivers/gpu/drm/ttm/Makefile
> +++ b/drivers/gpu/drm/ttm/Makefile
> @@ -7,4 +7,7 @@ ttm-y := ttm_agp_backend.o ttm_memory.o ttm_tt.o ttm_bo.o \
> ttm_object.o ttm_lock.o ttm_execbuf_util.o ttm_page_alloc.o \
> ttm_bo_manager.o
>
> +ifeq ($(CONFIG_SWIOTLB),y)
> +ttm-y += ttm_page_alloc_dma.o
> +endif
> obj-$(CONFIG_DRM_TTM) += ttm.o
> diff --git a/drivers/gpu/drm/ttm/ttm_memory.c b/drivers/gpu/drm/ttm/ttm_memory.c
> index e70ddd8..6d24fe2 100644
> --- a/drivers/gpu/drm/ttm/ttm_memory.c
> +++ b/drivers/gpu/drm/ttm/ttm_memory.c
> @@ -395,6 +395,7 @@ int ttm_mem_global_init(struct ttm_mem_global *glob)
> zone->name, (unsigned long long) zone->max_mem >> 10);
> }
> ttm_page_alloc_init(glob, glob->zone_kernel->max_mem/(2*PAGE_SIZE));
> + ttm_dma_page_alloc_init(glob, glob->zone_kernel->max_mem/(2*PAGE_SIZE));
> return 0;
> out_no_zone:
> ttm_mem_global_release(glob);
> @@ -410,6 +411,7 @@ void ttm_mem_global_release(struct ttm_mem_global *glob)
> /* let the page allocator first stop the shrink work. */
> ttm_page_alloc_fini();
>
> + ttm_dma_page_alloc_fini();
> flush_workqueue(glob->swap_queue);
> destroy_workqueue(glob->swap_queue);
> glob->swap_queue = NULL;
> diff --git a/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c b/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c
> new file mode 100644
> index 0000000..d6d8240
> --- /dev/null
> +++ b/drivers/gpu/drm/ttm/ttm_page_alloc_dma.c
> @@ -0,0 +1,1394 @@
> +/*
> + * Copyright 2011 (c) Oracle Corp.
> +
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sub license,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the
> + * next paragraph) shall be included in all copies or substantial portions
> + * of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> + * DEALINGS IN THE SOFTWARE.
> + *
> + * Author: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> + */
> +
> +/*
> + * A simple DMA pool losely based on dmapool.c. It has certain advantages
> + * over the DMA pools:
> + * - Pool collects resently freed pages for reuse (and hooks up to
> + * the shrinker).
> + * - Tracks currently in use pages
> + * - Tracks whether the page is UC, WB or cached (and reverts to WB
> + * when freed).
> + */
> +
> +#include <linux/dma-mapping.h>
> +#include <linux/list.h>
> +#include <linux/seq_file.h> /* for seq_printf */
> +#include <linux/slab.h>
> +#include <linux/spinlock.h>
> +#include <linux/highmem.h>
> +#include <linux/mm_types.h>
> +#include <linux/module.h>
> +#include <linux/mm.h>
> +#include <linux/atomic.h>
> +#include <linux/device.h>
> +#include <linux/kthread.h>
> +#include "ttm/ttm_bo_driver.h"
> +#include "ttm/ttm_page_alloc.h"
> +#ifdef TTM_HAS_AGP
> +#include <asm/agp.h>
> +#endif
> +
> +#define NUM_PAGES_TO_ALLOC (PAGE_SIZE/sizeof(struct page *))
> +#define SMALL_ALLOCATION 16
> +#define FREE_ALL_PAGES (~0U)
> +/* times are in msecs */
> +#define IS_UNDEFINED (0)
> +#define IS_WC (1<<1)
> +#define IS_UC (1<<2)
> +#define IS_CACHED (1<<3)
> +#define IS_DMA32 (1<<4)
> +
> +enum pool_type {
> + POOL_IS_UNDEFINED,
> + POOL_IS_WC = IS_WC,
> + POOL_IS_UC = IS_UC,
> + POOL_IS_CACHED = IS_CACHED,
> + POOL_IS_WC_DMA32 = IS_WC | IS_DMA32,
> + POOL_IS_UC_DMA32 = IS_UC | IS_DMA32,
> + POOL_IS_CACHED_DMA32 = IS_CACHED | IS_DMA32,
> +};
> +/*
> + * The pool structure. There are usually six pools:
> + * - generic (not restricted to DMA32):
> + * - write combined, uncached, cached.
> + * - dma32 (up to 2^32 - so up 4GB):
> + * - write combined, uncached, cached.
> + * for each 'struct device'. The 'cached' is for pages that are actively used.
> + * The other ones can be shrunk by the shrinker API if neccessary.
> + * @pools: The 'struct device->dma_pools' link.
> + * @type: Type of the pool
> + * @lock: Protects the inuse_list and free_list from concurrnet access. Must be
> + * used with irqsave/irqrestore variants because pool allocator maybe called
> + * from delayed work.
> + * @inuse_list: Pool of pages that are in use. The order is very important and
> + * it is in the order that the TTM pages that are put back are in.
> + * @free_list: Pool of pages that are free to be used. No order requirements.
> + * @dev: The device that is associated with these pools.
> + * @size: Size used during DMA allocation.
> + * @npages_free: Count of available pages for re-use.
> + * @npages_in_use: Count of pages that are in use (each of them
> + * is marked in_use.
> + * @nfrees: Stats when pool is shrinking.
> + * @nrefills: Stats when the pool is grown.
> + * @gfp_flags: Flags to pass for alloc_page.
> + * @fill_lock: Allows only one pool fill operation at time.
> + * @name: Name of the pool.
> + * @dev_name: Name derieved from dev - similar to how dev_info works.
> + * Used during shutdown as the dev_info during release is unavailable.
> + */
> +struct dma_pool {
> + struct list_head pools; /* The 'struct device->dma_pools link */
> + enum pool_type type;
> + spinlock_t lock;
> + struct list_head inuse_list;
> + struct list_head free_list;
> + struct device *dev;
> + unsigned size;
> + unsigned npages_free;
> + unsigned npages_in_use;
> + unsigned long nfrees; /* Stats when shrunk. */
> + unsigned long nrefills; /* Stats when grown. */
> + gfp_t gfp_flags;
> + bool fill_lock;
> + char name[13]; /* "cached dma32" */
> + char dev_name[64]; /* Constructed from dev */
> +};
> +
> +/*
> + * The accounting page keeping track of the allocated page along with
> + * the DMA address.
> + * @page_list: The link to the 'page_list' in 'struct dma_pool'.
> + * @vaddr: The virtual address of the page
> + * @dma: The bus address of the page. If the page is not allocated
> + * via the DMA API, it will be -1.
> + * @in_use: Set to true if in use. Should not be freed.
> + */
> +struct dma_page {
> + struct list_head page_list;
> + void *vaddr;
> + struct page *p;
> + dma_addr_t dma;
> +};
> +
> +/*
> + * Limits for the pool. They are handled without locks because only place where
> + * they may change is in sysfs store. They won't have immediate effect anyway
> + * so forcing serialization to access them is pointless.
> + */
> +
> +struct ttm_pool_opts {
> + unsigned alloc_size;
> + unsigned max_size;
> + unsigned small;
> +};
> +
> +/*
> + * Contains the list of all of the 'struct device' and their corresponding
> + * DMA pools. Guarded by _mutex->lock.
> + * @pools: The link to 'struct ttm_pool_manager->pools'
> + * @dev: The 'struct device' associated with the 'pool'
> + * @pool: The 'struct dma_pool' associated with the 'dev'
> + */
> +struct device_pools {
> + struct list_head pools;
> + struct device *dev;
> + struct dma_pool *pool;
> +};
> +
> +/*
> + * struct ttm_pool_manager - Holds memory pools for fast allocation
> + *
> + * @lock: Lock used when adding/removing from pools
> + * @pools: List of 'struct device' and 'struct dma_pool' tuples.
> + * @options: Limits for the pool.
> + * @npools: Total amount of pools in existence.
> + * @shrinker: The structure used by [un|]register_shrinker
> + */
> +struct ttm_pool_manager {
> + struct mutex lock;
> + struct list_head pools;
> + struct ttm_pool_opts options;
> + unsigned npools;
> + struct shrinker mm_shrink;
> + struct kobject kobj;
> +};
> +
> +static struct ttm_pool_manager *_manager;
> +
> +static struct attribute ttm_page_pool_max = {
> + .name = "pool_max_size",
> + .mode = S_IRUGO | S_IWUSR
> +};
> +static struct attribute ttm_page_pool_small = {
> + .name = "pool_small_allocation",
> + .mode = S_IRUGO | S_IWUSR
> +};
> +static struct attribute ttm_page_pool_alloc_size = {
> + .name = "pool_allocation_size",
> + .mode = S_IRUGO | S_IWUSR
> +};
> +
> +static struct attribute *ttm_pool_attrs[] = {
> + &ttm_page_pool_max,
> + &ttm_page_pool_small,
> + &ttm_page_pool_alloc_size,
> + NULL
> +};
> +
> +static void ttm_pool_kobj_release(struct kobject *kobj)
> +{
> + struct ttm_pool_manager *m =
> + container_of(kobj, struct ttm_pool_manager, kobj);
> + kfree(m);
> +}
> +
> +static ssize_t ttm_pool_store(struct kobject *kobj, struct attribute *attr,
> + const char *buffer, size_t size)
> +{
> + struct ttm_pool_manager *m =
> + container_of(kobj, struct ttm_pool_manager, kobj);
> + int chars;
> + unsigned val;
> + chars = sscanf(buffer, "%u", &val);
> + if (chars == 0)
> + return size;
> +
> + /* Convert kb to number of pages */
> + val = val / (PAGE_SIZE >> 10);
> +
> + if (attr == &ttm_page_pool_max)
> + m->options.max_size = val;
> + else if (attr == &ttm_page_pool_small)
> + m->options.small = val;
> + else if (attr == &ttm_page_pool_alloc_size) {
> + if (val > NUM_PAGES_TO_ALLOC*8) {
> + printk(KERN_ERR TTM_PFX
> + "Setting allocation size to %lu "
> + "is not allowed. Recommended size is "
> + "%lu\n",
> + NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 7),
> + NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));
> + return size;
> + } else if (val > NUM_PAGES_TO_ALLOC) {
> + printk(KERN_WARNING TTM_PFX
> + "Setting allocation size to "
> + "larger than %lu is not recommended.\n",
> + NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));
> + }
> + m->options.alloc_size = val;
> + }
> +
> + return size;
> +}
> +
> +static ssize_t ttm_pool_show(struct kobject *kobj, struct attribute *attr,
> + char *buffer)
> +{
> + struct ttm_pool_manager *m =
> + container_of(kobj, struct ttm_pool_manager, kobj);
> + unsigned val = 0;
> +
> + if (attr == &ttm_page_pool_max)
> + val = m->options.max_size;
> + else if (attr == &ttm_page_pool_small)
> + val = m->options.small;
> + else if (attr == &ttm_page_pool_alloc_size)
> + val = m->options.alloc_size;
> +
> + val = val * (PAGE_SIZE >> 10);
> +
> + return snprintf(buffer, PAGE_SIZE, "%u\n", val);
> +}
> +
> +static const struct sysfs_ops ttm_pool_sysfs_ops = {
> + .show = &ttm_pool_show,
> + .store = &ttm_pool_store,
> +};
> +
> +static struct kobj_type ttm_pool_kobj_type = {
> + .release = &ttm_pool_kobj_release,
> + .sysfs_ops = &ttm_pool_sysfs_ops,
> + .default_attrs = ttm_pool_attrs,
> +};
> +
> +#ifndef CONFIG_X86
> +static int set_pages_array_wb(struct page **pages, int addrinarray)
> +{
> +#ifdef TTM_HAS_AGP
> + int i;
> +
> + for (i = 0; i < addrinarray; i++)
> + unmap_page_from_agp(pages[i]);
> +#endif
> + return 0;
> +}
> +
> +static int set_pages_array_wc(struct page **pages, int addrinarray)
> +{
> +#ifdef TTM_HAS_AGP
> + int i;
> +
> + for (i = 0; i < addrinarray; i++)
> + map_page_into_agp(pages[i]);
> +#endif
> + return 0;
> +}
> +
> +static int set_pages_array_uc(struct page **pages, int addrinarray)
> +{
> +#ifdef TTM_HAS_AGP
> + int i;
> +
> + for (i = 0; i < addrinarray; i++)
> + map_page_into_agp(pages[i]);
> +#endif
> + return 0;
> +}
> +#endif /* for !CONFIG_X86 */
> +
> +static int ttm_set_pages_caching(struct dma_pool *pool,
> + struct page **pages, unsigned cpages)
> +{
> + int r = 0;
> + /* Set page caching */
> + if (pool->type & IS_UC) {
> + r = set_pages_array_uc(pages, cpages);
> + if (r)
> + pr_err(TTM_PFX
> + "%s: Failed to set %d pages to uc!\n",
> + pool->dev_name, cpages);
> + }
> + if (pool->type & IS_WC) {
> + r = set_pages_array_wc(pages, cpages);
> + if (r)
> + pr_err(TTM_PFX
> + "%s: Failed to set %d pages to wc!\n",
> + pool->dev_name, cpages);
> + }
> + return r;
> +}
> +
> +static void __ttm_dma_free_page(struct dma_pool *pool, struct dma_page *d_page)
> +{
> + dma_addr_t dma = d_page->dma;
> + dma_free_coherent(pool->dev, pool->size, d_page->vaddr, dma);
> +
> + kfree(d_page);
> + d_page = NULL;
> +}
> +static struct dma_page *__ttm_dma_alloc_page(struct dma_pool *pool)
> +{
> + struct dma_page *d_page;
> +
> + d_page = kmalloc(sizeof(struct dma_page), GFP_KERNEL);
> + if (!d_page)
> + return NULL;
> +
> + d_page->vaddr = dma_alloc_coherent(pool->dev, pool->size,
> + &d_page->dma,
> + pool->gfp_flags);
> + d_page->p = virt_to_page(d_page->vaddr);
> + if (!d_page->vaddr) {
> + kfree(d_page);
> + d_page = NULL;
> + }
Move d_page->p = virt_to_page(d_page->vaddr); after if (!d_page->vaddr)
block.
> + return d_page;
> +}
> +static enum pool_type ttm_to_type(int flags, enum ttm_caching_state cstate)
> +{
> + enum pool_type type = IS_UNDEFINED;
> +
> + if (flags & TTM_PAGE_FLAG_DMA32)
> + type |= IS_DMA32;
> + if (cstate == tt_cached)
> + type |= IS_CACHED;
> + else if (cstate == tt_uncached)
> + type |= IS_UC;
> + else
> + type |= IS_WC;
> +
> + return type;
> +}
> +static void ttm_pool_update_free_locked(struct dma_pool *pool,
> + unsigned freed_pages)
> +{
> + pool->npages_free -= freed_pages;
> + pool->nfrees += freed_pages;
> +
> +}
> +/* set memory back to wb and free the pages. */
> +static void ttm_dma_pages_put(struct dma_pool *pool, struct list_head *d_pages,
> + struct page *pages[], unsigned npages)
> +{
> + struct dma_page *d_page, *tmp;
> +
> + if (npages && set_pages_array_wb(pages, npages))
> + pr_err(TTM_PFX "%s: Failed to set %d pages to wb!\n",
> + pool->dev_name, npages);
> +
> + if (npages > 1) {
> + pr_debug("%s: (%s:%d) Freeing %d pages at once (lockless).\n",
> + pool->dev_name, pool->name, current->pid, npages);
> + }
> +
> + list_for_each_entry_safe(d_page, tmp, d_pages, page_list) {
> + list_del(&d_page->page_list);
> + __ttm_dma_free_page(pool, d_page);
> + }
> +}
> +/*
> + * Free pages from pool.
> + *
> + * To prevent hogging the ttm_swap process we only free NUM_PAGES_TO_ALLOC
> + * number of pages in one go.
> + *
> + * @pool: to free the pages from
> + * @nr_free: If set to true will free all pages in pool
> + **/
> +static unsigned ttm_dma_page_pool_free(struct dma_pool *pool, unsigned nr_free)
> +{
> + unsigned long irq_flags;
> + struct dma_page *dma_p, *tmp;
> + struct page **pages_to_free;
> + struct list_head d_pages;
> + unsigned freed_pages = 0,
> + npages_to_free = nr_free;
> +
> + if (NUM_PAGES_TO_ALLOC < nr_free)
> + npages_to_free = NUM_PAGES_TO_ALLOC;
> +#if 0
> + if (nr_free > 1) {
> + pr_debug("%s: (%s:%d) Attempting to free %d (%d) pages\n",
> + pool->dev_name, pool->name, current->pid,
> + npages_to_free, nr_free);
> + }
> +#endif
> + pages_to_free = kmalloc(npages_to_free * sizeof(struct page *),
> + GFP_KERNEL);
> +
> + if (!pages_to_free) {
> + pr_err(TTM_PFX
> + "%s: Failed to allocate memory for pool free operation.\n",
> + pool->dev_name);
> + return 0;
> + }
> + INIT_LIST_HEAD(&d_pages);
> +restart:
> + spin_lock_irqsave(&pool->lock, irq_flags);
> +
> + /* We picking the oldest ones off the list */
> + list_for_each_entry_safe_reverse(dma_p, tmp, &pool->free_list,
> + page_list) {
> + if (freed_pages >= npages_to_free)
> + break;
> +
> + /* Move the dma_page from one list to another. */
> + list_move(&dma_p->page_list, &d_pages);
> +
> + pages_to_free[freed_pages++] = dma_p->p;
> + /* We can only remove NUM_PAGES_TO_ALLOC at a time. */
> + if (freed_pages >= NUM_PAGES_TO_ALLOC) {
> +
> + ttm_pool_update_free_locked(pool, freed_pages);
> + /**
> + * Because changing page caching is costly
> + * we unlock the pool to prevent stalling.
> + */
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> +
> + ttm_dma_pages_put(pool, &d_pages, pages_to_free,
> + freed_pages);
> +
> + INIT_LIST_HEAD(&d_pages);
> +
> + if (likely(nr_free != FREE_ALL_PAGES))
> + nr_free -= freed_pages;
> +
> + if (NUM_PAGES_TO_ALLOC >= nr_free)
> + npages_to_free = nr_free;
> + else
> + npages_to_free = NUM_PAGES_TO_ALLOC;
> +
> + freed_pages = 0;
> +
> + /* free all so restart the processing */
> + if (nr_free)
> + goto restart;
> +
> + /* Not allowed to fall through or break because
> + * following context is inside spinlock while we are
> + * outside here.
> + */
> + goto out;
> +
> + }
> + }
> +
> + /* remove range of pages from the pool */
> + if (freed_pages) {
> + ttm_pool_update_free_locked(pool, freed_pages);
> + nr_free -= freed_pages;
> + }
> +
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> +
> + if (freed_pages)
> + ttm_dma_pages_put(pool, &d_pages, pages_to_free, freed_pages);
> +out:
> + kfree(pages_to_free);
> + return nr_free;
> +}
> +
> +static void ttm_dma_free_pool(struct device *dev, enum pool_type type)
> +{
> + struct device_pools *p;
> + struct dma_pool *pool;
> + struct dma_page *d_page, *d_tmp;
> +
> + if (!dev)
> + return;
> +
> + mutex_lock(&_manager->lock);
> + list_for_each_entry_reverse(p, &_manager->pools, pools) {
> + if (p->dev != dev)
> + continue;
> + pool = p->pool;
> + if (pool->type != type)
> + continue;
> +
> + list_del(&p->pools);
> + kfree(p);
> + _manager->npools--;
> + break;
> + }
> + list_for_each_entry_reverse(pool, &dev->dma_pools, pools) {
> + unsigned long irq_save;
> + if (pool->type != type)
> + continue;
> + /* Takes a spinlock.. */
> + ttm_dma_page_pool_free(pool, FREE_ALL_PAGES);
> + /* .. but afterwards we can take it too */
> + spin_lock_irqsave(&pool->lock, irq_save);
> + list_for_each_entry_safe(d_page, d_tmp, &pool->inuse_list,
> + page_list) {
> + pr_err("%s: (%s:%d) %p (%p DMA:0x%lx) busy!\n",
> + pool->dev_name, pool->name,
> + current->pid, d_page->vaddr,
> + virt_to_page(d_page->vaddr),
> + (unsigned long)d_page->dma);
> + list_del(&d_page->page_list);
> + kfree(d_page);
> + pool->npages_in_use--;
> + }
> + spin_unlock_irqrestore(&pool->lock, irq_save);
> + WARN_ON(((pool->npages_in_use + pool->npages_free) != 0));
> + /* This code path is called after _all_ references to the
> + * struct device has been dropped - so nobody should be
> + * touching it. In case somebody is trying to _add_ we are
> + * guarded by the mutex. */
> + list_del(&pool->pools);
> + kfree(pool);
> + break;
> + }
> + mutex_unlock(&_manager->lock);
> +}
> +/*
> + * On free-ing of the 'struct device' this deconstructor is run.
> + * Albeit the pool might have already been freed earlier.
> + */
> +static void ttm_dma_pool_release(struct device *dev, void *res)
> +{
> + struct dma_pool *pool = *(struct dma_pool **)res;
> +
> + if (pool)
> + ttm_dma_free_pool(dev, pool->type);
> +}
> +
> +static int ttm_dma_pool_match(struct device *dev, void *res, void *match_data)
> +{
> + return *(struct dma_pool **)res == match_data;
> +}
> +
> +static struct dma_pool *ttm_dma_pool_init(struct device *dev, gfp_t flags,
> + enum pool_type type)
> +{
> + char *n[] = {"wc", "uc", "cached", " dma32", "unknown",};
> + enum pool_type t[] = {IS_WC, IS_UC, IS_CACHED, IS_DMA32, IS_UNDEFINED};
> + struct device_pools *sec_pool = NULL;
> + struct dma_pool *pool = NULL, **ptr;
> + unsigned i;
> + int ret = -ENODEV;
> + char *p;
> +
> + if (!dev)
> + return NULL;
> +
> + ptr = devres_alloc(ttm_dma_pool_release, sizeof(*ptr), GFP_KERNEL);
> + if (!ptr)
> + return NULL;
> +
> + ret = -ENOMEM;
> +
> + pool = kmalloc_node(sizeof(struct dma_pool), GFP_KERNEL,
> + dev_to_node(dev));
> + if (!pool)
> + goto err_mem;
> +
> + sec_pool = kmalloc_node(sizeof(struct device_pools), GFP_KERNEL,
> + dev_to_node(dev));
> + if (!sec_pool)
> + goto err_mem;
> +
> + INIT_LIST_HEAD(&sec_pool->pools);
> + sec_pool->dev = dev;
> + sec_pool->pool = pool;
> +
> + INIT_LIST_HEAD(&pool->free_list);
> + INIT_LIST_HEAD(&pool->inuse_list);
> + INIT_LIST_HEAD(&pool->pools);
> + spin_lock_init(&pool->lock);
> + pool->dev = dev;
> + pool->npages_free = pool->npages_in_use = 0;
> + pool->nfrees = 0;
> + pool->gfp_flags = flags;
> + pool->size = PAGE_SIZE;
> + pool->type = type;
> + pool->nrefills = 0;
> + pool->fill_lock = false;
> + p = pool->name;
> + for (i = 0; i < 5; i++) {
> + if (type & t[i]) {
> + p += snprintf(p, sizeof(pool->name) - (p - pool->name),
> + "%s", n[i]);
> + }
> + }
> + *p = 0;
> + /* We copy the name for pr_ calls b/c when dma_pool_destroy is called
> + * - the kobj->name has already been deallocated.*/
> + snprintf(pool->dev_name, sizeof(pool->dev_name), "%s %s",
> + dev_driver_string(dev), dev_name(dev));
> + mutex_lock(&_manager->lock);
> + /* You can get the dma_pool from either the global: */
> + list_add(&sec_pool->pools, &_manager->pools);
> + _manager->npools++;
> + /* or from 'struct device': */
> + list_add(&pool->pools, &dev->dma_pools);
> + mutex_unlock(&_manager->lock);
> +
> + *ptr = pool;
> + devres_add(dev, ptr);
> +
> + return pool;
> +err_mem:
> + devres_free(ptr);
> + kfree(sec_pool);
> + kfree(pool);
> + return ERR_PTR(ret);
> +}
> +static struct dma_pool *ttm_dma_find_pool(struct device *dev,
> + enum pool_type type)
> +{
> + struct dma_pool *pool, *tmp, *found = NULL;
> +
> + if (type == IS_UNDEFINED)
> + return found;
> + /* NB: We iterate on the 'struct dev' which has no spinlock, but
> + * it does have a kref which we have taken. */
I fail to see where we kref dev.
> + list_for_each_entry_safe(pool, tmp, &dev->dma_pools, pools) {
> + if (pool->type != type)
> + continue;
> + found = pool;
> + break;
> + }
> + return found;
> +}
> +
> +/*
> + * Free pages the pages that failed to change the caching state. If there
> + * are pages that have changed their caching state already put them to the
> + * pool.
> + */
> +static void ttm_dma_handle_caching_state_failure(struct dma_pool *pool,
> + struct list_head *d_pages,
> + struct page **failed_pages,
> + unsigned cpages)
> +{
> + struct dma_page *d_page, *tmp;
> + struct page *p;
> + unsigned i = 0;
> +
> + p = failed_pages[0];
> + if (!p)
> + return;
> + /* Find the failed page. */
> + list_for_each_entry_safe(d_page, tmp, d_pages, page_list) {
> + if (d_page->p != p)
> + continue;
> + /* .. and then progress over the full list. */
> + list_del(&d_page->page_list);
> + __ttm_dma_free_page(pool, d_page);
> + if (++i < cpages)
> + p = failed_pages[i];
> + else
> + break;
> + }
> +
> +}
> +/*
> + * Allocate 'count' pages, and put 'need' number of them on the
> + * 'pages' and as well on the 'dma_address' starting at 'dma_offset' offset.
> + * The full list of pages should also be on 'd_pages'.
> + * We return zero for success, and negative numbers as errors.
> + */
> +static int ttm_dma_pool_alloc_new_pages(struct dma_pool *pool,
> + struct list_head *d_pages,
> + unsigned count)
> +{
> + struct page **caching_array;
> + struct dma_page *dma_p;
> + struct page *p;
> + int r = 0;
> + unsigned i, cpages;
> + unsigned max_cpages = min(count,
> + (unsigned)(PAGE_SIZE/sizeof(struct page *)));
> +
> + /* allocate array for page caching change */
> + caching_array = kmalloc(max_cpages*sizeof(struct page *), GFP_KERNEL);
> +
> + if (!caching_array) {
> + pr_err(TTM_PFX
> + "%s: Unable to allocate table for new pages.",
> + pool->dev_name);
> + return -ENOMEM;
> + }
> +
> + if (count > 1) {
> + pr_debug("%s: (%s:%d) Getting %d pages\n",
> + pool->dev_name, pool->name, current->pid,
> + count);
> + }
> +
> + for (i = 0, cpages = 0; i < count; ++i) {
> + dma_p = __ttm_dma_alloc_page(pool);
> + if (!dma_p) {
> + pr_err(TTM_PFX "%s: Unable to get page %u.\n",
> + pool->dev_name, i);
> +
> + /* store already allocated pages in the pool after
> + * setting the caching state */
> + if (cpages) {
> + r = ttm_set_pages_caching(pool, caching_array,
> + cpages);
> + if (r)
> + ttm_dma_handle_caching_state_failure(
> + pool, d_pages, caching_array,
> + cpages);
> + }
> + r = -ENOMEM;
> + goto out;
> + }
> + p = dma_p->p;
> +#ifdef CONFIG_HIGHMEM
> + /* gfp flags of highmem page should never be dma32 so we
> + * we should be fine in such case
> + */
> + if (!PageHighMem(p))
> +#endif
> + {
> + caching_array[cpages++] = p;
> + if (cpages == max_cpages) {
> + /* Note: Cannot hold the spinlock */
> + r = ttm_set_pages_caching(pool, caching_array,
> + cpages);
> + if (r) {
> + ttm_dma_handle_caching_state_failure(
> + pool, d_pages, caching_array,
> + cpages);
> + goto out;
> + }
> + cpages = 0;
> + }
> + }
> + list_add(&dma_p->page_list, d_pages);
> + }
> +
> + if (cpages) {
> + r = ttm_set_pages_caching(pool, caching_array, cpages);
> + if (r)
> + ttm_dma_handle_caching_state_failure(pool, d_pages,
> + caching_array, cpages);
> + }
> +out:
> + kfree(caching_array);
> + return r;
> +}
> +static bool ttm_dma_iterate_reverse(struct dma_pool *pool,
> + struct dma_page *d_page,
> + struct page *p)
> +{
> +
> + /* Note: When TTM layer gets pages - it gets them one page at a time
> + * and puts them on an array (so most recently allocated page is at
> + * at the back). The inuse_list is a copy of those pages, but in the
> + * exact opposite order. This is b/c when TTM puts pages back, it
> + * constructs a stack with the oldest element on the top. Hence the
> + * inuse_list is constructed with the same order so that it will
> + * efficiently be matched against the stack.
> + * But, just in case the pages are not in that order, we double check
> + * the 'pages' against our inuse_list in case we have to go in reverse.
> + */
> + struct page *p_next;
> + struct dma_page *tmp;
> +
> + tmp = list_entry(d_page->page_list.prev, struct dma_page, page_list);
> + if (&tmp->page_list != &pool->inuse_list) {
> + p_next = list_entry(p->lru.next, struct page, lru);
> + if (tmp->p == p_next)
> + return true;
> + }
> + return false;
> +}
> +
> +/*
> + * Iterate forward (or backwards if 'reverse' is true) by one element
> + * in the pool->in_use list. We use 'd_page' as the starting point.
> + * The 'd_page' upon completion of the iteration, is moved to the
> + * 'd_pages' list.
> + */
> +static struct dma_page *ttm_dma_iterate_next(struct dma_pool *pool,
> + struct dma_page *d_page,
> + struct list_head *d_pages,
> + bool reverse)
> +{
> + struct dma_page *next = NULL;
> +
> + if (unlikely(reverse)) {
> + if (&d_page->page_list != &pool->inuse_list)
> + next = list_entry(d_page->page_list.prev,
> + struct dma_page,
> + page_list);
> + list_move(&d_page->page_list, d_pages);
> + } else {
> + if (&d_page->page_list != &pool->inuse_list)
> + next = list_entry(d_page->page_list.next,
> + struct dma_page,
> + page_list);
> + list_move_tail(&d_page->page_list, d_pages);
> + }
> + return next;
> +}
> +/*
> + * Iterate forward (or backwards if 'reverse' is true), looking
> + * for page 'p' in the pool->inuse_list, starting at 'start'.
> + */
> +static struct dma_page *ttm_dma_iterate_forward(struct dma_pool *pool,
> + struct dma_page *start,
> + struct page *p,
> + bool reverse)
> +{
> + struct dma_page *tmp = start;
> +
> + if (unlikely(reverse)) {
> + list_for_each_entry_continue_reverse(tmp, &pool->inuse_list,
> + page_list) {
> + if (p == tmp->p)
> + return tmp;
> + }
> + } else {
> + list_for_each_entry_continue(tmp, &pool->inuse_list,
> + page_list) {
> + if (p == tmp->p)
> + return tmp;
> + }
> + }
> + return NULL;
> +}
> +/*
> + * Recycle (or delete) the 'pages' that are on the 'pool'.
> + * @pool: The pool that the pages are associated with.
> + * @pages: The list of pages we are done with.
> + * @page_count: Count of how many pages (or zero if all).
> + * @erase: Instead of recycling - just free them.
> + */
> +static unsigned int ttm_dma_put_pages_in_pool(struct dma_pool *pool,
> + struct list_head *pages,
> + unsigned page_count,
> + bool erase)
> +{
> + unsigned long uninitialized_var(irq_flags);
> + struct list_head uninitialized_var(d_pages);
> + struct page **uninitialized_var(array_pages);
> + unsigned uninitialized_var(freed_pages);
> + struct page *p, *tmp;
> + unsigned count = 0;
> + struct dma_page *d_tmp, *d_page = NULL;
> + bool rev = false;
> + if (unlikely(WARN_ON(list_empty(pages))))
> + return 0;
> +
> + if (page_count == 0) {
> + list_for_each_entry(p, pages, lru)
> + ++page_count;
> +
> + }
> + if (page_count > 1) {
> + pr_debug("%s: (%s:%d) %s %d pages\n",
> + pool->dev_name, pool->name, current->pid,
> + erase ? "Destroying" : "Recycling", page_count);
> + }
> +
> + /* d_pages is the list of 'struct dma_page' */
> + INIT_LIST_HEAD(&d_pages);
> +
> + if (erase) {
> + /* and pages_to_free is used for cache reset */
> + array_pages = kmalloc(page_count * sizeof(struct page *),
> + GFP_KERNEL);
> + if (!array_pages) {
> + dev_err(pool->dev, TTM_PFX
> + "Failed to allocate memory for pool free operation.\n");
> + return 0;
> + }
> + freed_pages = 0;
> + }
> +
> + /* Find the first page of the "chunk" of pages. */
> + p = list_first_entry(pages, struct page, lru);
> + spin_lock_irqsave(&pool->lock, irq_flags);
> +restart:
> + list_for_each_entry(d_tmp, &pool->inuse_list, page_list) {
> + if (p == d_tmp->p) {
> + d_page = d_tmp;
> + break;
> + }
> + }
> + /* The pages are _not_ in this pool. */
> + if (!d_page) {
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> + return 0;
> + }
> + rev = ttm_dma_iterate_reverse(pool, d_page, p);
> + if (rev)
> + pr_debug("%s: (%s:%d) Traversing %d in reverse order\n",
> + pool->dev_name, pool->name, current->pid, page_count);
> + /* Continue iterating on both lists. */
> + list_for_each_entry_safe(p, tmp, pages, lru) {
> + if (d_page->p != p && count != page_count) {
> + /* Yikes! The inuse stack is swiss cheese. Have to
> + start looking.*/
> + d_page = ttm_dma_iterate_forward(pool, d_page, p, rev);
> + if (!d_page)
> + goto restart;
> + }
> + /* Do not advance past what we were asked to delete. */
> + if (d_page->p != p)
> + break;
> + list_del(&p->lru);
> +
> + if (erase)
> + array_pages[freed_pages++] = d_page->p;
> + d_page = ttm_dma_iterate_next(pool, d_page, &d_pages, rev);
> + if (!d_page)
> + break;
> + count++;
> + /* Check if we should iterate. */
> + if (count == page_count)
> + break;
> + }
> + if (!erase) /* And stick 'em on the free pool. */
> + list_splice(&d_pages, &pool->free_list);
> +
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> +
> + if (erase) {
> + /* Note: The caller of us updates the pool accounting. */
> + ttm_dma_pages_put(pool, &d_pages, array_pages /* to set WB */,
> + freed_pages);
> + kfree(array_pages);
> + }
> + if (count > 1) {
> + pr_debug("%s: (%s:%d) %d/%d pages %s pool.\n",
> + pool->dev_name, pool->name, current->pid,
> + count, page_count,
> + erase ? "erased from inuse" : "put in free");
> + }
> + return count;
> +}
> +/*
> + * @return count of pages still required to fulfill the request.
> +*/
> +static int ttm_dma_page_pool_fill_locked(struct dma_pool *pool,
> + unsigned count,
> + unsigned long *irq_flags)
> +{
> + int r = count;
> +
> + if (pool->fill_lock)
> + return r;
> +
> + pool->fill_lock = true;
> + if (count < _manager->options.small &&
> + count > pool->npages_free) {
> + struct list_head d_pages;
> + unsigned alloc_size = _manager->options.alloc_size;
> +
> + INIT_LIST_HEAD(&d_pages);
> +
> + spin_unlock_irqrestore(&pool->lock, *irq_flags);
> +
> + /* Returns how many more are neccessary to fulfill the
> + * request. */
> + r = ttm_dma_pool_alloc_new_pages(pool, &d_pages, alloc_size);
> +
> + spin_lock_irqsave(&pool->lock, *irq_flags);
> + if (!r) {
> + /* Add the fresh to the end.. */
> + list_splice(&d_pages, &pool->free_list);
> + ++pool->nrefills;
> + pool->npages_free += alloc_size;
> + } else {
> + struct dma_page *d_page;
> + unsigned cpages = 0;
> +
> + pr_err(TTM_PFX "%s: Failed to fill %s pool (r:%d)!\n",
> + pool->dev_name, pool->name, r);
> +
> + list_for_each_entry(d_page, &d_pages, page_list) {
> + cpages++;
> + }
> + list_splice_tail(&d_pages, &pool->free_list);
> + pool->npages_free += cpages;
> + }
> + }
> + pool->fill_lock = false;
> + return r;
> +
> +}
> +
> +/*
> + * @return count of pages still required to fulfill the request.
> + * The populate list is actually a stack (not that is matters as TTM
> + * allocates one page at a time.
> + */
> +static int ttm_dma_pool_get_pages(struct dma_pool *pool,
> + struct list_head *pages,
> + dma_addr_t *dma_address, unsigned count)
> +{
> + unsigned long irq_flags;
> + int r;
> + unsigned i;
> + struct dma_page *d_page, *tmp;
> + struct list_head d_pages;
> +
> + spin_lock_irqsave(&pool->lock, irq_flags);
> + r = ttm_dma_page_pool_fill_locked(pool, count, &irq_flags);
> + if (r < 0) {
> + pr_debug("%s: (%s:%d) Asked for %d, got %d %s.\n",
> + pool->dev_name, pool->name, current->pid, count, r,
> + (r < 0) ? "err:" : "pages");
> + goto out;
> + }
> + if (!pool->npages_free)
> + goto out;
> + if (count > 1) {
> + pr_debug("%s: (%s:%d) Looking in free list for %d pages. "\
> + "(have %d pages free)\n",
> + pool->dev_name, pool->name, current->pid, count,
> + pool->npages_free);
> + }
> + i = 0;
> + /* We are holding the spinlock.. */
> + INIT_LIST_HEAD(&d_pages);
> + /* Note: The the 'pages' (and inuse_list) is expected to be a stack,
> + * so we put the entries in the right order (and on the inuse list
> + * in the reverse order to compenstate for freeing - which inverts the
> + * 'pages' order).
> + */
> + list_for_each_entry_safe(d_page, tmp, &pool->free_list, page_list) {
> + list_add_tail(&d_page->p->lru, pages);
> + dma_address[i++] = d_page->dma;
> + list_move(&d_page->page_list, &d_pages);
> + if (i == count)
> + break;
> + }
> + /* Note: The 'inuse_list' must have the same order as the 'pages'
> + * to be effective when pages are put back. And since 'pages' is
> + * as stack, ergo inuse_list is a stack too. */
> + list_splice(&d_pages, &pool->inuse_list);
> + count -= i;
> + pool->npages_in_use += i;
> + pool->npages_free -= i;
> +out:
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> + if (count)
> + pr_debug("%s: (%s:%d) Need %d more.\n",
> + pool->dev_name, pool->name, current->pid, count);
> + return count;
> +}
> +/*
> + * On success pages list will hold count number of correctly
> + * cached pages. On failure will hold the negative return value (-ENOMEM, etc).
> + */
> +int ttm_dma_get_pages(struct ttm_tt *ttm, struct list_head *pages,
> + unsigned count, dma_addr_t *dma_address)
> +
> +{
> + int r = -ENOMEM;
> + struct dma_pool *pool;
> + gfp_t gfp_flags;
> + enum pool_type type;
> + struct device *dev = ttm->be->dev;
> +
> + type = ttm_to_type(ttm->page_flags, ttm->caching_state);
> +
> + if (ttm->page_flags & TTM_PAGE_FLAG_DMA32)
> + gfp_flags = GFP_USER | GFP_DMA32;
> + else
> + gfp_flags = GFP_HIGHUSER;
> +
> + if (ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)
> + gfp_flags |= __GFP_ZERO;
> +
> + pool = ttm_dma_find_pool(dev, type);
> + if (!pool) {
> + pool = ttm_dma_pool_init(dev, gfp_flags, type);
> + if (IS_ERR_OR_NULL(pool))
> + return -ENOMEM;
> + }
> +#if 0
> + if (count > 1) {
> + pr_debug("%s (%s:%d) Attempting to get %d pages type %x\n",
> + pool->dev_name, pool->name, current->pid, count,
> + cstate);
> + }
> +#endif
> + /* Take pages out of a pool (if applicable) */
> + r = ttm_dma_pool_get_pages(pool, pages, dma_address, count);
> + /* clear the pages coming from the pool if requested */
> + if (ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC) {
> + struct page *p;
> + list_for_each_entry(p, pages, lru) {
> + clear_page(page_address(p));
> + }
> + }
> + /* If pool didn't have enough pages allocate new one. */
> + if (r > 0) {
> + struct list_head d_pages;
> + unsigned pages_need = r;
> + unsigned long irq_flags;
> +
> + INIT_LIST_HEAD(&d_pages);
> +
> + /* Note, we are running without locking here..
> + * and we have to manually add the stack to the inuse pool. */
> + r = ttm_dma_pool_alloc_new_pages(pool, &d_pages, pages_need);
> +
> + if (r == 0) {
> + struct dma_page *d_page;
> + int i = count - 1;
> +
> + /* Since the pages are directly going to the inuse_list
> + * which is stack based, lets treat it as a stack.
> + */
> + list_for_each_entry(d_page, &d_pages, page_list) {
> + list_add(&d_page->p->lru, pages);
> + BUG_ON(i < 0);
> + dma_address[i--] = d_page->dma;
> + }
> + spin_lock_irqsave(&pool->lock, irq_flags);
> + pool->npages_in_use += pages_need;
> + list_splice(&d_pages, &pool->inuse_list);
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> + } else {
> + /* If there is any pages in the list put them back to
> + * the pool. */
> + pr_err(TTM_PFX
> + "%s: Failed to allocate extra pages "
> + "for large request.",
> + pool->dev_name);
> + spin_lock_irqsave(&pool->lock, irq_flags);
> + pool->npages_free += r;
> + /* We don't care about ordering on the free_list. */
> + list_splice(&d_pages, &pool->free_list);
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> + return count;
> + }
> + }
> + return r;
> +}
> +
> +/* Get good estimation how many pages are free in pools */
> +static int ttm_dma_pool_get_num_unused_pages(void)
> +{
> + struct device_pools *p;
> + unsigned total = 0;
> +
> + mutex_lock(&_manager->lock);
> + list_for_each_entry(p, &_manager->pools, pools) {
> + if (p)
> + total += p->pool->npages_free;
> + }
> + mutex_unlock(&_manager->lock);
> + return total;
> +}
> +
> +/* Put all pages in pages list to correct pool to wait for reuse */
> +void ttm_dma_put_pages(struct ttm_tt *ttm, struct list_head *pages,
> + unsigned page_count, dma_addr_t *dma_address)
> +{
> + struct dma_pool *pool;
> + enum pool_type type;
> + bool is_cached = false;
> + unsigned count = 0, i;
> + unsigned long irq_flags;
> + struct device *dev = ttm->be->dev;
> +
> + if (list_empty(pages))
> + return;
> +
> + type = ttm_to_type(ttm->page_flags, ttm->caching_state);
> + pool = ttm_dma_find_pool(dev, type);
> + if (!pool) {
> + WARN_ON(!pool);
> + return;
> + }
> + is_cached = (ttm_dma_find_pool(pool->dev,
> + ttm_to_type(ttm->page_flags, tt_cached)) == pool);
> +
> + if (page_count > 1) {
> + dev_dbg(pool->dev, "(%s:%d) Attempting to %s %d pages.\n",
> + pool->name, current->pid,
> + (is_cached) ? "destroy" : "recycle", page_count);
> + }
> +
> + count = ttm_dma_put_pages_in_pool(pool, pages, page_count, is_cached);
> +
> + for (i = 0; i < count; i++)
> + dma_address[i] = 0;
> +
> + spin_lock_irqsave(&pool->lock, irq_flags);
> + pool->npages_in_use -= count;
> + if (is_cached)
> + pool->nfrees += count;
> + else
> + pool->npages_free += count;
> + spin_unlock_irqrestore(&pool->lock, irq_flags);
> +
> + page_count -= count;
> + WARN(page_count != 0,
> + "Only freed %d page(s) in %s. Could not free the other %d!\n",
> + count, pool->name, page_count);
> +
> + page_count = 0;
> + if (pool->npages_free > _manager->options.max_size) {
> + page_count = pool->npages_free - _manager->options.max_size;
> + if (page_count < NUM_PAGES_TO_ALLOC)
> + page_count = NUM_PAGES_TO_ALLOC;
> + }
> + if (page_count)
> + ttm_dma_page_pool_free(pool, page_count);
> +}
> +
> +/**
> + * Callback for mm to request pool to reduce number of page held.
> + */
> +static int ttm_dma_pool_mm_shrink(struct shrinker *shrink,
> + struct shrink_control *sc)
> +{
> + static atomic_t start_pool = ATOMIC_INIT(0);
> + unsigned idx = 0;
> + unsigned pool_offset = atomic_add_return(1, &start_pool);
> + unsigned shrink_pages = sc->nr_to_scan;
> + struct device_pools *p;
> +
> + if (list_empty(&_manager->pools))
> + return 0;
> +
> + mutex_lock(&_manager->lock);
> + pool_offset = pool_offset % _manager->npools;
> + list_for_each_entry(p, &_manager->pools, pools) {
> + unsigned nr_free;
> +
> + if (!p && !p->dev)
> + continue;
> + if (shrink_pages == 0)
> + break;
> + /* Do it in round-robin fashion. */
> + if (++idx < pool_offset)
> + continue;
> + nr_free = shrink_pages;
> + shrink_pages = ttm_dma_page_pool_free(p->pool, nr_free);
> + pr_debug("%s: (%s:%d) Asked to shrink %d, have %d more to go\n",
> + p->pool->dev_name, p->pool->name, current->pid, nr_free,
> + shrink_pages);
> + }
> + mutex_unlock(&_manager->lock);
> + /* return estimated number of unused pages in pool */
> + return ttm_dma_pool_get_num_unused_pages();
> +}
> +
> +static void ttm_dma_pool_mm_shrink_init(struct ttm_pool_manager *manager)
> +{
> + manager->mm_shrink.shrink = &ttm_dma_pool_mm_shrink;
> + manager->mm_shrink.seeks = 1;
> + register_shrinker(&manager->mm_shrink);
> +}
> +static void ttm_dma_pool_mm_shrink_fini(struct ttm_pool_manager *manager)
> +{
> + unregister_shrinker(&manager->mm_shrink);
> +}
> +int ttm_dma_page_alloc_init(struct ttm_mem_global *glob,
> + unsigned max_pages)
> +{
> + int ret = -ENOMEM;
> +
> + WARN_ON(_manager);
> +
> + printk(KERN_INFO TTM_PFX "Initializing DMA pool allocator.\n");
> +
> + _manager = kzalloc(sizeof(*_manager), GFP_KERNEL);
> + if (!_manager)
> + goto err_manager;
> +
> + mutex_init(&_manager->lock);
> + INIT_LIST_HEAD(&_manager->pools);
> +
> + _manager->options.max_size = max_pages;
> + _manager->options.small = SMALL_ALLOCATION;
> + _manager->options.alloc_size = NUM_PAGES_TO_ALLOC;
> +
> + /* This takes care of auto-freeing the _manager */
> + ret = kobject_init_and_add(&_manager->kobj, &ttm_pool_kobj_type,
> + &glob->kobj, "dma_pool");
> + if (unlikely(ret != 0)) {
> + kobject_put(&_manager->kobj);
> + goto err;
> + }
> + ttm_dma_pool_mm_shrink_init(_manager);
> + return 0;
> +err_manager:
> + kfree(_manager);
> + _manager = NULL;
> +err:
> + return ret;
> +}
> +void ttm_dma_page_alloc_fini(void)
> +{
> + struct device_pools *p, *t;
> +
> + printk(KERN_INFO TTM_PFX "Finalizing DMA pool allocator.\n");
> + ttm_dma_pool_mm_shrink_fini(_manager);
> +
> + list_for_each_entry_safe_reverse(p, t, &_manager->pools, pools) {
> + dev_dbg(p->dev, "(%s:%d) Freeing.\n", p->pool->name,
> + current->pid);
> + WARN_ON(devres_destroy(p->dev, ttm_dma_pool_release,
> + ttm_dma_pool_match, p->pool));
> + ttm_dma_free_pool(p->dev, p->pool->type);
> + }
> + kobject_put(&_manager->kobj);
> + _manager = NULL;
> +}
> +
> +int ttm_dma_page_alloc_debugfs(struct seq_file *m, void *data)
> +{
> + struct device_pools *p;
> + struct dma_pool *pool = NULL;
> + char *h[] = {"pool", "refills", "pages freed", "inuse", "available",
> + "name", "virt", "busaddr"};
> +
> + if (!_manager) {
> + seq_printf(m, "No pool allocator running.\n");
> + return 0;
> + }
> + seq_printf(m, "%13s %12s %13s %8s %8s %8s\n",
> + h[0], h[1], h[2], h[3], h[4], h[5]);
> + mutex_lock(&_manager->lock);
> + list_for_each_entry(p, &_manager->pools, pools) {
> + struct device *dev = p->dev;
> + if (!dev)
> + continue;
> + pool = p->pool;
> + seq_printf(m, "%13s %12ld %13ld %8d %8d %8s\n",
> + pool->name, pool->nrefills,
> + pool->nfrees, pool->npages_in_use,
> + pool->npages_free,
> + pool->dev_name);
> + }
> + mutex_unlock(&_manager->lock);
> + return 0;
> +}
> +EXPORT_SYMBOL_GPL(ttm_dma_page_alloc_debugfs);
> +bool ttm_dma_override(struct ttm_backend_func *be)
> +{
> + if (swiotlb_nr_tbl() && be) {
> + be->get_pages = &ttm_dma_get_pages;
> + be->put_pages = &ttm_dma_put_pages;
> + return true;
> + }
> + return false;
> +}
> +EXPORT_SYMBOL_GPL(ttm_dma_override);
> diff --git a/include/drm/ttm/ttm_page_alloc.h b/include/drm/ttm/ttm_page_alloc.h
> index 0aaac39..9c52fb7 100644
> --- a/include/drm/ttm/ttm_page_alloc.h
> +++ b/include/drm/ttm/ttm_page_alloc.h
> @@ -29,6 +29,37 @@
> #include "ttm_bo_driver.h"
> #include "ttm_memory.h"
>
> +#ifdef CONFIG_SWIOTLB
> +extern bool ttm_dma_override(struct ttm_backend_func *be);
> +
> +/**
> + * Initialize pool allocator.
> + */
> +int ttm_dma_page_alloc_init(struct ttm_mem_global *glob, unsigned max_pages);
> +/**
> + * Free pool allocator.
> + */
> +void ttm_dma_page_alloc_fini(void);
> +/**
> + * Output the state of pools to debugfs file
> + */
> +extern int ttm_dma_page_alloc_debugfs(struct seq_file *m, void *data);
> +#else
> +static inline bool ttm_dma_override(struct ttm_backend_func *be)
> +{
> + return false;
> +}
> +static inline int ttm_dma_page_alloc_init(struct ttm_mem_global *glob,
> + unsigned max_pages)
> +{
> + return -ENODEV;
> +}
> +static inline void ttm_dma_page_alloc_fini(void) { return; }
> +static inline int ttm_dma_page_alloc_debugfs(struct seq_file *m, void *data)
> +{
> + return 0;
> +}
> +#endif
> /**
> * Get count number of pages from pool to pages list.
> *
> --
> 1.7.6.4
>
See comment above, otherwise:
Reviewed-by: Jerome Glisse <jglisse@redhat.com>
^ permalink raw reply
* [U-Boot] [PATCH] Powerpc/DIU: Fixed the 800x600 and 1024x768 resolution bug
From: Anatolij Gustschin @ 2011-10-31 19:32 UTC (permalink / raw)
To: u-boot
In-Reply-To: <1320041994-28675-1-git-send-email-Chang-Ming.Huang@freescale.com>
On Mon, 31 Oct 2011 14:19:54 +0800
<Chang-Ming.Huang@freescale.com> wrote:
> From: Jerry Huang <Chang-Ming.Huang@freescale.com>
>
> When the resolution is set to 800x600 and 1024x768,
> but, the driver will use 1280x1024 resolution to set the DIU register
>
> Signed-off-by: Jerry Huang <Chang-Ming.Huang@freescale.com>
> ---
> drivers/video/fsl_diu_fb.c | 2 ++
> 1 files changed, 2 insertions(+), 0 deletions(-)
Applied to u-boot-video/master, thanks!
Anatolij
^ permalink raw reply
* Re: [PATCH 05/13] mtd/docg3: add multiple floor support
From: Robert Jarzmik @ 2011-10-31 19:32 UTC (permalink / raw)
To: Mike Dunn; +Cc: linux-mtd
In-Reply-To: <4EAEDBA3.6050005@newsguy.com>
Mike Dunn <mikedunn@newsguy.com> writes:
> On 10/28/2011 10:51 AM, Robert Jarzmik wrote:
>> Add support for multiple floors, ie. cascaded docg3
>> chips. There might be 4 docg3 chips cascaded, sharing the
>> same address space, and providing up to 4 times the storage
>> capacity of a unique chip.
>>
>> Each floor will be seen as an independant mtd device.
>>
>
> Do we know of any products that contain multiple doc devices in a cascaded
> configuration?
Yes, my board Mitac mioa701 has floors 0 and 1 in it.
--
Robert
^ permalink raw reply
* ANN: Project Kronos - Ubuntu UDS Session, 1 Nov @ 20:15 UTC
From: Mike McClurg @ 2011-10-31 19:32 UTC (permalink / raw)
To: xen-devel-GuqFBffKawuULHF6PoxzQEEOCMrvLtNR@public.gmane.org,
xen-api-GuqFBffKawuULHF6PoxzQEEOCMrvLtNR@public.gmane.org,
xen-users-GuqFBffKawuULHF6PoxzQEEOCMrvLtNR@public.gmane.org
Hi all,
I just wanted to let you know that Jon Ludlam and I will be hosting a
workshop on Project Kronos [1] tomorrow at the Ubuntu Developer Summit
(UDS) for Ubuntu 12.04. We'll be discussing the status of the project,
and the work remaining for us to get Kronos included in Ubuntu.
You can join in the workshop remotely. There will be a live audio stream
[2], an IRC channel on freenode [3], and an etherpad instance to take
notes [4]. You will need a Launchpad account to read or write on the
etherpad, and you must register with the group Ubuntu Etherpad instance [5].
The workshop will start on Tuesday, 1 Nov, at 20:15 UTC (16:15 EST). I
welcome everyone who is interested in Ubuntu, Xen and XCP to join!
Mike
[1] https://blueprints.launchpad.net/ubuntu/+spec/servercloud-p-kronos
[2] http://icecast.ubuntu.com:8000/status.xsl - go to antigua2 channel
[3] #ubuntu-uds-Antigua2 on freenode
[4] http://summit.ubuntu.com/uds-p/meeting/19427/servercloud-p-kronos/
[5] https://launchpad.net/~ubuntu-etherpad
^ permalink raw reply
* Re: [PATCH] Bluetooth: Set HCI_MGMT flag only in read_controller_info
From: Gustavo Padovan @ 2011-10-31 19:31 UTC (permalink / raw)
To: johan.hedberg; +Cc: linux-bluetooth
In-Reply-To: <1319488586-2779-1-git-send-email-johan.hedberg@gmail.com>
Hi Johan,
* johan.hedberg@gmail.com <johan.hedberg@gmail.com> [2011-10-24 22:36:26 +0200]:
> From: Johan Hedberg <johan.hedberg@intel.com>
>
> The HCI_MGMT flag should only be set when user space requests the full
> controller information. This way we avoid potential issues with setting
> change events ariving before the actual read_controller_info command
> finishes.
>
> Signed-off-by: Johan Hedberg <johan.hedberg@intel.com>
> ---
> net/bluetooth/mgmt.c | 2 --
> 1 files changed, 0 insertions(+), 2 deletions(-)
Applied, thanks.
Gustavo
^ permalink raw reply
* Confirmation
From: Western Union Money Transfer @ 2011-10-31 18:48 UTC (permalink / raw)
You have $85,000USD in cash credit by the International Monetary Funds via Western
Union. Confirm this receipt to due process unit officer with
FullName,Address,Tel,Occupation
*******************************************************
http://www.chasque.net
*******************************************************
^ permalink raw reply
* [PATCH] dma: fix spacing for method declaration, coding style issue in iop-adma.c
From: Ciaran McCormick @ 2011-10-31 19:29 UTC (permalink / raw)
To: dan.j.williams, vinod.koul; +Cc: linux-kernel, Ciaran McCormick
From: Ciaran McCormick <ciaranmccormick@gmail.com>
---
drivers/dma/iop-adma.c | 4 ++--
1 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/dma/iop-adma.c b/drivers/dma/iop-adma.c
index e03f811..686dc76 100644
--- a/drivers/dma/iop-adma.c
+++ b/drivers/dma/iop-adma.c
@@ -1746,12 +1746,12 @@ static struct platform_driver iop_adma_driver = {
},
};
-static int __init iop_adma_init (void)
+static int __init iop_adma_init(void)
{
return platform_driver_register(&iop_adma_driver);
}
-static void __exit iop_adma_exit (void)
+static void __exit iop_adma_exit(void)
{
platform_driver_unregister(&iop_adma_driver);
return;
--
1.7.5.4
^ permalink raw reply related
* Re: [PATCH 2/2] Bluetooth: Replace rfcomm tty tasklet by workqueue
From: Gustavo Padovan @ 2011-10-31 19:29 UTC (permalink / raw)
To: David Herrmann; +Cc: linux-bluetooth
In-Reply-To: <1319463058-29311-2-git-send-email-dh.herrmann@googlemail.com>
Hi David,
* David Herrmann <dh.herrmann@googlemail.com> [2011-10-24 15:30:58 +0200]:
> Remove old tasklets and replace by workqueue. To avoid reentrancy (which
> tasklets always avoid) we use the system_nrt_wq.
>
> Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
> ---
> net/bluetooth/rfcomm/tty.c | 16 +++++++++-------
> 1 files changed, 9 insertions(+), 7 deletions(-)
Both patches have been applied, thanks.
Gustavo
^ permalink raw reply
* Re: [Fedora-xen] [Xen-devel] Xen 4.1.2 HVM guest realtek nic problems (eth0 8139cp transmit queue timed out)
From: Pasi Kärkkäinen @ 2011-10-31 19:29 UTC (permalink / raw)
To: Boris Derzhavets; +Cc: xen, xen-devel
In-Reply-To: <1320089054.54459.YahooMailClassic@web65902.mail.ac4.yahoo.com>
On Mon, Oct 31, 2011 at 12:24:14PM -0700, Boris Derzhavets wrote:
> Seems to related
>
> https://bugs.launchpad.net/ubuntu/+source/xen/+bug/854829
>
Thanks, that seems to be the same bug.
Is the bugfix patch from xen-unstable going to backported to xen-4.1-testing.hg ?
(4.1 backported patch available on ubuntu's launchpad above..)
-- Pasi
> Boris.
>
> --- On Mon, 10/31/11, Pasi Kärkkäinen <pasik@iki.fi> wrote:
>
> From: Pasi Kärkkäinen <pasik@iki.fi>
> Subject: [Xen-devel] Xen 4.1.2 HVM guest realtek nic problems (eth0
> 8139cp transmit queue timed out)
> To: xen-devel@lists.xensource.com
> Date: Monday, October 31, 2011, 2:49 PM
>
> Hello,
>
> While testing Xen 4.1.2 and HVM guests I noticed the following problem
> with Fedora 16 HVM guests (using Linux 3.1.0 kernel in the VM):
>
> The errors (call trace) happens pretty much immediately when there's
> some network traffic going on..
>
> Simple "yum update" in the VM triggers the problem..
>
> [ 0.000000] Linux version 3.1.0-5.fc16.x86_64
> ([1]mockbuild@x86-10.phx2.fedoraproject.org) (gcc version 4.6.1 20111003
> (Red Hat 4.6.1-10) (GCC) ) #1 SMP Thu Oct 27 03:46:50 UTC 2011
> [ 0.000000] Command line: BOOT_IMAGE=/vmlinuz-3.1.0-5.fc16.x86_64
> root=/dev/mapper/vg_f16test64hvm-lv_root ro
> rd.lvm.lv=vg_f16test64hvm/lv_root rd.dm=0 SYSFONT=latarcyrheb-sun16 rhgb
> KEYTABLE=fi rd.md=0 rd.luks=0 rd.lvm.lv=vg_f16test64hvm/lv_swap
> LANG=en_US.UTF-8 console=ttyS0,38400 console=tty0
> <snip>
>
> [ 28.998481] 8139cp 0000:00:03.0: eth0: link up, 100Mbps, full-duplex,
> lpa 0x05E1
> [ 149.712071] ------------[ cut here ]------------
> [ 149.717216] WARNING: at net/sched/sch_generic.c:255
> dev_watchdog+0xf0/0x150()
> [ 149.724709] Hardware name: HVM domU
> [ 149.728738] NETDEV WATCHDOG: eth0 (8139cp): transmit queue 0 timed
> out
> [ 149.735537] Modules linked in: ip6t_REJECT nf_conntrack_ipv6
> nf_defrag_ipv6 nf_conntrack_ipv4 nf_defrag_ipv4 ip6table_filter xt_state
> ip6_tables nf_conntrack 81
> 39too 8139cp ppdev parport_pc mii parport i2c_piix4 i2c_core joydev
> [last unloaded: scsi_wait_scan]
> [ 149.768028] Pid: 0, comm: swapper Not tainted 3.1.0-5.fc16.x86_64 #1
> [ 149.774639] Call Trace:
> [ 149.777765] <IRQ> [<ffffffff81057a56>]
> warn_slowpath_common+0x83/0x9b
> [ 149.784024] [<ffffffff81057b11>] warn_slowpath_fmt+0x46/0x48
> [ 149.790141] [<ffffffff813ef49d>] ? netif_tx_lock+0x4a/0x7c
> [ 149.799007] [<ffffffff813ef613>] dev_watchdog+0xf0/0x150
> [ 149.806361] [<ffffffff81064b51>] run_timer_softirq+0x19b/0x280
> [ 149.814392] [<ffffffff81014fec>] ? sched_clock+0x9/0xd
> [ 149.821650] [<ffffffff813ef523>] ? netif_tx_unlock+0x54/0x54
> [ 149.828926] [<ffffffff8105d6b3>] __do_softirq+0xc9/0x1b5
> [ 149.836803] [<ffffffff81014fec>] ? sched_clock+0x9/0xd
> [ 149.843422] [<ffffffff814be5ec>] call_softirq+0x1c/0x30
> [ 149.850067] [<ffffffff81010b45>] do_softirq+0x46/0x81
> [ 149.856760] [<ffffffff8105d97b>] irq_exit+0x57/0xb1
> [ 149.863035] [<ffffffff812a39d3>] xen_evtchn_do_upcall+0x31/0x3e
> [ 149.871144] [<ffffffff814be76e>] xen_hvm_callback_vector+0x6e/0x80
> [ 149.879494] <EOI> [<ffffffff8102f2f1>] ? native_safe_halt+0xb/0xd
> [ 149.888220] [<ffffffff81015b7e>] default_idle+0x4e/0x86
> [ 149.894962] [<ffffffff8100e2ed>] cpu_idle+0xae/0xe8
> [ 149.901461] [<ffffffff814934ee>] rest_init+0x72/0x74
> [ 149.908949] [<ffffffff81b76b7d>] start_kernel+0x3ab/0x3b6
> [ 149.916617] [<ffffffff81b762c4>] x86_64_start_reservations+0xaf/0xb3
> [ 149.929148] [<ffffffff81b76140>] ? early_idt_handlers+0x140/0x140
> [ 149.936797] [<ffffffff81b763ca>] x86_64_start_kernel+0x102/0x111
> [ 149.944336] ---[ end trace d8786cb7d6a57f8a ]---
> [ 149.950406] 8139cp 0000:00:03.0: eth0: Transmit timeout, status
> d 3b 15 80ff
> [ 149.961879] ------------[ cut here ]------------
> [ 149.962245] WARNING: at kernel/softirq.c:159
> _local_bh_enable_ip+0x44/0x8e()
> [ 149.962245] Hardware name: HVM domU
> [ 149.962245] Modules linked in: ip6t_REJECT nf_conntrack_ipv6
> nf_defrag_ipv6 nf_conntrack_ipv4 nf_defrag_ipv4 ip6table_filter xt_state
> ip6_tables nf_conntrack 8139too 8139cp ppdev parport_pc mii parport
> i2c_piix4 i2c_core joydev [last unloaded: scsi_wait_scan]
> [ 149.962245] Pid: 0, comm: swapper Tainted: G
> W 3.1.0-5.fc16.x86_64 #1
> [ 149.962245] Call Trace:
> [ 149.962245] <IRQ> [<ffffffff81057a56>]
> warn_slowpath_common+0x83/0x9b
> [ 149.962245] [<ffffffff813ce599>] ? skb_release_data+0xca/0xcf
> [ 149.962245] [<ffffffff81057a88>] warn_slowpath_null+0x1a/0x1c
> [ 149.962245] [<ffffffff8105d462>] _local_bh_enable_ip+0x44/0x8e
> [ 149.962245] [<ffffffff8105d4ba>] local_bh_enable_ip+0xe/0x10
> [ 149.962245] [<ffffffff814b5db4>] _raw_spin_unlock_bh+0x15/0x17
> [ 149.962245] [<ffffffffa0053969>] destroy_conntrack+0x9d/0xdc
> [nf_conntrack]
> [ 149.962245] [<ffffffff813fa343>] nf_conntrack_destroy+0x19/0x1b
> [ 149.962245] [<ffffffff813ce7ad>] skb_release_head_state+0xa7/0xef
> [ 149.962245] [<ffffffff813ce5b1>] __kfree_skb+0x13/0x83
> [ 149.962245] [<ffffffff813ce677>] consume_skb+0x56/0x6b
> [ 149.962245] [<ffffffffa003c1b9>] cp_clean_rings+0xb4/0x114 [8139cp]
> [ 149.962245] [<ffffffffa003c371>] cp_tx_timeout+0x88/0x10e [8139cp]
> [ 149.962245] [<ffffffff813ef627>] dev_watchdog+0x104/0x150
> [ 149.962245] [<ffffffff81064b51>] run_timer_softirq+0x19b/0x280
> [ 149.962245] [<ffffffff81014fec>] ? sched_clock+0x9/0xd
> [ 149.962245] [<ffffffff813ef523>] ? netif_tx_unlock+0x54/0x54
> [ 149.962245] [<ffffffff8105d6b3>] __do_softirq+0xc9/0x1b5
> [ 149.962245] [<ffffffff81014fec>] ? sched_clock+0x9/0xd
> [ 149.962245] [<ffffffff814be5ec>] call_softirq+0x1c/0x30
> [ 149.962245] [<ffffffff81010b45>] do_softirq+0x46/0x81
> [ 149.962245] [<ffffffff8105d97b>] irq_exit+0x57/0xb1
> [ 149.962245] [<ffffffff812a39d3>] xen_evtchn_do_upcall+0x31/0x3e
> [ 149.962245] [<ffffffff814be76e>] xen_hvm_callback_vector+0x6e/0x80
> [ 149.962245] <EOI> [<ffffffff8102f2f1>] ? native_safe_halt+0xb/0xd
> [ 149.962245] [<ffffffff81015b7e>] default_idle+0x4e/0x86
> [ 149.962245] [<ffffffff8100e2ed>] cpu_idle+0xae/0xe8
> [ 149.962245] [<ffffffff814934ee>] rest_init+0x72/0x74
> [ 149.962245] [<ffffffff81b76b7d>] start_kernel+0x3ab/0x3b6
> [ 149.962245] [<ffffffff81b762c4>] x86_64_start_reservations+0xaf/0xb3
> [ 149.962245] [<ffffffff81b76140>] ? early_idt_handlers+0x140/0x140
> [ 149.962245] [<ffffffff81b763ca>] x86_64_start_kernel+0x102/0x111
> [ 149.962245] ---[ end trace d8786cb7d6a57f8b ]---
>
> Full guest kernel dmesg attached to this email.
> The host is running F16 with Xen 4.1.2 and Linux 3.1.0 dom0 kernel.
>
> Xen cfgfile for the HVM domain:
>
> kernel = "hvmloader"
> builder='hvm'
> device_model = 'qemu-dm'
> name = "f16test64hvm"
> memory = 1024
> vcpus=1
> pae=1
> acpi=1
> apic=1
> vif = [ 'type=ioemu, mac=00:16:3f:03:01:14, bridge=virbr0' ]
> disk = [ 'phy:/dev/vg_f16/f16test64hvm,hda,w',
> 'file:/root/iso/Fedora-16-Final-RC2-x86_64-DVD.iso,hdc:cdrom,r' ]
> boot='cd'
> xen_platform_pci=0
> on_poweroff = 'destroy'
> on_reboot = 'restart'
> on_crash = 'restart'
> sdl=0
> vnc=1
> vncpasswd=''
> stdvga=0
> serial='pty'
> tsc_mode=0
> usb=1
> usbdevice='tablet'
> keymap='fi'
>
> Using "model=e1000" instead for the vif works OK.. no problems with the
> emulated intel nic.
>
> Any ideas what the problem with the emulated realtek nic?
>
> Thanks,
>
> -- Pasi
>
> -----Inline Attachment Follows-----
>
> _______________________________________________
> Xen-devel mailing list
> [2]Xen-devel@lists.xensource.com
> [3]http://lists.xensource.com/xen-devel
>
> References
>
> Visible links
> 1. file:///mc/compose?to=mockbuild@x86-10.phx2.fedoraproject.org
> 2. file:///mc/compose?to=Xen-devel@lists.xensource.com
> 3. http://lists.xensource.com/xen-devel
--
xen mailing list
xen@lists.fedoraproject.org
https://admin.fedoraproject.org/mailman/listinfo/xen
^ permalink raw reply
* [Qemu-devel] [PULL] [PATCH 00/10] Linux-user patches for 1.0
From: Riku Voipio @ 2011-10-31 19:27 UTC (permalink / raw)
To: aliguori; +Cc: qemu-devel
Fixes related linux-user qemu targetting 1.0 are available in
the git repository at:
git://git.linaro.org/people/rikuvoipio/qemu.git linux-user-for-upstream
Alexander Graf (2):
linux-user: fix openat
linux-user: implement reboot syscall
Matthias Braun (3):
linux-user: fix TARGET_RLIM_INFINITY declaration
linux-user: fix rlimit syscalls on sparc(64)
linux-user: fix abi_(u)long, target_ulong mismatch
Richard Henderson (5):
sparc-linux-user: Handle SIGILL.
sparc-linux-user: Fixup sending SIGSEGV
sparc-linux-user: Add some missing syscall numbers
ppc64-linux-user: Properly interpret the entry function descriptor.
ppc64-linux-user: Fix syscall return type.
linux-user/elfload.c | 8 +-
linux-user/main.c | 26 ++--
linux-user/qemu-types.h | 12 ++
linux-user/signal.c | 22 ++--
linux-user/sparc/syscall_nr.h | 3 +
linux-user/strace.c | 4 +-
linux-user/syscall.c | 272 ++++++++++++++++++++---------------------
linux-user/syscall_defs.h | 17 ++-
linux-user/vm86.c | 4 +-
9 files changed, 193 insertions(+), 175 deletions(-)
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.