viernes, 29 de abril de 2011

Linux courses from now to july , free your mind

Upcoming Linux Training Opportunities <==

The following Linux training courses this month come with an exclusive 10% off discount to recipients of this newsletter. Enter APRTRN11 when registering.

Developing Linux Device Drivers
July 25 - July 29, 2011

Linux Kernel Internals and Debugging                     

July 11 - July 15, 2011

Open Source Compliance Programs: What You Must Know
July 19, 2011

To review all courses, please visit:

Also get Linux Foundation Training information, updates and discounts
on Twitter:

==> The Linux Foundation in the News <==

The Business Insider
From the Dorm Room to the Smartphone: The Incredible 20-Year Story of Linux
Today in Tech: Linux Turns 20

Linux Foundation Announces Designated Gurus for 2011

LinuxCon to Feature Red Hat, WebOS, Ubuntu and More as Linux Turns 20

Linux High Availability Group Working on Critical Enterprise Application Stack

20 Years of Linux Video Competition to be Judged by Linus Torvalds

Top 5 Takeaways from Linux Foundation Collaboration Summit 2011

Android Chief: We're Still Open

To no longer receive the The Linux Foundation Monthly Newsletter, please click here:

Programacion de un os , base linux.

Pues aqui pongo código de los desarrolladores de linux. Para qeu se den una idea de como utilizar la planificacion de procesos

I changed the logic a little and add a filter for skipping nodes.
With large NUMA, tasks may under cpuset or mempolicy and the usage of memory
can be unbalanced. So, I think a filter is required.
Now, memory cgroup's direct reclaim frees memory from the current node.
But this has some troubles. In usual, when a set of threads works in
cooperative way, they are tend to on the same node. So, if they hit
limits under memcg, it will reclaim memory from themselves, it may be
active working set.
For example, assume 2 node system which has Node 0 and Node 1
and a memcg which has 1G limit. After some work, file cacne remains and
and usages are
   Node 0:  1M
   Node 1:  998M.
and run an application on Node 0, it will eats its foot before freeing
unnecessary file caches.
This patch adds round-robin for NUMA and adds equal pressure to each
node. When using cpuset's spread memory feature, this will work very well.
From: Ying Han
Signed-off-by: Ying Han
Signed-off-by: KAMEZAWA Hiroyuki
Changelog v1->v2:
  - fixed comments.
  - added a logic to avoid scanning unused node.
 include/linux/memcontrol.h |    1
 mm/memcontrol.c            |   98 ++++++++++++++++++++++++++++++++++++++++++---
 mm/vmscan.c                |    9 +++-
 3 files changed, 101 insertions(+), 7 deletions(-)
Index: memcg/include/linux/memcontrol.h
--- memcg.orig/include/linux/memcontrol.h
+++ memcg/include/linux/memcontrol.h
@@ -108,6 +108,7 @@ extern void mem_cgroup_end_migration(str
 int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg);
 int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg);
+int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
 unsigned long mem_cgroup_zone_nr_pages(struct mem_cgroup *memcg,
                                       struct zone *zone,
                                       enum lru_list lru);
