WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-devel

Re: [Xen-devel][PATCH][LINUX] Dynamic modes support for xenfb (2 of 2)

To: Markus Armbruster <armbru@xxxxxxxxxx>
Subject: Re: [Xen-devel][PATCH][LINUX] Dynamic modes support for xenfb (2 of 2)
From: Pat Campbell <plc@xxxxxxxxxx>
Date: Sun, 23 Mar 2008 21:40:18 -0600
Cc: xen-devel <xen-devel@xxxxxxxxxxxxxxxxxxx>
Delivery-date: Sun, 23 Mar 2008 20:43:46 -0700
Envelope-to: www-data@xxxxxxxxxxxxxxxxxx
In-reply-to: <87r6e7auam.fsf@xxxxxxxxxxxxxxxxx>
List-help: <mailto:xen-devel-request@lists.xensource.com?subject=help>
List-id: Xen developer discussion <xen-devel.lists.xensource.com>
List-post: <mailto:xen-devel@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/cgi-bin/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/cgi-bin/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=unsubscribe>
References: <47D98787.6000501@xxxxxxxxxx> <87hcf91cmh.fsf@xxxxxxxxxxxxxxxxx> <47DD7082.9090401@xxxxxxxxxx> <874pb5w8xa.fsf@xxxxxxxxxxxxxxxxx> <47E013CE.5090608@xxxxxxxxxx> <87r6e7auam.fsf@xxxxxxxxxxxxxxxxx>
Sender: xen-devel-bounces@xxxxxxxxxxxxxxxxxxx
User-agent: Thunderbird 2.0.0.6 (X11/20070801)
Markus Armbruster wrote:
> Pat Campbell <plc@xxxxxxxxxx> writes:
>
>   
>> Markus Armbruster wrote:
>>     
>>> Pat Campbell <plc@xxxxxxxxxx> writes:
>>>
>>>   
>>>       
>>>> Markus Armbruster wrote:
>>>>     
>>>>         
>>>>> Pat Campbell <plc@xxxxxxxxxx> writes:
>>>>>
>>>>>   
>>>>>       
>>>>>           
>>>>>> Attached patch adds dynamic frame buffer resolution support to
>>>>>> the PV xenfb frame buffer driver.
>>>>>>
>>>>>> Corresponding backend IOEMU patch is required for functionality but
>>>>>> this patch is not dependent on it, preserving backwards compatibility.
>>>>>>
>>>>>> Please apply to tip of linux-2.6.18-xen
>>>>>>
>>>>>> Signed-off-by: Pat Campbell <plc@xxxxxxxxxx>
>>>>>>     
>>>>>>         
>>>>>>             
>>>>> Adding another lock (queue_lock) to our already ticklish locking gives
>>>>> me a queasy feeling...
>>>>>
>>>>> The purpose of the lock is not obvious to me.  Please explain that, in
>>>>> the code.  Likewise, it's not entirely obvious that the locking works.
>>>>> Please update the "How the locks work together" comment.
>>>>>
>>>>> But before you do that, I suggest you tell us exactly what problem
>>>>> you're attempting to solve with queue_lock.  Maybe we can come up with
>>>>> a less scary solution.  Maybe not.  But it's worth a try.  If it's
>>>>> just to ensure the changes made by xenfb_set_par() are seen in
>>>>> xenfb_do_resize() correctly, a memory barrier should to the trick more
>>>>> easily.
>>>>>       
>>>>>           
> [Pat explains the race...]
>   
>>> Your race is real.
>>>
>>> Your old code shared the resolution state (info->resize_dpy and the
>>> resolution variables in info->fb_info) between xenfb_do_resize()
>>> (running in xenfb_thread) and xenfb_set_par() (running in another
>>> thread).
>>>
>>> Your new code shares the ring buffer instead.
>>>
>>> Both methods can be made race-free with suitable synchronization.
>>>
>>> With your old code, xenfb_set_par() always succeeds.  Until the
>>> backend gets around to process the XENFB_TYPE_RESIZE message, it
>>> interprets the frame buffer for the old resolution.  As you argue
>>> below, this isn't fatal, it can just mess up the display somewhat.
>>>
>>> With your new code, xenfb_set_par() can take a long time (one second),
>>> and it can fail, leaving the display in a deranged state until the
>>> next resolution change.  It still doesn't fully synchronize with the
>>> backend: it returns successfully after sending the message, leaving
>>> the time window until the backend receives the message open.
>>>   
>>>       
>> Synchronizing with the backend?  I don't think this is necessary.  The
>> update events that follow the resize event will be for the new size, as
>> long as the backend gets the resize event we should be ok. 
>>     
>
> I didn't mean to say that synchronizing with the backend is necessary.
> I just wanted to point out that your new method pays the price of
> synchronization, namely a possibly significant delay in
> xenfb_set_par(), plus an ugly failure mode there, without actually
> achieving synchronization.
>
>   
>>> I'd prefer the old behavior.  But I could be missing something here.
>>> Am I?
>>>
>>>   
>>>       
>> I like the new behavior, it seems more straight forward and does not
>> rely on the xenfb_thread() being active.  Our first set_par() happens
>> during frame buffer registration which is before xenfb_thread() is
>> started.     I disliked adding new code into the xenfb_update() function
>> for an event that happens rarely so will revert back to the sharing of
>> resize_dpy flag code.
>>
>> Is this how you envision xenfb_set_par() synchronization?
>>
>> static int xenfb_set_par(struct fb_info *info)
>> {
>>     struct xenfb_info *xenfb_info;
>>     unsigned long flags;
>>
>>     xenfb_info = info->par;
>>
>>     if (xenfb_info->kthread) {
>>         spin_lock_irqsave(&xenfb_info->resize_lock, flags);
>>         info->var.xres_virtual = info->var.xres;
>>         info->var.yres_virtual = info->var.yres;
>>         xenfb_info->resize_dpy = 1;
>>         /* Wake up xenfb_thread() */
>>         xenfb_refresh(xenfb_info, 0, 0, 1, 1);
>>         while (xenfb_info->kthread && xenfb_info->resize_dpy == 1) {
>>             msleep(10);
>>         }
>>         spin_unlock_irqrestore(&xenfb_info->resize_lock, flags);
>>     }
>>     return 0;
>> }
>>
>> To explain the code a liitle bit.
>>  1. Need to test for kthread because first xenfb_set_par() happens
>> before xenfb_thread() is started
>>     
>
> Why can you just ignore the mode change then?
>
>   
>>  2. Need to wakeup xenfb_thread via refresh as application screen events
>> are blocked waiting on the set_par to complete.  Can't just set dirty,
>> will get a bogus nasty gram.
>>     
>
> I'd pass an empty rectangle there:
>
>         xenfb_refresh(xenfb_info, INT_MAX, INT_MAX, 0, 0);
>
> Alternatively, factor out the code to wake up the thread into a new
> function, and call that here and from __xenfb_refresh().  That would
> be cleaner.
>
>   
>>  3. Testing xenfb_thread in the while loop in case xenfb_remove() is
>> called and thread is shutdown.  Protects against a  system shutdown
>> hang.  Don't know if that can happen, defensive code.
>>     
>
> Sleeps while holding a spinlock.  Not good.  And I didn't get the hang
> you're trying to defend against.
>
> xenfb_resize_screen() still accesses the size unsynchronized, and can
> thus see intermediate states of resolution changes.
>
>
> No, that's not what I had in mind.  Let me sketch it.
>
> The first question to answer for a mutex is: what shared state does it
> protect?  resize_lock protects the screen size fb_info->var.xres,
> fb_info->var.yres and the flag resize_dpy.
>
> Once that's clear, the use of the mutex becomes obvious: wrap it
> around any access of the shared state, i.e. the updating of the shared
> state it protects in xenfb_set_par() and the reading in
> xenfb_thread().  Code sketch:
>
> static void xenfb_resize_screen(struct xenfb_info *info)
> {
>       if (xenfb_queue_full(info))
>               return;
>
>         /* caller holds info->resize_lock */
>       info->resize_dpy = 0;
>       xenfb_do_resize(info);
> }
>
> static int xenfb_thread(void *data)
> {
>       struct xenfb_info *info = data;
>       unsigned long flags;
>
>       while (!kthread_should_stop()) {
>               spin_lock_irqsave(info->resize_lock, flags);
>               if (info->resize_dpy)
>                       xenfb_resize_screen(info);
>               spin_unlock_irqrestore(info->resize_lock, flags);
> [...]
> }
> [...]
> static int xenfb_set_par(struct fb_info *info)
> {
>       struct xenfb_info *xenfb_info = info->par;
>       unsigned long flags;
>
>       spin_lock_irqsave(info->resize_lock, flags);
>       info->var.xres_virtual = info->var.xres;
>       info->var.yres_virtual = info->var.yres;
>       xenfb_info->resize_dpy = 1;
>       spin_unlock_irqrestore(info->resize_lock, flags);
>
>       if (xenfb_info->kthread) {
>               /* Wake up xenfb_thread() */
>               xenfb_refresh(xenfb_info, INT_MAX, INT_MAX, 0, 0);
>       }
>       return 0;
> }
>
> Note that xenfb_set_par() can schedule resolution changes just fine
> before xenfb_thread() runs.  It'll pick them up right when it starts.
>
> I used xenfb_refresh() to wake up xenfb_thread() only to keep things
> simple, not to express a preference for that method.
>
> Don't just copy my code sketch!  Review it carefully, please.
>
>   
>> -------------------
>> New lock comment
>>
>> /*
>>  * There are three locks: spinlock resize_lock protecting resize_dpy,
>>     
>
> It actually protects the screen size and resize_dpy.
>
>   
>>  * spinlock dirty_lock protecting the dirty rectangle and mutex
>>  * mm_lock protecting mappings.
>>  *
>>  * resize_lock is used to synchronize resize_dpy access between
>>  * xenfb_set_par() and xenfb_do_resize() running in xenfb_thread().
>>  *
>>  * How the dirty and mapping locks work together
>>  *
>> ..........
>>
>>
>>     
>>> I think you could fix the old code by protecting access to the shared
>>> resolution state by a spin lock.
>>>
>>> If I am missing something, and your new code is the way to go, you
>>> still need to migrate your explanation why it works from e-mail to
>>> source file, where the poor maintainer can find it.
>>>
>>> [...]
>>>
>>> Looks like this is the last issue that you haven't addressed /
>>> explained fully yet :)
>>>
>>>   
>>>       
>> Yahoo, getting close. Thanks
>>
>> Just an FYI, I am at Brainshare this week so my responses might be a
>> little slow but I will try to turn around any comments I receive as soon
>> as possible.  Like to put this to bed before any more staging changes
>> take place.
>>     
>
> Me too!  And thanks for pushing this feature all the way.
>
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@xxxxxxxxxxxxxxxxxxx
> http://lists.xensource.com/xen-devel
>   
I have attached front and back for your review.  Back has not changed
except to include opengl changes. Front has synchronization fix.  I
added a spin lock and struct xenfb_resize into struct xenfb.  struct
xenfb_resize was added to protect the screen size values from changes
outside the driver.  IE User application calls to ioctl(fb,
FBIOPUT_VSCREENINFO, &fb_var); while the driver is processing a previous
call.


diff -r 76c9cf11ce23 tools/ioemu/hw/xenfb.c
--- a/tools/ioemu/hw/xenfb.c    Fri Mar 21 09:45:34 2008 +0000
+++ b/tools/ioemu/hw/xenfb.c    Sun Mar 23 19:38:17 2008 -0600
@@ -516,6 +516,16 @@ static void xenfb_on_fb_event(struct xen
                        }
                        xenfb_guest_copy(xenfb, x, y, w, h);
                        break;
+               case XENFB_TYPE_RESIZE:
+                       xenfb->width  = event->resize.width;
+                       xenfb->height = event->resize.height;
+                       xenfb->row_stride = event->resize.stride;
+                       dpy_colourdepth(xenfb->ds, xenfb->depth);
+                       dpy_resize(xenfb->ds, xenfb->width, xenfb->height, 
xenfb->row_stride);
+                       if (xenfb->ds->shared_buf)
+                               dpy_setdata(xenfb->ds, xenfb->pixels);
+                       xenfb_invalidate(xenfb);
+                       break;
                }
        }
        xen_mb();               /* ensure we're done with ring contents */
@@ -680,6 +690,7 @@ static int xenfb_read_frontend_fb_config
 static int xenfb_read_frontend_fb_config(struct xenfb *xenfb) {
        struct xenfb_page *fb_page;
        int val;
+       int videoram;
 
         if (xenfb_xs_scanf1(xenfb->xsh, xenfb->fb.otherend, "feature-update",
                             "%d", &val) < 0)
@@ -702,10 +713,30 @@ static int xenfb_read_frontend_fb_config
         /* TODO check for consistency with the above */
         xenfb->fb_len = fb_page->mem_length;
         xenfb->row_stride = fb_page->line_length;
+
+        /* Protect against hostile frontend, limit fb_len to max allowed */
+        if (xenfb_xs_scanf1(xenfb->xsh, xenfb->fb.nodename, "videoram", "%d",
+                            &videoram) < 0)
+                videoram = 0;
+        videoram = videoram * 1024 * 1024;
+        if (videoram && xenfb->fb_len > videoram) {
+                fprintf(stderr, "Framebuffer requested length of %zd exceeded 
allowed %d\n",
+                        xenfb->fb_len, videoram);
+                xenfb->fb_len = videoram;
+                if (xenfb->row_stride * xenfb->height > xenfb->fb_len)
+                        xenfb->height = xenfb->fb_len / xenfb->row_stride;
+        }
         fprintf(stderr, "Framebuffer depth %d width %d height %d line %d\n",
                 fb_page->depth, fb_page->width, fb_page->height, 
fb_page->line_length);
         if (xenfb_map_fb(xenfb, xenfb->fb.otherend_id) < 0)
                return -1;
+
+        /* Indicate we have the frame buffer resize feature */
+        xenfb_xs_printf(xenfb->xsh, xenfb->fb.nodename, "feature-resize", "1");
+
+        /* Tell kbd pointer the screen geometry */
+        xenfb_xs_printf(xenfb->xsh, xenfb->kbd.nodename, "width", "%d", 
xenfb->width);
+        xenfb_xs_printf(xenfb->xsh, xenfb->kbd.nodename, "height", "%d", 
xenfb->height);
 
         if (xenfb_switch_state(&xenfb->fb, XenbusStateConnected))
                 return -1;
diff -r 76c9cf11ce23 tools/python/xen/xend/server/vfbif.py
--- a/tools/python/xen/xend/server/vfbif.py     Fri Mar 21 09:45:34 2008 +0000
+++ b/tools/python/xen/xend/server/vfbif.py     Sun Mar 23 08:08:09 2008 -0600
@@ -6,7 +6,7 @@ import os
 import os
 
 CONFIG_ENTRIES = ['type', 'vncdisplay', 'vnclisten', 'vncpasswd', 'vncunused',
-                  'display', 'xauthority', 'keymap',
+                  'videoram', 'display', 'xauthority', 'keymap',
                   'uuid', 'location', 'protocol', 'opengl']
 
 class VfbifController(DevController):
diff -r 76c9cf11ce23 tools/python/xen/xm/create.py
--- a/tools/python/xen/xm/create.py     Fri Mar 21 09:45:34 2008 +0000
+++ b/tools/python/xen/xm/create.py     Sun Mar 23 08:10:23 2008 -0600
@@ -500,6 +500,11 @@ gopts.var('vncunused', val='',
           use="""Try to find an unused port for the VNC server.
           Only valid when vnc=1.""")
 
+gopts.var('videoram', val='',
+          fn=set_value, default=None,
+          use="""Maximum amount of videoram PV guest can allocate
+          for frame buffer.""")
+
 gopts.var('sdl', val='',
           fn=set_value, default=None,
           use="""Should the device model use SDL?""")
@@ -645,7 +650,8 @@ def configure_vfbs(config_devs, vals):
             d['type'] = 'sdl'
         for (k,v) in d.iteritems():
             if not k in [ 'vnclisten', 'vncunused', 'vncdisplay', 'display',
-                          'xauthority', 'type', 'vncpasswd', 'opengl' ]:
+                          'videoram', 'xauthority', 'type', 'vncpasswd',
+                          'opengl' ]:
                 err("configuration option %s unknown to vfbs" % k)
             config.append([k,v])
         if not d.has_key("keymap"):
diff -r 76c9cf11ce23 xen/include/public/io/fbif.h
--- a/xen/include/public/io/fbif.h      Fri Mar 21 09:45:34 2008 +0000
+++ b/xen/include/public/io/fbif.h      Sun Mar 23 08:05:53 2008 -0600
@@ -50,12 +50,28 @@ struct xenfb_update
     int32_t height; /* rect height */
 };
 
+/*
+ * Framebuffer resize notification event
+ * Capable backend sets feature-resize in xenstore.
+ */
+#define XENFB_TYPE_RESIZE 3
+
+struct xenfb_resize
+{
+    uint8_t type;    /* XENFB_TYPE_RESIZE */
+    int32_t width;   /* width in pixels */
+    int32_t height;  /* height in pixels */
+    int32_t stride;  /* stride in bytes */
+    int32_t depth;   /* depth in bits */
+};
+
 #define XENFB_OUT_EVENT_SIZE 40
 
 union xenfb_out_event
 {
     uint8_t type;
     struct xenfb_update update;
+    struct xenfb_resize resize;
     char pad[XENFB_OUT_EVENT_SIZE];
 };
 
@@ -109,15 +125,17 @@ struct xenfb_page
      * Each directory page holds PAGE_SIZE / sizeof(*pd)
      * framebuffer pages, and can thus map up to PAGE_SIZE *
      * PAGE_SIZE / sizeof(*pd) bytes.  With PAGE_SIZE == 4096 and
-     * sizeof(unsigned long) == 4, that's 4 Megs.  Two directory
-     * pages should be enough for a while.
+     * sizeof(unsigned long) == 4/8, that's 4 Megs 32 bit and 2 Megs
+     * 64 bit.  256 directories give enough room for a 512 Meg
+     * framebuffer with a max resolution of 12,800x10,240.  Should
+     * be enough for a while with room leftover for expansion.
      */