Index: memcg/mm/memcontrol.c
--- memcg.orig/mm/memcontrol.c
+++ memcg/mm/memcontrol.c
@@ -237,6 +237,11 @@ struct mem_cgroup {
         * reclaimed from.
        int last_scanned_child;
+       int last_scanned_node;
+       nodemask_t      scan_nodes;
+       unsigned long   next_scan_node_update;
         * Should the accounting and control be hierarchical, per subtree?
@@ -650,18 +655,27 @@ static void mem_cgroup_soft_scan(struct
        this_cpu_add(mem->stat->events[MEM_CGROUP_EVENTS_SOFT_SCAN], val);
+static unsigned long
+mem_cgroup_get_zonestat_node(struct mem_cgroup *mem, int nid, enum lru_list idx)
+       struct mem_cgroup_per_zone *mz;
+       u64 total;
+       int zid;
+       for (zid = 0; zid < MAX_NR_ZONES; zid++) {
+               mz = mem_cgroup_zoneinfo(mem, nid, zid);
+               total += MEM_CGROUP_ZSTAT(mz, idx);
+       }
+       return total;
 static unsigned long mem_cgroup_get_local_zonestat(struct mem_cgroup *mem,
                                        enum lru_list idx)
-       int nid, zid;
-       struct mem_cgroup_per_zone *mz;
+       int nid;
        u64 total = 0;
-               for (zid = 0; zid < MAX_NR_ZONES; zid++) {
-                       mz = mem_cgroup_zoneinfo(mem, nid, zid);
-                       total += MEM_CGROUP_ZSTAT(mz, idx);
-               }
+               total += mem_cgroup_get_zonestat_node(mem, nid, idx);
        return total;
@@ -1471,6 +1485,77 @@ mem_cgroup_select_victim(struct mem_cgro
        return ret;
+ * Update nodemask always is not very good. Even if we have empty
+ * list, or wrong list here, we can start from some node and traverse all nodes
+ * based on zonelist. So, update the list loosely once in 10 secs.
+ *
+ */
+static void mem_cgroup_may_update_nodemask(struct mem_cgroup *mem)
+       int nid;
+       if (time_after(mem->next_scan_node_update, jiffies))
+               return;
+       mem->next_scan_node_update = jiffies + 10*HZ;
+       /* make a nodemask where this memcg uses memory from */
+       mem->scan_nodes = node_states[N_HIGH_MEMORY];
+       for_each_node_mask(nid, node_states[N_HIGH_MEMORY]) {
+               if (mem_cgroup_get_zonestat_node(mem, nid, LRU_INACTIVE_FILE) ||
+                   mem_cgroup_get_zonestat_node(mem, nid, LRU_ACTIVE_FILE))
+                       continue;
+               if (total_swap_pages &&
+                   (mem_cgroup_get_zonestat_node(mem, nid, LRU_INACTIVE_ANON) ||
+                    mem_cgroup_get_zonestat_node(mem, nid, LRU_ACTIVE_ANON)))
+                       continue;
+               node_clear(nid, mem->scan_nodes);
+       }
+ * Selecting a node where we start reclaim from. Because what we need is just
+ * reducing usage counter, start from anywhere is O,K. Considering
+ * memory reclaim from current node, there are pros. and cons.
+ *
+ * Freeing memory from current node means freeing memory from a node which
+ * we'll use or we've used. So, it may make LRU bad. And if several threads
+ * hit limits, it will see a contention on a node. But freeing from remote
+ * node means more costs for memory reclaim because of memory latency.
+ *
+ * Now, we use round-robin. Better algorithm is welcomed.
+ */
+int mem_cgroup_select_victim_node(struct mem_cgroup *mem)
+       int node;
+       mem_cgroup_may_update_nodemask(mem);
+       node = mem->last_scanned_node;
+       node = next_node(node, mem->scan_nodes);
+       if (node == MAX_NUMNODES) {
+               node = first_node(mem->scan_nodes);
+               if (unlikely(node == MAX_NUMNODES))
+                       node = numa_node_id();
+       }
+       mem->last_scanned_node = node;
+       return node;
+int mem_cgroup_select_victim_node(struct mem_cgroup *mem)
+       return 0;
  * Scan the hierarchy if needed to reclaim memory. We remember the last child
  * we reclaimed from, so that we don't end up penalizing one child extensively
@@ -4678,6 +4763,7 @@ mem_cgroup_create(struct cgroup_subsys *
                res_counter_init(&mem->memsw, NULL);
        mem->last_scanned_child = 0;
+       mem->last_scanned_node = MAX_NUMNODES;
        if (parent)
Index: memcg/mm/vmscan.c
--- memcg.orig/mm/vmscan.c
+++ memcg/mm/vmscan.c
@@ -2198,6 +2198,7 @@ unsigned long try_to_free_mem_cgroup_pag
        struct zonelist *zonelist;
        unsigned long nr_reclaimed;
+       int nid;
        struct scan_control sc = {
                .may_writepage = !laptop_mode,
                .may_unmap = 1,
@@ -2208,10 +2209,16 @@ unsigned long try_to_free_mem_cgroup_pag
                .mem_cgroup = mem_cont,
                .nodemask = NULL, /* we don't care the placement */
+       /*
+        * Unlike direct reclaim via alloc_pages(), memcg's reclaim
+        * don't take care of from where we get pages . So, the node where
+        * we start scan is not needed to be current node.
+        */
+       nid = mem_cgroup_select_victim_node(mem_cont);
        sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
                        (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
-       zonelist = NODE_DATA(numa_node_id())->node_zonelists;
+       zonelist = NODE_DATA(nid)->node_zonelists;
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to
More majordomo info at
Please read the FAQ at

domingo, 24 de abril de 2011

kernel noob development

hola, pues mas que nada es una nota para mí, ya que estoy empezando a hacer mi sistema , despues os cuento.

aquí esta una pequeña guía que un hacker empezó a hacer.

sábado, 23 de abril de 2011

Instalacion de virtual-box en ubuntu

Pues como me he enterado linux para muchos es ser alienijena ,pero la erdad ubuntu es un sustema tan amigable como windows pero con la ventaja de que es open source .

Los pasos para instalar virtual-box dentro del sistema libre es:

1.- si el sistema esta en kde o gnome es casi lo mismo , lo que sucede es que utilizaremos sipnactic para la instalacion

2.- dentro del escritorio nos vamos a sistema , admnistracion. Y ahi estará sipnactic , un gestor de instalacion para hacer mas rapido su uso.

3.- en el buscador de sipnactic colocamos el nombre de virtual box gmd , nos indicara que tenemos que instalar varias cosas a parte de esta .

4.- le damos permiso de que se instalen y colocamos nuestra contraseña de superroot .

5.- dejamos instalar y yap ! Para iniciar , dentro de una terminal , con alt+f2 colocamos virtual-box , y yap podemos crear nuestros discos duros virtuales

Pd: estare subiendo info oara hacer un raw disk a partir de nuestra particion podamos hacer un .v

Redes en windows

Hola , pues es de hecho muy rapido crear una red en windows , solamente tenemos que hacaer lo siguiente :

1.- crear una carpeta compartida , sea la que sea.

2.- en el caso de windows 7 solamente quitamos dentro del panel de control , en configuracion de redes

Nos vamos a hogar, para hacerla de rapido uso .

3.- dentro de ahi enn propiedades avanzadas hasta abajo , hay una configuracion de ecriptar la ttansferencia de datos .

4.- lo desactivamos para la transferencia de datos .

5.- igualmente para la proteccion co contraseña ,desactivamos esa opcion . Y listo

Pd : obiamente hay. Restricciones para Las configuraciones de cada comoutadora , como el firewall del antivirus.
Estaré subiendo mas informacion a cerca de configuraciones de redes tacnto en linux como en windows , si tienen alguna duda o sugerencia haganmela saber , saludos .

viernes, 22 de abril de 2011

100 mejores películas francesas

1. La evasión. Becker
2. La pasión de Juana de Arco. Dreyer
3. Shoah. Lanzmann
4. Un condenado a muerte se ha escapado. Bresson
5. El salario del miedo. Clouzot
6. Los niños del paraíso. Carné
7. La regla del juego. Renoir
8. La gran ilusión. Renoir
8. Los 400 golpes. Truffaut
9. Noche y niebla. Resnais
10. L'Atalante. Vigo
11. La edad de oro. Buñuel
12. Rififi. Dassin
13. Madame de...Ophüls
14. Las diabólicas. Clouzot
15. Napoleón. Gance
16. El muelle. Marker
17. Adiós, muchachos. Malle
18. Una partida de campo. Renoir
19. París bajos fondos. Becker
20. Pickpocket. Bresson
21. Mouchette. Bresson
22. Vivir su vida. Godard
23. Al azar de Baltasar. Bresson
24. El odio. Kassovitz
25. Juegos prohibidos. Clèment
26. Un perro andaluz. Buñuel / Dalí
27. La noche americana. Truffaut
28. Al final de la escapada. Godard
29. Viaje a la luna. Méliès
30. El placer. Ophüls
31. La ronda. Ophüls
32. El fuego fatuo. Malle
33. Persépolis. Satrapi / Paronnaud
34. Mi tío. Tati
35. El globo rojo. Lamorisse
36. El silencio de un hombre. Melville
37. Céline y Julia van en barco. Rivette
38. Jules y Jim. Truffaut
39. La bella y la bestia. Cocteau
40. Orfeo. Cocteau
41. El muelle de las brumas. Carné
42. Ascensor para el cadalso. Malle
43. Hiroshima, mi amor. Resnais
44. Viva la libertad. Clair
45. A pleno sol. Clément
46. Cero en conducta. Vigo
47. La bestia humana. Renoir
48. Las vacaciones del señor Hulot. Tati
49. Diario de un cura rural. Bresson
50. Mi noche con Maud. Rohmer
51. El confidente. Melville
52. Una mujer es una mujer. Godard
53. Banda aparte. Godard
54. La piel suave. Truffaut
55. L'amour fou. Rivette
56. El desprecio. Godard
57. El proceso. Welles
58. Belle de jour. Buñuel
59. El círculo rojo. Melville
60. El año pasado en Marienbad. Resnais
61. Pierrot el loco. Godard
62. El carnicero. Chabrol
63. El proceso de Juana de Arco. Bresson
64. Morir en Madrid. Rossif
65. La rodilla de Claire. Rohmer
66. Los paraguas de Cherburgo. Demy
67. Besos robados. Truffaut
68. El pequeño salvaje. Truffaut
69. La mujer infiel. Chabrol
70. La mamá y la puta. Eustache
71. El soplo al corazón. Malle
72. El discreto encanto de la burguesía. Buñuel
73. El amor después del mediodía. Rohmer
74. El fantasma de la libertad. Buñuel
75. El quimérico inquilino. Polanski
76. La piel dura. Truffaut
77. Estado de sitio. Costa-Gavras
78. El manantial de las colinas. Berri
79. La venganza de Manon. Berri
80. Alrededor de la medianoche. Tavernier
81. Monsieur Hire. Laconte
82. El rayo verde. Rohmer
83. Cyrano de Bergerac. Rappeneau
84. Hoy empieza todo. Tavernier
85. Leon (El profesional). Besson
86. La fortuna de vivir. Becker
87. Un corazón en invierno. Sautet
88. Los espigadores y la espigadora. Varda
89. Los juncos salvajes. Téchiné
90. Cuento de verano. Rohmer
91. Cuento de otoño. Rohmer
92. La ceremonia. Chabrol
93. Todas las mañanas del mundo. Corneau
94. Delicatessen. Jeunet / Caro
95. Enemigo a las puertas. Annaud
96. Quiéreme si te atreves. Samuell
97. Los chicos del coro. Barratier
98. El señor Ibrahim y las flores del Corán. Dupeyron
99. La pianista. Haneke
100. La escafandra y la mariposa. Schnabel

gracias a

intolerancia en viernes santo.(edad media)

Protestas e Intolerancia de la Iglesia Cristiana Medieval: El deseo de una experiencia religiosa más profunda y personal —que caracterizó al renacimiento espiritual de la Alta Edad Media— condujo al pueblo en direcciones hostiles a la iglesia institucional. A partir del siglo XII la herejía, la permanencia de las doctrinas religiosas diferentes de las enseñanzas ortodoxas de la iglesia, llegó a ser un problema para la iglesia católica.

La herejía mejor conocida de los siglos XII y XIII fue el catarismo. A los cátaros (la palabra cátaro significa «puro”) también se les conoció como albigenses, por la ciudad de Albi, una de sus fortalezas en el sur de Francia. Creían en un sistema dualista en que el bien y el mal eran entidades distintas y separadas. Las cosas del espíritu eran buenas, como creadas por el Dios de la luz; las cosas del mundo eran malas, ya que las había creado Satán, el príncipe de la oscuridad. Del mismo modo, los humanos estaban inmersos en el dualismo. Sus almas, que eran buenas, estaban atrapadas en cuerpos materiales, que eran malos.

Según los cátaros, la iglesia católica, una institución materialista, no tenía nada que ver con Dios, y era esencialmente mala. No había necesidad de seguir sus enseñanzas o de reconocer su autoridad. El movimiento de los cátaros tuvo gran apoyo por parte de importantes nobles del sur de Francia y norte de Italia.

gracias a para mas información.

Entradas populares