-    unsigned long pd[2];
+    unsigned long pd[256];
 };
 
 /*
- * Wart: xenkbd needs to know resolution.  Put it here until a better
- * solution is found, but don't leak it to the backend.
+ * Wart: xenkbd needs to know default resolution.  Put it here until a
+ * better solution is found, but don't leak it to the backend.
  */
 #ifdef __KERNEL__
 #define XENFB_WIDTH 800
diff -r de57c3f218fb drivers/xen/fbfront/xenfb.c
--- a/drivers/xen/fbfront/xenfb.c       Thu Mar 20 11:35:25 2008 +0000
+++ b/drivers/xen/fbfront/xenfb.c       Sun Mar 23 19:52:17 2008 -0600
@@ -62,15 +62,21 @@ struct xenfb_info
        struct xenfb_page       *page;
        unsigned long           *mfns;
        int                     update_wanted; /* XENFB_TYPE_UPDATE wanted */
+       int                     feature_resize; /* Backend has resize feature */
+       struct xenfb_resize     resize;
+       int                     resize_dpy;
+       spinlock_t              resize_lock;
 
        struct xenbus_device    *xbdev;
 };
 
 /*
- * How the locks work together
- *
- * There are two locks: spinlock dirty_lock protecting the dirty
- * rectangle, and mutex mm_lock protecting mappings.
+ * There are three locks:
+ *    spinlock resize_lock protecting resize_dpy and screen size
+ *    spinlock dirty_lock protecting the dirty rectangle
+ *    mutex mm_lock protecting mappings.
+ *
+ * How the dirty and mapping locks work together
  *
  * The problem is that dirty rectangle and mappings aren't
  * independent: the dirty rectangle must cover all faulted pages in
@@ -129,20 +135,41 @@ struct xenfb_info
  *
  * Oh well, we wont be updating the writes to this page anytime soon.
  */
+#define MB_ (1024*1024)
+#define XENFB_DEFAULT_FB_LEN (XENFB_WIDTH * XENFB_HEIGHT * XENFB_DEPTH / 8)
+
+enum {KPARAM_MEM, KPARAM_WIDTH, KPARAM_HEIGHT, KPARAM_CNT};
+static int video[KPARAM_CNT] = {2, XENFB_WIDTH, XENFB_HEIGHT};
+module_param_array(video, int, NULL, 0);
+MODULE_PARM_DESC(video,
+               "Size of video memory in MB and width,height in pixels, default 
= (2,800,600)");
 
 static int xenfb_fps = 20;
-static unsigned long xenfb_mem_len = XENFB_WIDTH * XENFB_HEIGHT * XENFB_DEPTH 
/ 8;
 
 static int xenfb_remove(struct xenbus_device *);
-static void xenfb_init_shared_page(struct xenfb_info *);
+static void xenfb_init_shared_page(struct xenfb_info *, struct fb_info *);
 static int xenfb_connect_backend(struct xenbus_device *, struct xenfb_info *);
 static void xenfb_disconnect_backend(struct xenfb_info *);
 
+static void xenfb_send_event(struct xenfb_info *info,
+               union xenfb_out_event *event)
+{
+       __u32 prod;
+
+       prod = info->page->out_prod;
+       /* caller ensures !xenfb_queue_full() */
+       mb();                   /* ensure ring space available */
+       XENFB_OUT_RING_REF(info->page, prod) = *event;
+       wmb();                  /* ensure ring contents visible */
+       info->page->out_prod = prod + 1;
+
+       notify_remote_via_irq(info->irq);
+}
+
 static void xenfb_do_update(struct xenfb_info *info,
                            int x, int y, int w, int h)
 {
        union xenfb_out_event event;
-       __u32 prod;
 
        event.type = XENFB_TYPE_UPDATE;
        event.update.x = x;
@@ -150,14 +177,22 @@ static void xenfb_do_update(struct xenfb
        event.update.width = w;
        event.update.height = h;
 
-       prod = info->page->out_prod;
        /* caller ensures !xenfb_queue_full() */
-       mb();                   /* ensure ring space available */
-       XENFB_OUT_RING_REF(info->page, prod) = event;
-       wmb();                  /* ensure ring contents visible */
-       info->page->out_prod = prod + 1;
-
-       notify_remote_via_irq(info->irq);
+       xenfb_send_event(info, &event);
+}
+
+static void xenfb_do_resize(struct xenfb_info *info)
+{
+       union xenfb_out_event event;
+
+       event.type = XENFB_TYPE_RESIZE;
+       event.resize.width = info->resize.width;
+       event.resize.height = info->resize.height;
+       event.resize.stride = info->resize.stride;
+       event.resize.depth = info->resize.depth;
+
+       /* caller ensures !xenfb_queue_full() */
+       xenfb_send_event(info, &event);
 }
 
 static int xenfb_queue_full(struct xenfb_info *info)
@@ -209,11 +244,26 @@ static void xenfb_update_screen(struct x
        xenfb_do_update(info, x1, y1, x2 - x1, y2 - y1);
 }
 
+static void xenfb_handle_resize_dpy(struct xenfb_info *info)
+{
+       int flags;
+
+       spin_lock_irqsave(&info->resize_lock, flags);
+       if (info->resize_dpy) {
+               if (!xenfb_queue_full(info)) {
+                       info->resize_dpy = 0;
+                       xenfb_do_resize(info);
+               }
+       }
+       spin_unlock_irqrestore(&info->resize_lock, flags);
+}
+
 static int xenfb_thread(void *data)
 {
        struct xenfb_info *info = data;
 
        while (!kthread_should_stop()) {
+               xenfb_handle_resize_dpy(info);
                if (info->dirty) {
                        info->dirty = 0;
                        xenfb_update_screen(info);
@@ -413,6 +463,55 @@ static int xenfb_mmap(struct fb_info *fb
        return 0;
 }
 
+static int
+xenfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+       struct xenfb_info *xenfb_info;
+       int required_mem_len;
+
+       xenfb_info = info->par;
+
+       if (!xenfb_info->feature_resize) {
+               if (var->xres == video[KPARAM_WIDTH] &&
+                       var->yres == video[KPARAM_HEIGHT] &&
+                       var->bits_per_pixel == xenfb_info->page->depth) {
+                       return 0;
+               }
+               return -EINVAL;
+       }
+
+       /* Can't resize past initial width and height */
+       if (var->xres > video[KPARAM_WIDTH] || var->yres > video[KPARAM_HEIGHT])
+               return -EINVAL;
+
+       required_mem_len = var->xres * var->yres * (xenfb_info->page->depth / 
8);
+       if (var->bits_per_pixel == xenfb_info->page->depth &&
+               var->xres <= info->fix.line_length / (XENFB_DEPTH / 8) &&
+               required_mem_len <= info->fix.smem_len) {
+               var->xres_virtual = var->xres;
+               var->yres_virtual = var->yres;
+               return 0;
+       }
+       return -EINVAL;
+}
+
+static int xenfb_set_par(struct fb_info *info)
+{
+       struct xenfb_info *xenfb_info;
+       unsigned long flags;
+
+       xenfb_info = info->par;
+
+       spin_lock_irqsave(&xenfb_info->resize_lock, flags);
+       xenfb_info->resize.width = info->var.xres;
+       xenfb_info->resize.height = info->var.yres;
+       xenfb_info->resize.stride = info->fix.line_length;
+       xenfb_info->resize.depth = info->var.bits_per_pixel;
+       xenfb_info->resize_dpy = 1;
+       spin_unlock_irqrestore(&xenfb_info->resize_lock, flags);
+       return 0;
+}
+
 static struct fb_ops xenfb_fb_ops = {
        .owner          = THIS_MODULE,
        .fb_setcolreg   = xenfb_setcolreg,
@@ -420,6 +519,8 @@ static struct fb_ops xenfb_fb_ops = {
        .fb_copyarea    = xenfb_copyarea,
        .fb_imageblit   = xenfb_imageblit,
        .fb_mmap        = xenfb_mmap,
+       .fb_check_var   = xenfb_check_var,
+       .fb_set_par     = xenfb_set_par,
 };
 
 static irqreturn_t xenfb_event_handler(int rq, void *dev_id,
@@ -450,6 +551,8 @@ static int __devinit xenfb_probe(struct 
 {
        struct xenfb_info *info;
        struct fb_info *fb_info;
+       int fb_size;
+       int val;
        int ret;
 
        info = kzalloc(sizeof(*info), GFP_KERNEL);
@@ -457,11 +560,27 @@ static int __devinit xenfb_probe(struct 
                xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");
                return -ENOMEM;
        }
+
+       /* Limit kernel param videoram amount to what is in xenstore */
+       if (xenbus_scanf(XBT_NIL, dev->otherend, "videoram", "%d", &val) == 1) {
+               if (val < video[KPARAM_MEM])
+                       video[KPARAM_MEM] = val;
+       }
+
+       /* If requested res does not fit in available memory, use default */
+       fb_size = video[KPARAM_MEM] * MB_;
+       if (video[KPARAM_WIDTH] * video[KPARAM_HEIGHT] * XENFB_DEPTH/8 > 
fb_size) {
+               video[KPARAM_WIDTH] = XENFB_WIDTH;
+               video[KPARAM_HEIGHT] = XENFB_HEIGHT;
+               fb_size = XENFB_DEFAULT_FB_LEN;
+       }
+
        dev->dev.driver_data = info;
        info->xbdev = dev;
        info->irq = -1;
        info->x1 = info->y1 = INT_MAX;
        spin_lock_init(&info->dirty_lock);
+       spin_lock_init(&info->resize_lock);
        mutex_init(&info->mm_lock);
        init_waitqueue_head(&info->wq);
        init_timer(&info->refresh);
@@ -469,12 +588,12 @@ static int __devinit xenfb_probe(struct 
        info->refresh.data = (unsigned long)info;
        INIT_LIST_HEAD(&info->mappings);
 
-       info->fb = vmalloc(xenfb_mem_len);
+       info->fb = vmalloc(fb_size);
        if (info->fb == NULL)
                goto error_nomem;
-       memset(info->fb, 0, xenfb_mem_len);
-
-       info->nr_pages = (xenfb_mem_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+       memset(info->fb, 0, fb_size);
+
+       info->nr_pages = (fb_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
 
        info->pages = kmalloc(sizeof(struct page *) * info->nr_pages,
                              GFP_KERNEL);
@@ -489,8 +608,6 @@ static int __devinit xenfb_probe(struct 
        info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
        if (!info->page)
                goto error_nomem;
-
-       xenfb_init_shared_page(info);
 
        fb_info = framebuffer_alloc(sizeof(u32) * 256, NULL);
                                /* see fishy hackery below */
@@ -504,9 +621,9 @@ static int __devinit xenfb_probe(struct 
        fb_info->screen_base = info->fb;
 
        fb_info->fbops = &xenfb_fb_ops;
-       fb_info->var.xres_virtual = fb_info->var.xres = info->page->width;
-       fb_info->var.yres_virtual = fb_info->var.yres = info->page->height;
-       fb_info->var.bits_per_pixel = info->page->depth;
+       fb_info->var.xres_virtual = fb_info->var.xres = video[KPARAM_WIDTH];
+       fb_info->var.yres_virtual = fb_info->var.yres = video[KPARAM_HEIGHT];
+       fb_info->var.bits_per_pixel = XENFB_DEPTH;
 
        fb_info->var.red = (struct fb_bitfield){16, 8, 0};
        fb_info->var.green = (struct fb_bitfield){8, 8, 0};
@@ -518,9 +635,9 @@ static int __devinit xenfb_probe(struct 
        fb_info->var.vmode = FB_VMODE_NONINTERLACED;
 
        fb_info->fix.visual = FB_VISUAL_TRUECOLOR;
-       fb_info->fix.line_length = info->page->line_length;
+       fb_info->fix.line_length = fb_info->var.xres * (XENFB_DEPTH / 8);
        fb_info->fix.smem_start = 0;
-       fb_info->fix.smem_len = xenfb_mem_len;
+       fb_info->fix.smem_len = fb_size;
        strcpy(fb_info->fix.id, "xen");
        fb_info->fix.type = FB_TYPE_PACKED_PIXELS;
        fb_info->fix.accel = FB_ACCEL_NONE;
@@ -533,6 +650,8 @@ static int __devinit xenfb_probe(struct 
                xenbus_dev_fatal(dev, ret, "fb_alloc_cmap");
                goto error;
        }
+
+       xenfb_init_shared_page(info, fb_info);
 
        ret = register_framebuffer(fb_info);
        if (ret) {
@@ -571,7 +690,7 @@ static int xenfb_resume(struct xenbus_de
        struct xenfb_info *info = dev->dev.driver_data;
 
        xenfb_disconnect_backend(info);
-       xenfb_init_shared_page(info);
+       xenfb_init_shared_page(info, info->fb_info);
        return xenfb_connect_backend(dev, info);
 }
 
@@ -597,9 +716,11 @@ static int xenfb_remove(struct xenbus_de
        return 0;
 }
 
-static void xenfb_init_shared_page(struct xenfb_info *info)
+static void xenfb_init_shared_page(struct xenfb_info *info,
+                                   struct fb_info * fb_info)
 {
        int i;
+       int epd = PAGE_SIZE / sizeof(info->mfns[0]);
 
        for (i = 0; i < info->nr_pages; i++)
                info->pages[i] = vmalloc_to_page(info->fb + i * PAGE_SIZE);
@@ -607,13 +728,14 @@ static void xenfb_init_shared_page(struc
        for (i = 0; i < info->nr_pages; i++)
                info->mfns[i] = vmalloc_to_mfn(info->fb + i * PAGE_SIZE);
 
-       info->page->pd[0] = vmalloc_to_mfn(info->mfns);
-       info->page->pd[1] = 0;
-       info->page->width = XENFB_WIDTH;
-       info->page->height = XENFB_HEIGHT;
-       info->page->depth = XENFB_DEPTH;
-       info->page->line_length = (info->page->depth / 8) * info->page->width;
-       info->page->mem_length = xenfb_mem_len;
+       for (i = 0; i * epd < info->nr_pages; i++)
+               info->page->pd[i] = vmalloc_to_mfn(&info->mfns[i * epd]);
+
+       info->page->width = fb_info->var.xres;
+       info->page->height = fb_info->var.yres;
+       info->page->depth = fb_info->var.bits_per_pixel;
+       info->page->line_length = fb_info->fix.line_length;
+       info->page->mem_length = fb_info->fix.smem_len;
        info->page->in_cons = info->page->in_prod = 0;
        info->page->out_cons = info->page->out_prod = 0;
 }
@@ -712,6 +834,11 @@ static void xenfb_backend_changed(struct
                        val = 0;
                if (val)
                        info->update_wanted = 1;
+
+               if (xenbus_scanf(XBT_NIL, dev->otherend,
+                                       "feature-resize", "%d", &val) < 0)
+                       val = 0;
+               info->feature_resize = val;
                break;
 
        case XenbusStateClosing:
diff -r de57c3f218fb drivers/xen/fbfront/xenkbd.c
--- a/drivers/xen/fbfront/xenkbd.c      Thu Mar 20 11:35:25 2008 +0000
+++ b/drivers/xen/fbfront/xenkbd.c      Sun Mar 23 08:04:40 2008 -0600
@@ -297,6 +297,16 @@ static void xenkbd_backend_changed(struc
                 */
                if (dev->state != XenbusStateConnected)
                        goto InitWait; /* no InitWait seen yet, fudge it */
+
+               /* Set input abs params to match backend screen res */
+               if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,
+                                  "width", "%d", &val) > 0 )
+                       input_set_abs_params(info->ptr, ABS_X, 0, val, 0, 0);
+
+               if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,
+                                  "height", "%d", &val) > 0 )
+                       input_set_abs_params(info->ptr, ABS_Y, 0, val, 0, 0);
+
                break;
 
        case XenbusStateClosing:
diff -r de57c3f218fb include/xen/interface/io/fbif.h
--- a/include/xen/interface/io/fbif.h   Thu Mar 20 11:35:25 2008 +0000
+++ b/include/xen/interface/io/fbif.h   Sun Mar 23 08:04:40 2008 -0600
@@ -50,12 +50,28 @@ struct xenfb_update
     int32_t height; /* rect height */
 };
 
+/*
+ * Framebuffer resize notification event
+ * Capable backend sets feature-resize in xenstore.
+ */
+#define XENFB_TYPE_RESIZE 3
+
+struct xenfb_resize
+{
+    uint8_t type;    /* XENFB_TYPE_RESIZE */
+    int32_t width;   /* width in pixels */
+    int32_t height;  /* height in pixels */
+    int32_t stride;  /* stride in bytes */
+    int32_t depth;   /* depth in bits */
+};
+
 #define XENFB_OUT_EVENT_SIZE 40
 
 union xenfb_out_event
 {
     uint8_t type;
     struct xenfb_update update;
+    struct xenfb_resize resize;
     char pad[XENFB_OUT_EVENT_SIZE];
 };
 
@@ -109,15 +125,17 @@ struct xenfb_page
      * Each directory page holds PAGE_SIZE / sizeof(*pd)
      * framebuffer pages, and can thus map up to PAGE_SIZE *
      * PAGE_SIZE / sizeof(*pd) bytes.  With PAGE_SIZE == 4096 and
-     * sizeof(unsigned long) == 4, that's 4 Megs.  Two directory
-     * pages should be enough for a while.
+     * sizeof(unsigned long) == 4/8, that's 4 Megs 32 bit and 2 Megs
+     * 64 bit.  256 directories give enough room for a 512 Meg
+     * framebuffer with a max resolution of 12,800x10,240.  Should
+     * be enough for a while with room leftover for expansion.
      */
-    unsigned long pd[2];
+    unsigned long pd[256];
 };
 
 /*
- * Wart: xenkbd needs to know resolution.  Put it here until a better
- * solution is found, but don't leak it to the backend.
+ * Wart: xenkbd needs to know default resolution.  Put it here until a
+ * better solution is found, but don't leak it to the backend.
  */
 #ifdef __KERNEL__
 #define XENFB_WIDTH 800
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel